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

 *                                                                            *

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

#include "impd_drc_uni_drc.h"

#include "impd_drc_tables.h"

#include "impd_drc_api.h"

#include "ixheaace_api.h"

#include "ixheaace_aac_constants.h"

#include "ixheaace_error_codes.h"

#include "ixheaac_error_standards.h"

#include <stdlib.h>

#include "ixheaace_psy_const.h"

#include "ixheaace_tns.h"

#include "ixheaace_tns_params.h"

#include "ixheaace_rom.h"

#include "ixheaace_common_rom.h"

#include "ixheaace_quant.h"

#include "ixheaace_block_switch.h"

#include "ixheaace_bitbuffer.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops16.h"

#include "ixheaac_basic_ops40.h"

#include "ixheaac_basic_ops.h"

#include "ixheaace_psy_const.h"

#include "ixheaace_tns.h"

#include "ixheaace_psy_data.h"

#include "ixheaace_interface.h"

#include "ixheaace_adjust_threshold_data.h"

#include "ixheaace_dynamic_bits.h"

#include "ixheaace_qc_data.h"

#include "ixheaace_adjust_threshold.h"

#include "ixheaace_sf_estimation.h"

#include "ixheaace_static_bits.h"

#include "ixheaace_bits_count.h"

#include "ixheaace_channel_map.h"

#include "ixheaace_write_bitstream.h"

#include "ixheaace_psy_configuration.h"

#include "ixheaace_psy_mod.h"

#include "ixheaace_tns_params.h"

#include "ixheaace_stereo_preproc.h"

#include "ixheaace_enc_main.h"

#include "ixheaace_qc_util.h"

#include "ixheaace_common_utils.h"

static WORD32 ia_enhaacplus_enc_calc_frame_len(WORD32 bit_rate, WORD32 sample_rate,

                                               FRAME_LEN_RESULT_MODE mode,

                                               WORD32 long_frame_len) {

  WORD32 result;

  result = ((long_frame_len) >> 3) * (bit_rate);

  switch (mode) {

    case FRAME_LEN_BYTES_MODULO:

      result %= sample_rate;

      break;

    case FRAME_LEN_BYTES_INT:

      result /= sample_rate;

      break;

    default:

      break;

  }

  return result;

}

static WORD32 ia_enhaacplus_enc_frame_padding(WORD32 bit_rate, WORD32 sample_rate,

                                              WORD32 *ptr_padding_rest, WORD32 frame_len_long) {

  WORD32 padding_on;

  WORD32 difference;

  padding_on = 0;

  difference = ia_enhaacplus_enc_calc_frame_len(bit_rate, sample_rate, FRAME_LEN_BYTES_MODULO,

                                                frame_len_long);

  *ptr_padding_rest -= difference;

  if (*ptr_padding_rest <= 0) {

    padding_on = 1;

    *ptr_padding_rest += sample_rate;

  }

  return padding_on;

}

IA_ERRORCODE ia_enhaacplus_enc_qc_out_new(ixheaace_qc_out *pstr_qc_out, WORD32 num_channels,

                                          WORD32 *ptr_shared_buffer1, WORD32 *ptr_shared_buffer3,

                                          WORD32 long_frame_len)

{

  WORD32 i;

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

    pstr_qc_out->qc_channel[i]->quant_spec = &((WORD16 *)ptr_shared_buffer1)[i * long_frame_len];

    memset(pstr_qc_out->qc_channel[i]->quant_spec, 0,

           sizeof(*pstr_qc_out->qc_channel[i]->quant_spec) * long_frame_len);

    pstr_qc_out->qc_channel[i]->max_val_in_sfb =

        &((UWORD16 *)&ptr_shared_buffer3[(long_frame_len + long_frame_len / 2) +

                                         IXHEAACE_MAX_CH_IN_BS_ELE *

                                             MAXIMUM_GROUPED_SCALE_FACTOR_BAND /

                                             2])[i * MAXIMUM_GROUPED_SCALE_FACTOR_BAND];

    memset(

        pstr_qc_out->qc_channel[i]->max_val_in_sfb, 0,

        sizeof(*pstr_qc_out->qc_channel[i]->max_val_in_sfb) * MAXIMUM_GROUPED_SCALE_FACTOR_BAND);

    pstr_qc_out->qc_channel[i]->scalefactor = &((WORD16 *)&ptr_shared_buffer3[(

        long_frame_len + long_frame_len / 2)])[i * MAXIMUM_GROUPED_SCALE_FACTOR_BAND];

    memset(pstr_qc_out->qc_channel[i]->scalefactor, 0,

           sizeof(*pstr_qc_out->qc_channel[i]->scalefactor) * MAXIMUM_GROUPED_SCALE_FACTOR_BAND);

  }

  if (pstr_qc_out == NULL) {

    return IA_EXHEAACE_INIT_FATAL_AAC_INIT_FAILED;

  }

  return IA_NO_ERROR;

}

