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

 *

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

#include "ixheaac_constants.h"

#include "ixheaacd_cnst.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops16.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_mps_aac_struct.h"

#include "ixheaacd_mps_res_rom.h"

#include "ixheaacd_mps_res.h"

#include "ixheaacd_mps_res_huffman.h"

#define LONG_BLOCK_SECT_LEN 5

#define SHORT_BLOCK_SECT_LEN 3

WORD16 ixheaacd_c_block_read_section_data(

    ia_bit_buf_struct *it_bit_buf,

    ia_mps_dec_residual_channel_info_struct *p_aac_decoder_channel_info) {

  WORD band;

  WORD sect_cb;

  WORD sect_len;

  WORD sect_len_incr;

  WORD sect_esc_val;

  ia_mps_dec_residual_ics_info_struct *p_ics_info = &p_aac_decoder_channel_info->ics_info;

  WORD sfb_transmitted = p_ics_info->max_sf_bands;

  WORD win_group = p_ics_info->window_groups;

  WORD8 *p_code_book = p_aac_decoder_channel_info->p_code_book;

  WORD8 *p_code_book_temp = p_code_book;

  WORD32 sect_bitlen = LONG_BLOCK_SECT_LEN;

  if (p_aac_decoder_channel_info->ics_info.window_sequence == EIGHT_SHORT_SEQUENCE)

    sect_bitlen = SHORT_BLOCK_SECT_LEN;

  sect_esc_val = (1 << sect_bitlen) - 1;

  do {

    band = 0;

    while (band < sfb_transmitted) {

      WORD32 temp_word;

      sect_len = 0;

      temp_word = ixheaacd_read_bits_buf(it_bit_buf, 4 + sect_bitlen);

      sect_cb = temp_word >> sect_bitlen;

      sect_len_incr = temp_word & sect_esc_val;

      while (sect_len_incr == sect_esc_val) {

        sect_len = (sect_len + sect_esc_val);

        sect_len_incr = ixheaacd_read_bits_buf(it_bit_buf, sect_bitlen);

      }

      sect_len = (sect_len + sect_len_incr);

      band = (band + sect_len);

      if (band > sfb_transmitted) {

        return (WORD16)((WORD32)IA_XHEAAC_DEC_EXE_NONFATAL_EXCEEDS_SFB_TRANSMITTED);

      }

      if (sect_cb == BOOKSCL) {

        return (WORD16)((WORD32)AAC_DEC_INVALID_CODE_BOOK);

      }

      sect_len = sect_len - 1;

      for (; sect_len >= 0; sect_len--) {

        *p_code_book_temp++ = sect_cb;

      }

    }

    p_code_book += MAX_SFB_SHORT;

    p_code_book_temp = p_code_book;

    win_group--;

  } while (win_group != 0);

  return AAC_DEC_OK;

}

