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

 *                                                                            *

 * Copyright (C) 2018 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 <math.h>

#include <stdio.h>

#include <string.h>

#include "ixheaac_type_def.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_tns_usac.h"

#include "ixheaacd_cnst.h"

#include "ixheaacd_error_codes.h"

#include "ixheaacd_acelp_info.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_info.h"

#include "ixheaacd_sbr_common.h"

#include "ixheaacd_drc_data_struct.h"

#include "ixheaacd_drc_dec.h"

#include "ixheaacd_sbrdecoder.h"

#include "ixheaacd_mps_polyphase.h"

#include "ixheaac_sbr_const.h"

#include "ixheaacd_ec_defines.h"

#include "ixheaacd_ec_struct_def.h"

#include "ixheaacd_main.h"

#include "ixheaacd_arith_dec.h"

#include "ixheaacd_bit_extract.h"

#include "ixheaacd_func_def.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_info.h"

#include "ixheaacd_defines.h"

#define MAX_NR_OF_SWB 120

VOID ixheaacd_calc_grp_offset(ia_sfb_info_struct *ptr_sfb_info, pUWORD8 group) {

  WORD32 group_offset;

  WORD32 group_idx;

  WORD32 ixheaacd_drc_offset;

  WORD16 *group_offset_p;

  WORD32 sfb, len;

  group_offset = 0;

  group_idx = 0;

  do {

    ptr_sfb_info->group_len[group_idx] = group[group_idx] - group_offset;

    group_offset = group[group_idx];

    group_idx++;

  } while (group_offset < 8);

  ptr_sfb_info->num_groups = group_idx;

  group_offset_p = ptr_sfb_info->sfb_idx_tbl;

  ixheaacd_drc_offset = 0;

  for (group_idx = 0; group_idx < ptr_sfb_info->num_groups; group_idx++) {

    len = ptr_sfb_info->group_len[group_idx];

    for (sfb = 0; sfb < ptr_sfb_info->sfb_per_sbk; sfb++) {

      ixheaacd_drc_offset += ptr_sfb_info->sfb_width[sfb] * len;

      *group_offset_p++ = ixheaacd_drc_offset;

    }

  }

}

VOID ixheaacd_read_tns_u(ia_sfb_info_struct *ptr_sfb_info,

                         ia_tns_frame_info_struct *pstr_tns_frame_info,

                         ia_bit_buf_struct *it_bit_buff) {

  WORD32 j, k, top, coef_res, resolution, compress;

  WORD32 short_flag, i;

  WORD16 *sp, tmp, s_mask, n_mask;

  ia_tns_filter_struct *tns_filt;

  ia_tns_info_struct *pstr_tns_info;

  static const WORD16 sgn_mask[] = {0x2, 0x4, 0x8};

  static const WORD16 neg_mask[] = {(WORD16)0xfffc, (WORD16)0xfff8,

                                    (WORD16)0xfff0};

  WORD16 n_filt_bits;

  WORD16 start_band_bits;

  WORD16 order_bits;

  short_flag = (!ptr_sfb_info->islong);

  pstr_tns_frame_info->n_subblocks = ptr_sfb_info->max_win_len;

  if (!short_flag) {

    n_filt_bits = 2;

    start_band_bits = 6;

    order_bits = 4;

  } else {

    n_filt_bits = 1;

    start_band_bits = 4;

    order_bits = 3;

  }

  for (i = 0; i < pstr_tns_frame_info->n_subblocks; i++) {

    pstr_tns_info = &pstr_tns_frame_info->str_tns_info[i];

    if (!(pstr_tns_info->n_filt =

              ixheaacd_read_bits_buf(it_bit_buff, n_filt_bits)))

      continue;

    pstr_tns_info->coef_res = coef_res =

        ixheaacd_read_bits_buf(it_bit_buff, 1) + 3;

    top = ptr_sfb_info->sfb_per_sbk;

    tns_filt = &pstr_tns_info->str_filter[0];

    for (j = pstr_tns_info->n_filt; j > 0; j--) {

      tns_filt->stop_band = top;

      top = tns_filt->start_band =

          top - ixheaacd_read_bits_buf(it_bit_buff, start_band_bits);

      tns_filt->order = ixheaacd_read_bits_buf(it_bit_buff, order_bits);

      if (tns_filt->order) {

        tns_filt->direction = ixheaacd_read_bits_buf(it_bit_buff, 1);

        compress = ixheaacd_read_bits_buf(it_bit_buff, 1);

        resolution = coef_res - compress;

        s_mask = sgn_mask[resolution - 2];

        n_mask = neg_mask[resolution - 2];

        sp = tns_filt->coef;

        for (k = tns_filt->order; k > 0; k--) {

          tmp = ixheaacd_read_bits_buf(it_bit_buff, resolution);

          *sp++ = (tmp & s_mask) ? (tmp | n_mask) : tmp;

        }

      }

      tns_filt++;

    }

  }

}