IA_ERRORCODE ia_enhaacplus_enc_qc_new(ixheaace_qc_state *pstr_qc_state,

                                      WORD32 *ptr_shared_buffer_2, WORD32 long_frame_len

) {

  memset(pstr_qc_state, 0, sizeof(ixheaace_qc_state));

  pstr_qc_state->qc_scr.shared_buffer_2 =

      (ptr_shared_buffer_2 + long_frame_len * IXHEAACE_MAX_CH_IN_BS_ELE + 16);

  return IA_NO_ERROR;

}

IA_ERRORCODE ia_enhaacplus_enc_qc_init(ixheaace_qc_state *pstr_qc_state, WORD32 aot,

                                       ixheaace_qc_init *pstr_init, FLAG flag_framelength_small) {

  IA_ERRORCODE error = IA_NO_ERROR;

  pstr_qc_state->num_channels = pstr_init->pstr_element_info->n_channels_in_el;

  pstr_qc_state->max_bits_tot = pstr_init->max_bits;

  switch (aot) {

    case AOT_AAC_LC:

    case AOT_SBR:

    case AOT_PS:

      pstr_qc_state->bit_res_tot = pstr_init->bit_res - pstr_init->average_bits;

      break;

    case AOT_AAC_LD:

    case AOT_AAC_ELD:

      if (pstr_init->bit_res) {

        pstr_qc_state->bit_res_tot = pstr_init->bit_res - pstr_init->average_bits;

      } else {

        pstr_qc_state->bit_res_tot = 0;

      }

      break;

  }

  pstr_qc_state->average_bits_tot = pstr_init->average_bits;

  pstr_qc_state->max_bit_fac = pstr_init->max_bit_fac;

  pstr_qc_state->padding.padding_rest = pstr_init->padding.padding_rest;

  pstr_qc_state->quality_level = pstr_init->inv_quant;

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {

    pstr_qc_state->glob_stat_bits = 3; /* for ID_END */

  }

  error = ia_enhaacplus_enc_init_element_bits(

      &pstr_qc_state->element_bits, *pstr_init->pstr_element_info, pstr_init->bitrate,

      pstr_init->average_bits, aot, pstr_qc_state->glob_stat_bits, pstr_init->bit_res,

      flag_framelength_small);

  if (error != IA_NO_ERROR) {

    return error;

  }

  iaace_adj_thr_init(&pstr_qc_state->str_adj_thr, pstr_init->mean_pe,

                     pstr_qc_state->element_bits.ch_bitrate, aot);

  ia_enhaacplus_enc_bitcount_init((WORD32 *)pstr_qc_state->side_info_tab_long,

                                  (WORD32 *)pstr_qc_state->side_info_tab_short);

  return IA_NO_ERROR;

}

VOID ia_enhaacplus_enc_update_bit_reservoir(ixheaace_qc_state *pstr_qc_kernel,

                                            ixheaace_qc_out *pstr_qc_out)

{

  ixheaace_element_bits *pstr_el_bits;

  pstr_qc_kernel->bit_res_tot = 0;

  pstr_el_bits = &pstr_qc_kernel->element_bits;

  if (pstr_el_bits->average_bits > 0) {

    /* constant bitrate */

    pstr_el_bits->bit_res_level +=

        pstr_el_bits->average_bits -

        (pstr_qc_out->qc_element.static_bits_used + pstr_qc_out->qc_element.dyn_bits_used +

         pstr_qc_out->qc_element.anc_bits_used + pstr_qc_out->qc_element.fill_bits);

    pstr_qc_kernel->bit_res_tot += pstr_el_bits->bit_res_level;

  } else {

    /* variable bitrate */

    pstr_el_bits->bit_res_level = pstr_el_bits->max_bits;

    pstr_qc_kernel->bit_res_tot = pstr_qc_kernel->max_bits_tot;

  }

}