VOID ixheaacd_res_c_block_read_scf_data(

    ia_bit_buf_struct *it_bit_buf,

    ia_mps_dec_residual_channel_info_struct *p_aac_decoder_channel_info, WORD16 global_gain,

    ia_mps_dec_residual_aac_tables_struct *aac_tables_ptr) {

  WORD band;

  WORD16 position = 0;

  WORD group;

  WORD16 factor = global_gain;

  WORD8 *p_code_book, *p_codebook_tmp;

  WORD16 *p_scale_factor, *p_scale_factor_tmp;

  WORD16 norm_value;

  ia_mps_dec_residual_ics_info_struct *p_ics_info;

  WORD window_groups, sfb_transmitted;

  UWORD16 *h;

  const UWORD16 *hscf = &aac_tables_ptr->res_huffmann_tables_ptr->huffman_code_book_scl[1];

  WORD start_bit_pos = it_bit_buf->bit_pos;

  UWORD8 *start_read_pos = it_bit_buf->ptr_read_next;

  UWORD8 *ptr_read_next = it_bit_buf->ptr_read_next;

  WORD32 bit_pos = 7 - it_bit_buf->bit_pos;

  WORD32 read_word;

  WORD32 diffbytes;

  diffbytes = (WORD32)(it_bit_buf->ptr_bit_buf_end - ptr_read_next);

  diffbytes++;

  if (diffbytes >= 4) {

    read_word = ixheaacd_res_aac_showbits_32(ptr_read_next);

    diffbytes = 4;

    ptr_read_next = it_bit_buf->ptr_read_next + 4;

  } else {

    WORD32 ii;

    read_word = 0;

    for (ii = 0; ii < diffbytes; ii++) {

      read_word = (read_word << 8) | (*ptr_read_next);

      ptr_read_next++;

    }

    read_word <<= ((4 - diffbytes) << 3);

  }

  p_code_book = p_aac_decoder_channel_info->p_code_book;

  p_ics_info = &p_aac_decoder_channel_info->ics_info;

  sfb_transmitted = p_ics_info->max_sf_bands;

  p_scale_factor = p_aac_decoder_channel_info->p_scale_factor;

  window_groups = p_ics_info->window_groups;

  band = sfb_transmitted - 1;

  for (group = 0; group < window_groups; group++) {

    p_codebook_tmp = &p_code_book[group * MAX_SFB_SHORT];

    p_scale_factor_tmp = &p_scale_factor[group * MAX_SFB_SHORT];

    for (band = sfb_transmitted - 1; band >= 0; band--) {

      WORD32 cb_num = *p_codebook_tmp++;

      if (cb_num == ZERO_HCB)

        *p_scale_factor_tmp++ = 0;

      else {

        {

          WORD32 flag = 1;

          WORD pns_band;

          ia_mps_dec_residual_pns_data_struct *p_pns_data = &p_aac_decoder_channel_info->pns_data;

          if (cb_num == NOISE_HCB && (p_pns_data->pns_active != 1)) flag = 0;

          if (flag) {

            UWORD16 first_offset;

            WORD16 sign_ret_val;

            UWORD32 read_word1;

            read_word1 = read_word << bit_pos;

            h = (UWORD16 *)(hscf);

            first_offset = 7;

            h += (read_word1) >> (32 - first_offset);

            sign_ret_val = *h;

            while (sign_ret_val > 0) {

              bit_pos += first_offset;

              ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word,

                                          it_bit_buf->ptr_bit_buf_end);

              read_word1 = (read_word1) << (first_offset);

              first_offset = (sign_ret_val >> 11);

              first_offset = (sign_ret_val >> 11);

              h += sign_ret_val & (0x07FF);

              h += (read_word1) >> (32 - first_offset);

              sign_ret_val = *h;

            }

            bit_pos += ((sign_ret_val & 0x7fff) >> 11);

            ixheaacd_aac_read_byte_corr(&ptr_read_next, &bit_pos, &read_word,

                                        it_bit_buf->ptr_bit_buf_end);

            norm_value = (sign_ret_val & (0x07FF)) - 60;

          } else {

            WORD32 noise_start_value;

            UWORD32 temp;

            temp = (read_word << bit_pos);

            temp = ((UWORD32)temp >> (32 - 9));

            noise_start_value = temp;

            bit_pos += 9;

            ixheaacd_aac_read_2bytes(&ptr_read_next, &bit_pos, &read_word);

            norm_value = noise_start_value - 256;

            p_pns_data->pns_active = 1;

            p_pns_data->current_energy = global_gain - NOISE_OFFSET;

          }

          if (cb_num > NOISE_HCB) {

            position = position + norm_value;

            *p_scale_factor_tmp++ = -position;

          } else if (cb_num < NOISE_HCB) {

            factor = factor + norm_value;

            *p_scale_factor_tmp++ = factor;

          } else {

            p_pns_data->current_energy =

                ixheaac_add16_sat(p_pns_data->current_energy, norm_value);

            pns_band = (group << 4) + sfb_transmitted - band - 1;

            p_aac_decoder_channel_info->p_scale_factor[pns_band] = p_pns_data->current_energy;

            p_pns_data->pns_used[pns_band] = 1;

            p_scale_factor_tmp++;

          }

        }

      }

    }

  }

  it_bit_buf->ptr_read_next = ptr_read_next - diffbytes;

  it_bit_buf->bit_pos = 7 - bit_pos;

  {

    WORD bits_cons;

    bits_cons = (WORD)(((it_bit_buf->ptr_read_next - start_read_pos) << 3) +

                       (start_bit_pos - it_bit_buf->bit_pos));

    it_bit_buf->cnt_bits -= bits_cons;

  }

}