/******************************************************************************
 *                                                                            *
 * 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 <math.h>
#include <stdlib.h>
#include "iusace_type_def.h"
#include "iusace_cnst.h"
#include "iusace_bitbuffer.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 "ixheaace_memory_standards.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_config.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_fd_qc_util.h"
#include "iusace_fd_qc_adjthr.h"

VOID iusace_qc_create(ia_qc_main_struct *pstr_qc_main) {
  WORD32 i = 0;
  memset(pstr_qc_main, 0, sizeof(ia_qc_main_struct));

  for (i = 0; i < 2; i++) {
    memset(pstr_qc_main->str_qc_out.str_qc_out_chan[i].quant_spec, 0,
           sizeof(WORD16) * FRAME_LEN_LONG);
    memset(pstr_qc_main->str_qc_out.str_qc_out_chan[i].scalefactor, 0,
           sizeof(WORD16) * FRAME_LEN_LONG);
  }
  return;
}

VOID iusace_qc_init(ia_qc_data_struct *pstr_qc_data, const WORD32 max_bits, WORD32 sample_rate,
                    WORD32 bw_limit, WORD32 channels, WORD32 ccfl) {
  FLOAT32 mean_pe;
  pstr_qc_data->tot_avg_bits = pstr_qc_data->avg_bits;
  pstr_qc_data->static_bits = 1;
  pstr_qc_data->avg_bits = (pstr_qc_data->avg_bits - pstr_qc_data->static_bits);
  pstr_qc_data->max_bits = channels * max_bits;
  pstr_qc_data->max_bitres_bits = channels * max_bits - pstr_qc_data->tot_avg_bits;
  pstr_qc_data->max_bitres_bits =
      pstr_qc_data->max_bitres_bits - (pstr_qc_data->max_bitres_bits % 8);
  pstr_qc_data->bit_res_lvl = pstr_qc_data->max_bitres_bits;
  pstr_qc_data->padding = sample_rate;

  pstr_qc_data->max_bit_fac =
      (FLOAT32)channels * (max_bits - 744) /
      (FLOAT32)(pstr_qc_data->tot_avg_bits ? pstr_qc_data->tot_avg_bits : 1);
  mean_pe = 10.0f * ccfl * bw_limit / (sample_rate / 2.0f);

  iusace_adj_thr_init(&pstr_qc_data->str_adj_thr_ele, mean_pe,
                      (channels > 0) ? pstr_qc_data->ch_bitrate / channels : 0);

  return;
}

static WORD32 iusace_calc_frame_len(WORD32 bit_rate, WORD32 sample_rate, WORD32 mode,
                                    WORD32 ccfl) {
  WORD32 result;

  result = ((ccfl) >> 3) * (bit_rate);
  switch (mode) {
    case FRAME_LEN_BYTES_MODULO:
      result %= sample_rate;
      break;
    case FRAME_LEN_BYTES_INT:
      result /= sample_rate;
      break;
  }

  return (result);
}

static WORD32 iusace_get_frame_padding(WORD32 bit_rate, WORD32 sample_rate, WORD32 *padding,
                                       WORD32 ccfl) {
  WORD32 padding_on = 0;
  WORD32 difference;

  difference = iusace_calc_frame_len(bit_rate, sample_rate, FRAME_LEN_BYTES_MODULO, ccfl);

  *padding -= difference;

  if (*padding <= 0) {
    padding_on = 1;
    *padding += sample_rate;
  }

  return padding_on;
}

VOID iusace_adj_bitrate(ia_qc_data_struct *pstr_qc_data, WORD32 bit_rate, WORD32 sample_rate,
                        WORD32 ccfl) {
  WORD32 padding_on;
  WORD32 frame_len;
  WORD32 code_bits;
  WORD32 code_bits_prev;
  WORD32 total_bits = 0;

  padding_on = iusace_get_frame_padding(bit_rate, sample_rate, &pstr_qc_data->padding, ccfl);
  frame_len =
      padding_on + iusace_calc_frame_len(bit_rate, sample_rate, FRAME_LEN_BYTES_INT, ccfl);

  frame_len <<= 3;
  code_bits_prev = pstr_qc_data->tot_avg_bits - pstr_qc_data->static_bits;
  code_bits = frame_len - pstr_qc_data->static_bits;

  if (code_bits != code_bits_prev) {
    pstr_qc_data->avg_bits = (WORD32)code_bits;
    total_bits += pstr_qc_data->avg_bits;
    pstr_qc_data->avg_bits += code_bits - total_bits;
  }

  pstr_qc_data->tot_avg_bits = frame_len;

  return;
}

WORD32 iusace_calc_max_val_in_sfb(WORD32 sfb_count, WORD32 max_sfb_per_grp, WORD32 sfb_per_group,
                                  WORD32 *ptr_sfb_offset, WORD16 *ptr_quant_spec) {
  WORD32 sfb;
  WORD32 max = 0;
  WORD32 sfb_offs;

  for (sfb_offs = 0; sfb_offs < sfb_count; sfb_offs += sfb_per_group) {
    for (sfb = 0; sfb < max_sfb_per_grp; sfb++) {
      WORD32 line;
      WORD32 local_max = 0;
      for (line = ptr_sfb_offset[sfb + sfb_offs]; line < ptr_sfb_offset[sfb + sfb_offs + 1];
           line++) {
        if (abs(ptr_quant_spec[line]) > local_max) {
          local_max = abs(ptr_quant_spec[line]);
        }
      }
      if (local_max > max) {
        max = local_max;
      }
    }
  }

  return max;
}