VOID ixheaacd_scale_factor_data(ia_sfb_info_struct *info, WORD32 tot_sfb,

                                WORD32 max_sfb, WORD32 sfb_per_sbk,

                                WORD8 *ptr_code_book) {

  WORD band;

  WORD sect_cb;

  WORD sect_len;

  WORD8 *ptr_codebook = ptr_code_book;

  WORD8 *temp_ptr_codebook = ptr_codebook;

  WORD32 win_group = info->max_win_len;

  memset(ptr_codebook, 0, 128);

  band = 0;

  while (band < tot_sfb || win_group != 0) {

    sect_cb = 11;

    sect_len = max_sfb;

    band = band + sfb_per_sbk;

    sect_len = sect_len - 1;

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

      *temp_ptr_codebook++ = sect_cb;

    }

    ptr_codebook += 16;

    temp_ptr_codebook = ptr_codebook;

    win_group--;

  }

  return;

}

WORD32

ixheaacd_win_seq_select(WORD32 window_sequence_curr,

                        WORD32 window_sequence_last) {

  WORD32 window_sequence;

  switch (window_sequence_curr) {

    case ONLY_LONG_SEQUENCE:

      window_sequence = ONLY_LONG_SEQUENCE;

      break;

    case LONG_START_SEQUENCE:

      if ((window_sequence_last == LONG_START_SEQUENCE) ||

          (window_sequence_last == EIGHT_SHORT_SEQUENCE) ||

          (window_sequence_last == STOP_START_SEQUENCE)) {

        window_sequence = STOP_START_SEQUENCE;

      } else {

        window_sequence = LONG_START_SEQUENCE;

      }

      break;

    case LONG_STOP_SEQUENCE:

      window_sequence = LONG_STOP_SEQUENCE;

      break;

    case EIGHT_SHORT_SEQUENCE:

      window_sequence = EIGHT_SHORT_SEQUENCE;

      break;

    default:

      return -1;

  }

  return window_sequence;

}

VOID ixheaacd_tns_reset(ia_sfb_info_struct *ptr_sfb_info,

                        ia_tns_frame_info_struct *pstr_tns_frame_info) {

  WORD32 s;

  pstr_tns_frame_info->n_subblocks = ptr_sfb_info->max_win_len;

  for (s = 0; s < pstr_tns_frame_info->n_subblocks; s++)

    pstr_tns_frame_info->str_tns_info[s].n_filt = 0;

}