IA_ERRORCODE ia_enhaacplus_enc_finalize_bit_consumption(ixheaace_qc_state *pstr_qc_kernel,

                                                        ixheaace_qc_out *pstr_qc_out,

                                                        WORD32 flag_last_element, WORD32 cnt_bits,

                                                        WORD32 *tot_fill_bits,

                                                        iexheaac_encoder_str **pstr_aac_enc,

                                                        WORD32 num_bs_elements, WORD32 aot) {

  WORD32 n_full_fill_elem, diff_bits;

  WORD32 total_fill_bits = 0;

  const WORD32 max_fill_elem_bits = 7 + 270 * 8;

  WORD32 tfb_flag = 0;

  WORD32 tfb_flag1 = 0;

  WORD32 tfb_flag2 = 0;

  pstr_qc_out->tot_static_bits_used = (flag_last_element ? pstr_qc_kernel->glob_stat_bits : 0);

  pstr_qc_out->tot_dyn_bits_used = 0;

  pstr_qc_out->tot_anc_bits_used = 0;

  pstr_qc_out->total_fill_bits = 0;

  pstr_qc_out->tot_static_bits_used += pstr_qc_out->qc_element.static_bits_used;

  pstr_qc_out->tot_dyn_bits_used += pstr_qc_out->qc_element.dyn_bits_used;

  pstr_qc_out->tot_anc_bits_used += pstr_qc_out->qc_element.anc_bits_used;

  pstr_qc_out->total_fill_bits += pstr_qc_out->qc_element.fill_bits;

  /* Accumulate total fill bits */

  *tot_fill_bits += pstr_qc_out->qc_element.fill_bits;

  if (flag_last_element) {

    WORD32 i, j, temp_resv;

    WORD32 bit_resv_spc[(MAXIMUM_BS_ELE << 1) + 1];

    WORD32 bit_resv_spc_sort[(MAXIMUM_BS_ELE << 1) + 1] = {0, 1,  2,  3,  4,  5,  6,  7, 8,

                                                           9, 10, 11, 12, 13, 14, 15, 16};

    total_fill_bits = *tot_fill_bits;

    /* Distribute fill bits among all channel elements for next frame */

    if (total_fill_bits > 0) {

      /* Generate array of vacancies in bit reservoirs */

      for (i = 0, temp_resv = 0; i < num_bs_elements; i++, temp_resv++) {

        bit_resv_spc[temp_resv] = (pstr_aac_enc[i]->qc_kernel.element_bits.max_bit_res_bits -

                                   pstr_aac_enc[i]->qc_kernel.element_bits.bit_res_level);

        /* CPE gets double the weight of SCE, so split CPE reservoir into two */

        if (pstr_aac_enc[i]->qc_kernel.num_channels == 2) {

          bit_resv_spc[temp_resv + 1] = bit_resv_spc[temp_resv] >> 1;

          bit_resv_spc[temp_resv] -= bit_resv_spc[temp_resv + 1];

          temp_resv++;

        }

      }

      /* Sort bit_resv_spc[] in descending order of levels and

      store the order in bit_resv_spc_sort[] */

      for (i = (temp_resv - 1); i > 0; i--) {

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

          if (bit_resv_spc[bit_resv_spc_sort[j]] < bit_resv_spc[bit_resv_spc_sort[j + 1]]) {

            WORD32 tmp_var = bit_resv_spc_sort[j];

            bit_resv_spc_sort[j] = bit_resv_spc_sort[j + 1];

            bit_resv_spc_sort[j + 1] = tmp_var;

          }

        }

      }

      /* One dummy full reservoir at the end to help in bit distribution */

      bit_resv_spc[temp_resv] = 0;

      bit_resv_spc_sort[temp_resv] = temp_resv;

      /* Distribute fill bits among reservoirs in the order of bit_resv_spc_sort[]:

      - Bring up [0] to the level of [1]

      - Next bring up [0] and [1] to the level of [2]...and so on */

      for (i = 1; ((i < (temp_resv + 1)) && (total_fill_bits > 0)); i++) {

        if (((bit_resv_spc[bit_resv_spc_sort[0]] - bit_resv_spc[bit_resv_spc_sort[i]]) * i) <=

            total_fill_bits) {

          total_fill_bits -=

              ((bit_resv_spc[bit_resv_spc_sort[0]] - bit_resv_spc[bit_resv_spc_sort[i]]) * i);

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

            bit_resv_spc[bit_resv_spc_sort[j]] = bit_resv_spc[bit_resv_spc_sort[i]];

          }

        } else {

          WORD32 div_bs_ele;

          div_bs_ele = (WORD32)(total_fill_bits / i);

          total_fill_bits -= (div_bs_ele * i);

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

            bit_resv_spc[bit_resv_spc_sort[j]] -= div_bs_ele;

          }

          for (j = 0; ((j < i) && (total_fill_bits > 0)); j++) {

            bit_resv_spc[bit_resv_spc_sort[j]]--;

            total_fill_bits--;

          }

        }

      }

      /* Supply additional bits added for coding next frame */

      for (i = 0, temp_resv = 0; i < num_bs_elements; i++, temp_resv++) {

        WORD32 add_bits;

        add_bits = (pstr_aac_enc[i]->qc_kernel.element_bits.max_bit_res_bits -

                    pstr_aac_enc[i]->qc_kernel.element_bits.bit_res_level) -

                   bit_resv_spc[temp_resv];

        /* Because CPE reservoir has been split into two */

        if (pstr_aac_enc[i]->qc_kernel.num_channels == 2) {

          temp_resv++;

          add_bits -= bit_resv_spc[temp_resv];

        }

        /* These will be in addition to the avg. bitrate for the next frame */

        pstr_aac_enc[i]->qc_kernel.element_bits.carry_bits = add_bits;

      }

      /* Update remaining fill bits */

      *tot_fill_bits = total_fill_bits;

    }

    n_full_fill_elem = (total_fill_bits - 1) / max_fill_elem_bits;

    if (n_full_fill_elem) {

      total_fill_bits -= n_full_fill_elem * max_fill_elem_bits;

    }

    if (total_fill_bits > 0) {

      /* minimum Fillelement contains 7 (TAG + byte cnt) bits */

      total_fill_bits = MAX(7, total_fill_bits);

      /* fill element size equals n*8 + 7 */

      total_fill_bits += ((8 - (total_fill_bits - 7) % 8) % 8);

      switch (total_fill_bits) {

        case 7:

          tfb_flag2 = 1;

          break;

        case 15:

          tfb_flag1 = 1;

          break;

        default:

          tfb_flag = 1;

          break;

      }

    }

    total_fill_bits += n_full_fill_elem * max_fill_elem_bits;

    pstr_qc_out->align_bits =

        7 - (cnt_bits + pstr_qc_out->tot_dyn_bits_used + pstr_qc_out->tot_static_bits_used +

             pstr_qc_out->tot_anc_bits_used + +total_fill_bits - 1) %

                8;

    if (((pstr_qc_out->align_bits + total_fill_bits - *tot_fill_bits) == 8) &&

        (total_fill_bits > 8)) {

      total_fill_bits -= 8;

    }

    diff_bits = (pstr_qc_out->align_bits + total_fill_bits) - *tot_fill_bits;

    if (diff_bits) {

      if (diff_bits < 0) {

        return IA_EXHEAACE_EXE_FATAL_INVALID_BIT_CONSUMPTION;

      } else {

        {

          if (cnt_bits + pstr_qc_out->tot_static_bits_used + pstr_qc_out->tot_dyn_bits_used +

                  pstr_qc_out->tot_anc_bits_used + total_fill_bits >

              12288) {

            if ((diff_bits > 8) && (total_fill_bits > 8)) {

              if (tfb_flag || tfb_flag1) {

                total_fill_bits -= 8;

              }

              if (tfb_flag2) {

                total_fill_bits -= 7;

              }

            }

          } else {

            if (pstr_qc_kernel->element_bits.bit_res_level - diff_bits > 0) {

              pstr_qc_kernel->element_bits.bit_res_level -= diff_bits;

              pstr_qc_kernel->bit_res_tot = pstr_qc_kernel->element_bits.bit_res_level;

            } else {

              if ((diff_bits > 8) && (total_fill_bits > 8) && (tfb_flag)) {

                total_fill_bits -= 8;

              } else if ((diff_bits > 8) && (total_fill_bits > 8) && (tfb_flag1)) {

                total_fill_bits -= 8;

              } else if ((diff_bits > 8) && (total_fill_bits > 8) && (tfb_flag2)) {

                total_fill_bits -= 7;

              }

            }

          }

        }

      }

    }

    switch (aot) {

      case AOT_AAC_LC:

      case AOT_SBR:

      case AOT_PS:

        *tot_fill_bits = total_fill_bits;

        break;

      case AOT_AAC_LD:

      case AOT_AAC_ELD:

        pstr_qc_out->total_fill_bits = total_fill_bits;

        *tot_fill_bits = 0;

        break;

    }

  }  // if flag_last_element

  else {

    pstr_qc_out->align_bits = 0;

  }

  if ((pstr_qc_out->tot_dyn_bits_used + pstr_qc_out->tot_static_bits_used +

       pstr_qc_out->tot_anc_bits_used + pstr_qc_out->total_fill_bits + pstr_qc_out->align_bits) >

      pstr_qc_kernel->max_bits_tot) {

  }

  return IA_NO_ERROR;

}

