/******************************************************************************
 *                                                                            *
 * 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 <stdlib.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 "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"

#include "ixheaac_error_standards.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_adjust_threshold_data.h"
#include "ixheaace_bitbuffer.h"
#include "ixheaace_dynamic_bits.h"
#include "ixheaace_qc_data.h"
#include "ixheaace_channel_map.h"
#include "ixheaace_block_switch.h"
#include "ixheaace_psy_data.h"
#include "ixheaace_interface.h"
#include "ixheaace_write_bitstream.h"
#include "ixheaace_psy_configuration.h"
#include "ixheaace_psy_mod.h"
#include "ixheaace_stereo_preproc.h"
#include "ixheaace_enc_main.h"
#include "ixheaace_qc_util.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_common_utils.h"

#define ALIGNMENT_DEFINE __attribute__((aligned(8)))

IA_ERRORCODE ia_enhaacplus_enc_aac_core_encode(
    iexheaac_encoder_str **pstr_aac_enc, FLOAT32 *ptr_time_signal, UWORD32 time_sn_stride,
    const UWORD8 *ptr_anc_bytes, UWORD8 *num_anc_bytes, UWORD8 *ptr_out_bytes,
    WORD32 *num_out_bytes, ixheaace_aac_tables *pstr_aac_tabs, VOID *ptr_bit_stream_handle,
    VOID *ptr_bit_stream, FLAG flag_last_element, WORD32 *write_program_config_element,
    WORD32 i_num_coup_channels, WORD32 i_channels_mask, WORD32 ele_idx, WORD32 *total_fill_bits,
    WORD32 total_channels, WORD32 aot, WORD32 adts_flag, WORD32 num_bs_elements,
    WORD32 *is_quant_spec_zero, WORD32 *is_gain_limited) {
  IA_ERRORCODE err_code = IA_NO_ERROR;
  iexheaac_encoder_str *pstr_aac_encoder = pstr_aac_enc[ele_idx];
  ixheaace_element_info *pstr_element_info = &pstr_aac_encoder->element_info;
  WORD32 glob_used_bits;
  WORD32 anc_data_bytes, anc_data_bytes_left;
  WORD32 stat_bits_flag = 0;
  WORD32 frame_len_long = FRAME_LEN_1024;
  WORD32 ch;

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
    frame_len_long =
        (pstr_aac_encoder->config.flag_framelength_small == 1) ? FRAME_LEN_960 : FRAME_LEN_1024;
  } else if (aot == AOT_AAC_LD || aot == AOT_AAC_ELD) {
    frame_len_long =
        (pstr_aac_encoder->config.flag_framelength_small == 1) ? FRAME_LEN_480 : FRAME_LEN_512;
  }

  if (ele_idx == 0) {
    if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
      ptr_bit_stream_handle = ia_enhaacplus_enc_create_bitbuffer(
          ptr_bit_stream, (UWORD8 *)ptr_out_bytes,
          (((pstr_aac_encoder->config.flag_framelength_small == 1) ? MAXIMUM_CHANNEL_BITS_960
                                                                   : MAXIMUM_CHANNEL_BITS_1024) /
           8) *
              total_channels);
    } else if (aot == AOT_AAC_LD || aot == AOT_AAC_ELD) {
      if (pstr_aac_encoder->config.bitreservoir_size != -1) {
        WORD32 avg_byte_perframe = (pstr_aac_encoder->config.bit_rate * frame_len_long /
                                    (pstr_aac_encoder->config.core_sample_rate * 8));

        if ((pstr_aac_encoder->config.bitreservoir_size * total_channels) > avg_byte_perframe) {
          ptr_bit_stream_handle = ia_enhaacplus_enc_create_bitbuffer(
              ptr_bit_stream, (UWORD8 *)ptr_out_bytes,
              pstr_aac_encoder->config.bitreservoir_size * total_channels);
        } else {
          ptr_bit_stream_handle = ia_enhaacplus_enc_create_bitbuffer(
              ptr_bit_stream, (UWORD8 *)ptr_out_bytes,
              (pstr_aac_encoder->config.bit_rate * frame_len_long /
               (pstr_aac_encoder->config.core_sample_rate * 8)));
        }
      } else {
        ptr_bit_stream_handle = ia_enhaacplus_enc_create_bitbuffer(
            ptr_bit_stream, (UWORD8 *)ptr_out_bytes,
            (pstr_aac_encoder->config.bit_rate * frame_len_long /
             (pstr_aac_encoder->config.core_sample_rate * 8)));
      }
    }
  } else {
    ptr_bit_stream_handle = ptr_bit_stream;
  }

  if (adts_flag) {
    stat_bits_flag = 0; /* fix for low bit-rate */
    if ((pstr_aac_encoder->config.core_sample_rate * 3) <= (pstr_aac_encoder->config.bit_rate)) {
      stat_bits_flag = 7; /* fix for low bit-rate */
    }
  }

  anc_data_bytes = anc_data_bytes_left = *num_anc_bytes;

  if (pstr_element_info->el_type == ID_CPE) {
    if (!pstr_aac_encoder->config.num_stereo_preprocessing) {
      iaace_apply_stereo_preproc(&pstr_aac_encoder->str_stereo_pre_pro, time_sn_stride,
                                 pstr_element_info, ptr_time_signal, frame_len_long);
    }
  }

  err_code = ia_enhaacplus_enc_psy_main(
      time_sn_stride, pstr_element_info, ptr_time_signal, aot,
      pstr_aac_encoder->psy_kernel.psy_data[pstr_element_info->channel_index[0]],
      pstr_aac_encoder->psy_kernel
          .temporal_noise_shaping_data[pstr_element_info->channel_index[0]],
      &pstr_aac_encoder->psy_kernel.psy_conf_long, &pstr_aac_encoder->psy_kernel.psy_conf_short,
      pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]],
      &pstr_aac_encoder->psy_out.psy_out_element,
      pstr_aac_encoder->psy_kernel.p_scratch_tns_float,
      (FLOAT32 *)pstr_aac_encoder->pstr_aac_scratch->shared_buffer1,
      pstr_aac_encoder->pstr_aac_scratch->shared_buffer5, pstr_aac_tabs, frame_len_long);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  ia_enhaacplus_enc_adjust_bitrate(
      &pstr_aac_encoder->qc_kernel, pstr_aac_encoder->config.bit_rate,
      pstr_aac_encoder->config.core_sample_rate, flag_last_element, frame_len_long);

  for (ch = 0; ch < pstr_element_info->n_channels_in_el; ch++) {
    pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]][ch].ms_digest =
        pstr_aac_encoder->psy_out.psy_out_element.tools_info.ms_digest;

    memcpy(
        &pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]][ch].ms_used[0],
        &pstr_aac_encoder->psy_out.psy_out_element.tools_info.ms_mask[0],
        MAXIMUM_GROUPED_SCALE_FACTOR_BAND *
            sizeof(pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]][ch]
                       .ms_used[0]));
  }

  err_code = ia_enhaacplus_enc_qc_main(
      &pstr_aac_encoder->qc_kernel, pstr_element_info->n_channels_in_el,
      &pstr_aac_encoder->qc_kernel.element_bits,
      pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]],
      &pstr_aac_encoder->psy_out.psy_out_element,
      pstr_aac_encoder->qc_out.qc_channel[pstr_element_info->channel_index[0]],
      &pstr_aac_encoder->qc_out.qc_element, MIN(anc_data_bytes_left, anc_data_bytes),
      pstr_aac_tabs, adts_flag, aot, stat_bits_flag, flag_last_element, frame_len_long,
      pstr_aac_encoder->pstr_aac_scratch->shared_buffer5, is_quant_spec_zero,
      is_gain_limited);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  if (pstr_element_info->el_type == ID_CPE) {
    if (!pstr_aac_encoder->config.num_stereo_preprocessing) {
      iaace_update_stereo_pre_process(
          pstr_aac_encoder->psy_out.psy_out_ch[pstr_element_info->channel_index[0]],
          &pstr_aac_encoder->qc_out.qc_element, &pstr_aac_encoder->str_stereo_pre_pro,
          pstr_aac_encoder->psy_out.psy_out_element.weight_ms_lr_pe_ratio);
    }
  }

  /* Update bit reservoir levels */
  ia_enhaacplus_enc_update_bit_reservoir(&pstr_aac_encoder->qc_kernel, &pstr_aac_encoder->qc_out);

  err_code = ia_enhaacplus_enc_finalize_bit_consumption(
      &pstr_aac_encoder->qc_kernel, &pstr_aac_encoder->qc_out, flag_last_element,
      ((ixheaace_bit_buf_handle)ptr_bit_stream_handle)->cnt_bits, total_fill_bits, pstr_aac_enc,
      num_bs_elements, aot);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  err_code = ia_enhaacplus_enc_write_bitstream(
      ptr_bit_stream_handle, *pstr_element_info, &pstr_aac_encoder->qc_out,
      &pstr_aac_encoder->psy_out, &glob_used_bits, ptr_anc_bytes, pstr_aac_tabs,
      flag_last_element, write_program_config_element, i_num_coup_channels, i_channels_mask,
      pstr_aac_encoder->config.core_sample_rate, ele_idx, aot, total_fill_bits);
  if (err_code != IA_NO_ERROR) {
    return err_code;
  }
  /* write out the bitstream */
  *num_out_bytes = ia_enhaacplus_enc_get_bits_available(ptr_bit_stream_handle) / 8;

  /* Validate that this frame is not too large */
  if (pstr_aac_encoder->config.bitreservoir_size != -1) {
    WORD32 avg_bytes_perframe = (pstr_aac_encoder->config.bit_rate * frame_len_long /
                                 (pstr_aac_encoder->config.core_sample_rate * 8));

    if (pstr_aac_encoder->config.bitreservoir_size * total_channels > avg_bytes_perframe) {
      if (*num_out_bytes > (pstr_aac_encoder->config.bitreservoir_size * total_channels)) {
        err_code = IA_EXHEAACE_EXE_FATAL_INVALID_OUT_BYTES;
      }
    } else {
      if (*num_out_bytes > avg_bytes_perframe) {
        err_code = IA_EXHEAACE_EXE_FATAL_INVALID_OUT_BYTES;
      }
    }
  } else {
    WORD32 avg_bytes_perframe = (pstr_aac_encoder->config.bit_rate * frame_len_long /
                                 (pstr_aac_encoder->config.core_sample_rate * 8));
    if (*num_out_bytes > avg_bytes_perframe) {
      err_code = IA_EXHEAACE_EXE_FATAL_INVALID_OUT_BYTES;
    }
  }

  return err_code;
}