VOID ixheaacd_section_data(ia_usac_data_struct *usac_data,

                           ia_bit_buf_struct *g_bs, ia_sfb_info_struct *info,

                           WORD16 global_gain, pWORD16 factors, pUWORD8 groups,

                           WORD8 *ptr_code_book) {

  WORD32 band;

  WORD16 position = 0;

  WORD32 group;

  WORD16 factor = global_gain;

  WORD8 *temp_codebook_ptr;

  WORD16 *ptr_scale_fac, *temp_ptr_scale_fac;

  WORD16 norm_val;

  WORD32 window_grps, trans_sfb;

  WORD16 index, length;

  const UWORD16 *hscf = usac_data->huffman_code_book_scl;

  const UWORD32 *idx_tab = usac_data->huffman_code_book_scl_index;

  WORD32 start_bit_pos = g_bs->bit_pos;

  UWORD8 *start_read_pos = g_bs->ptr_read_next;

  UWORD8 *ptr_read_next = g_bs->ptr_read_next;

  WORD32 bit_pos = 7 - g_bs->bit_pos;

  WORD32 is_1_group = 1;

  WORD32 bb = 0, i;

  WORD32 increment;

  WORD32 read_word =

      ixheaacd_aac_showbits_32(ptr_read_next, g_bs->cnt_bits, &increment);

  ptr_read_next = g_bs->ptr_read_next + increment;

  trans_sfb = info->sfb_per_sbk;

  temp_ptr_scale_fac = factors;

  window_grps = info->max_win_len;

  memset(factors, 0, MAXBANDS);

  band = trans_sfb - 1;

  for (group = 0; group < window_grps;) {

    temp_codebook_ptr = &ptr_code_book[group * 16];

    ptr_scale_fac = temp_ptr_scale_fac;

    group = *groups++;

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

      WORD32 cb_num = *temp_codebook_ptr++;

      if ((band == trans_sfb - 1) && (is_1_group == 1)) {

        *temp_ptr_scale_fac = factor;

        temp_ptr_scale_fac++;

        continue;

      }

      if (cb_num == ZERO_HCB)

        *temp_ptr_scale_fac++ = 0;

      else {

        WORD32 pns_band;

        WORD16 curr_energy = 0;

        UWORD32 read_word1;

        read_word1 = read_word << bit_pos;

        ixheaacd_huffman_decode(read_word1, &index, &length, hscf, idx_tab);

        bit_pos += length;

        ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word,

                                     g_bs->ptr_bit_buf_end);

        norm_val = index - 60;

        if (cb_num > NOISE_HCB) {

          position = position + norm_val;

          *temp_ptr_scale_fac++ = -position;

        } else if (cb_num < NOISE_HCB) {

          factor = factor + norm_val;

          *temp_ptr_scale_fac++ = factor;

        } else {

          curr_energy += norm_val;

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

          temp_ptr_scale_fac[pns_band] = curr_energy;

          temp_ptr_scale_fac++;

        }

      }

    }

    is_1_group = 0;

    if (!(info->islong)) {

      for (bb++; bb < group; bb++) {

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

          ptr_scale_fac[i + trans_sfb] = ptr_scale_fac[i];

        }

        temp_ptr_scale_fac += trans_sfb;

        ptr_scale_fac += trans_sfb;

      }

    }

  }

  ptr_read_next = ptr_read_next - increment;

  ixheaacd_aac_read_byte_corr1(&ptr_read_next, &bit_pos, &read_word,

                               g_bs->ptr_bit_buf_end);

  g_bs->ptr_read_next = ptr_read_next;

  g_bs->bit_pos = 7 - bit_pos;

  {

    WORD32 bits_consumed;

    bits_consumed = (WORD32)(((g_bs->ptr_read_next - start_read_pos) << 3) +

                             (start_bit_pos - g_bs->bit_pos));

    g_bs->cnt_bits -= bits_consumed;

  }

}

WORD32 ixheaacd_fd_channel_stream(

    ia_usac_data_struct *usac_data,

    ia_usac_tmp_core_coder_struct *pstr_core_coder, UWORD8 *max_sfb,

    WORD32 window_sequence_last, WORD32 chn, WORD32 noise_filling, WORD32 ch,

    ia_bit_buf_struct *it_bit_buff

    )