VOID ia_enhaacplus_enc_adjust_bitrate(ixheaace_qc_state *pstr_qc_state, WORD32 bit_rate,

                                      WORD32 sample_rate, WORD32 flag_last_element,

                                      WORD32 frame_len_long)

{

  WORD32 padding_on;

  WORD32 frame_len;

  WORD32 code_bits;

  WORD32 code_bits_last;

  padding_on = ia_enhaacplus_enc_frame_padding(

      bit_rate, sample_rate, &pstr_qc_state->padding.padding_rest, frame_len_long);

  frame_len = padding_on + ia_enhaacplus_enc_calc_frame_len(bit_rate, sample_rate,

                                                            FRAME_LEN_BYTES_INT, frame_len_long);

  frame_len <<= 3;

  if (flag_last_element) {

    code_bits_last = pstr_qc_state->average_bits_tot - pstr_qc_state->glob_stat_bits;

    code_bits = frame_len - pstr_qc_state->glob_stat_bits;

  } else {

    code_bits_last = pstr_qc_state->average_bits_tot;

    code_bits = frame_len;

  }

  /* calculate bits for every channel element */

  if (code_bits != code_bits_last) {

    WORD32 total_bits = 0;

    pstr_qc_state->element_bits.average_bits =

        (WORD32)(pstr_qc_state->element_bits.relative_bits * code_bits);

    total_bits += pstr_qc_state->element_bits.average_bits;

    pstr_qc_state->element_bits.average_bits += code_bits - total_bits;

  }

  pstr_qc_state->average_bits_tot = frame_len;

  /* Bits carried over from previous frame due to distribution of fill bits */

  pstr_qc_state->element_bits.average_bits += pstr_qc_state->element_bits.carry_bits;

  pstr_qc_state->average_bits_tot += pstr_qc_state->element_bits.carry_bits;

  /* Flush for current frame */

  pstr_qc_state->element_bits.carry_bits = 0;

}

WORD32 ia_enhaacplus_aac_limitbitrate(WORD32 core_sampling_rate, WORD32 frame_length,

                                      WORD32 num_channels, WORD32 bit_rate) {

  WORD32 prev_bit_rate, shift = 0, iter = 0;

  WORD32 max_ch_bits = MAXIMUM_CHANNEL_BITS_1024;

  while ((frame_length & ~((1 << (shift + 1)) - 1)) == frame_length &&

         (core_sampling_rate & ~((1 << (shift + 1)) - 1)) == core_sampling_rate) {

    shift++;

  }

  max_ch_bits = MAXIMUM_CHANNEL_BITS_1024 * frame_length / MAX_FRAME_LEN;

  do {

    prev_bit_rate = bit_rate;

    bit_rate = MAX(bit_rate, ((((40 * num_channels) + TRANSPORT_BITS) * (core_sampling_rate)) /

                              frame_length));

    bit_rate = MIN(bit_rate, ((num_channels * max_ch_bits) * (core_sampling_rate >> shift)) /

                                 (frame_length >> shift));

  } while (prev_bit_rate != bit_rate && iter++ < 3);

  return bit_rate;

}