{

  WORD32 i;

  WORD32 tot_sfb;

  WORD32 noise_level = 0;

  WORD32 arith_reset_flag;

  WORD32 arth_size;

  WORD16 global_gain;

  WORD32 max_spec_coefficients;

  WORD32 err_code = 0;

  WORD32 noise_offset;

  WORD32 *fac_data;

  ia_sfb_info_struct *info;

  WORD8 *ptr_code_book = (WORD8 *)&usac_data->scratch_buffer;

  global_gain = ixheaacd_read_bits_buf(it_bit_buff, 8);

  if (noise_filling) {

    noise_level = ixheaacd_read_bits_buf(it_bit_buff, 3);

    noise_offset = ixheaacd_read_bits_buf(it_bit_buff, 5);

  } else {

    noise_level = 0;

    noise_offset = 0;

  }

  if (!pstr_core_coder->common_window) {

    err_code = ixheaacd_ics_info(usac_data, chn, max_sfb, it_bit_buff,

                                 window_sequence_last);

    if (err_code == -1) {

      if (usac_data->ec_flag) {

        memcpy(usac_data->max_sfb, pstr_core_coder->max_sfb, sizeof(pstr_core_coder->max_sfb));

        longjmp(*(it_bit_buff->xaac_jmp_buf),

                IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);

      } else {

        return err_code;

      }

    }

  }

  info = usac_data->pstr_sfb_info[chn];

  if (!pstr_core_coder->common_tw && usac_data->tw_mdct[0] == 1) {

    usac_data->tw_data_present[chn] = ixheaacd_read_bits_buf(it_bit_buff, 1);

    if (usac_data->tw_data_present[chn]) {

      WORD32 i;

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

        usac_data->tw_ratio[chn][i] = ixheaacd_read_bits_buf(it_bit_buff, 3);

      }

    }

  }

  if (*max_sfb == 0) {

    tot_sfb = 0;

  } else {

    i = 0;

    tot_sfb = info->sfb_per_sbk;

    while (usac_data->group_dis[chn][i++] < info->max_win_len) {

      tot_sfb += info->sfb_per_sbk;

    }

  }

  ixheaacd_scale_factor_data(info, tot_sfb, *max_sfb, info->sfb_per_sbk,

                             ptr_code_book);

  if ((it_bit_buff->ptr_read_next > it_bit_buff->ptr_bit_buf_end - 3) &&

      (it_bit_buff->size == it_bit_buff->max_size)) {

    return -1;

  }

  ixheaacd_section_data(usac_data, it_bit_buff, info, global_gain,

                        usac_data->factors[chn], usac_data->group_dis[chn],

                        ptr_code_book);

  if (pstr_core_coder->tns_data_present[ch] == 0)

    ixheaacd_tns_reset(info, usac_data->pstr_tns[chn]);

  if (pstr_core_coder->tns_data_present[ch] == 1)

    ixheaacd_read_tns_u(info, usac_data->pstr_tns[chn], it_bit_buff);

  if (*max_sfb > 0) {

    max_spec_coefficients =

        info->sfb_idx_tbl[*max_sfb - 1] / info->group_len[0];

  } else {

    max_spec_coefficients = 0;

  }

  if (usac_data->usac_independency_flg)

    arith_reset_flag = 1;

  else

    arith_reset_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);

  switch (usac_data->window_sequence[chn]) {

    case EIGHT_SHORT_SEQUENCE:

      arth_size = usac_data->ccfl / 8;

      break;

    default:

      arth_size = usac_data->ccfl;

      break;

  }

  err_code = ixheaacd_ac_spectral_data(

      usac_data, max_spec_coefficients, noise_level, noise_offset, arth_size,

      it_bit_buff, *max_sfb, arith_reset_flag, noise_filling, chn);

  if (err_code != 0) return err_code;

  usac_data->fac_data_present[chn] = ixheaacd_read_bits_buf(it_bit_buff, 1);

  if (usac_data->fac_data_present[chn]) {

    WORD32 fac_len;

    if ((usac_data->window_sequence[chn]) == EIGHT_SHORT_SEQUENCE) {

      fac_len = (usac_data->ccfl) / 16;

    } else {

      fac_len = (usac_data->ccfl) / 8;

    }

    fac_data = usac_data->fac_data[chn];

    fac_data[0] = ixheaacd_read_bits_buf(it_bit_buff, 7);

    ixheaacd_fac_decoding(fac_len, 0, &fac_data[1], it_bit_buff);

  }

  return 0;

}