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

 *                                                                            *

 * 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 <limits.h>

#include <stddef.h>

#include <stdlib.h>

#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 "ixheaac_error_standards.h"

#include "ixheaace_error_codes.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_tns_params.h"

#include "ixheaace_rom.h"

#include "ixheaace_common_rom.h"

#include "ixheaace_bitbuffer.h"

#include "ixheaace_bits_count.h"

#include "ixheaace_dynamic_bits.h"

#include "ixheaace_common_utils.h"

static WORD32 ia_enhaacplus_enc_calc_side_info_bits(WORD32 sfb_cnt, WORD32 block_type) {

  WORD32 seg_len_bits = (block_type == SHORT_WINDOW ? 3 : 5);

  WORD32 escape_val = (block_type == SHORT_WINDOW ? 7 : 31);

  WORD32 side_info_bits, tmp;

  side_info_bits = CODE_BCK_BITS;

  tmp = sfb_cnt;

  while (tmp >= 0) {

    side_info_bits += seg_len_bits;

    tmp -= escape_val;

  }

  return (side_info_bits);

}

static VOID ia_enhaacplus_enc_build_bit_look_up(

    const WORD16 *ptr_quant_spec, const WORD32 max_sfb, const WORD32 *ptr_sfb_offset,

    const UWORD16 *sfb_max,

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    ixheaace_section_info *pstr_section_info, ixheaace_huffman_tables *pstr_huffman_tbl,

    WORD32 aot) {

  WORD8 i;

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

    WORD32 sfb_width, max_val;

    pstr_section_info[i].sfb_cnt = 1;

    pstr_section_info[i].sfb_start = i;

    switch (aot) {

      case AOT_AAC_LC:

      case AOT_SBR:

      case AOT_PS:

        pstr_section_info[i].section_bits = INVALID_BITCOUNT_LC;

        break;

      case AOT_AAC_LD:

      case AOT_AAC_ELD:

        pstr_section_info[i].section_bits = INVALID_BITCOUNT_LD;

        break;

    }

    pstr_section_info[i].code_book = -1;

    sfb_width = ptr_sfb_offset[i + 1] - ptr_sfb_offset[i];

    max_val = sfb_max[i];

    ia_enhaacplus_enc_bitcount(ptr_quant_spec + ptr_sfb_offset[i], sfb_width, max_val,

                               bit_look_up[i], pstr_huffman_tbl, aot);

  }

}

static WORD32 ia_enhaacplus_enc_find_best_book(const WORD32 *ptr_bit_cnt, WORD8 *ptr_codebook,

                                               WORD32 aot) {

  WORD32 min_bits = 0, temp1, temp2;

  WORD8 temp_book = CODE_BCK_ESC_NDX;

  WORD8 j;

  switch (aot) {

    case AOT_AAC_LC:

    case AOT_SBR:

    case AOT_PS:

      min_bits = INVALID_BITCOUNT_LC;

      break;

    case AOT_AAC_LD:

    case AOT_AAC_ELD:

      min_bits = INVALID_BITCOUNT_LD;

      break;

  }

  for (j = 0; j <= CODE_BCK_ESC_NDX; j += 2) {

    temp1 = *ptr_bit_cnt++;

    temp2 = *ptr_bit_cnt++;

    if (temp1 < min_bits) {

      min_bits = temp1;

      temp_book = j;

    }

    if (temp2 < min_bits) {

      min_bits = temp2;

      temp_book = j + 1;

    }

  }

  *ptr_codebook = temp_book;

  return min_bits;

}

static WORD32 ia_enhaacplus_enc_find_min_merge_bits(const WORD32 *ptr_bit_cnt1,

                                                    const WORD32 *ptr_bit_cnt2, WORD32 aot) {

  WORD32 min_bits = 0, j, temp1, temp2, temp3, temp4;

  switch (aot) {

    case AOT_AAC_LC:

    case AOT_SBR:

    case AOT_PS:

      min_bits = INVALID_BITCOUNT_LC;

      break;

    case AOT_AAC_LD:

    case AOT_AAC_ELD:

      min_bits = INVALID_BITCOUNT_LD;

      break;

  }

  for (j = CODE_BCK_ESC_NDX; j >= 0; j -= 2) {

    temp1 = *ptr_bit_cnt1++;

    temp2 = *ptr_bit_cnt2++;

    temp3 = *ptr_bit_cnt1++;

    temp1 = temp1 + temp2;

    min_bits = MIN(temp1, min_bits);

    temp4 = *ptr_bit_cnt2++;

    temp1 = temp3 + temp4;

    min_bits = MIN(temp1, min_bits);

  }

  return min_bits;

}

static VOID ia_enhaacplus_enc_merge_bit_look_up(WORD32 *ptr_bit_cnt1, const WORD32 *ptr_bit_cnt2,

                                                WORD32 aot) {

  WORD32 j, temp1, temp2, temp3, temp4;

  WORD32 invalid_bitcnt = 0;

  switch (aot) {

    case AOT_AAC_LC:

    case AOT_SBR:

    case AOT_PS:

      invalid_bitcnt = INVALID_BITCOUNT_LC;

      break;

    case AOT_AAC_LD:

    case AOT_AAC_ELD:

      invalid_bitcnt = INVALID_BITCOUNT_LD;

      break;

  }

  for (j = 0; j <= CODE_BCK_ESC_NDX; j += 2) {

    temp1 = ptr_bit_cnt1[j];

    temp2 = ptr_bit_cnt2[j];

    temp3 = ptr_bit_cnt1[j + 1];

    ptr_bit_cnt1[j] = MIN(temp1 + temp2, invalid_bitcnt);

    temp4 = ptr_bit_cnt2[j + 1];

    ptr_bit_cnt1[j + 1] = MIN(temp3 + temp4, invalid_bitcnt);

  }

}

static WORD32 ia_enhaacplus_enc_find_max_merge(

    const WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],

    const ixheaace_section_info *section, const WORD32 max_sfb, WORD32 *max_ndx) {

  WORD32 i, max_merge_gain = 0;

  for (i = 0; i + section[i].sfb_cnt < max_sfb; i += section[i].sfb_cnt) {

    if (merge_gain_look_up[i] > max_merge_gain) {

      max_merge_gain = merge_gain_look_up[i];

      *max_ndx = i;

    }

  }

  return (max_merge_gain);

}

static WORD32 ia_enhaacplus_enc_calc_merge_gain(

    const ixheaace_section_info *pstr_section_info,

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    const WORD32 *pstr_side_info_tab, const WORD32 idx1, const WORD32 idx2, WORD32 aot) {

  WORD32 split_bits;

  WORD32 merge_bits;

  WORD32 merge_gain;

  split_bits = pstr_section_info[idx1].section_bits + pstr_section_info[idx2].section_bits;

  merge_bits =

      pstr_side_info_tab[pstr_section_info[idx1].sfb_cnt + pstr_section_info[idx2].sfb_cnt] +

      ia_enhaacplus_enc_find_min_merge_bits(bit_look_up[idx1], bit_look_up[idx2], aot);

  merge_gain = split_bits - merge_bits;

  return merge_gain;

}

static VOID ia_enhaacplus_enc_gm_stage0(

    ixheaace_section_info *pstr_section,

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    const WORD32 max_sfb, WORD32 aot) {

  WORD32 i = 0;

  WORD32 invalid_bitcnt = 0;

  switch (aot) {

    case AOT_AAC_LC:

    case AOT_SBR:

    case AOT_PS:

      invalid_bitcnt = INVALID_BITCOUNT_LC;

      break;

    case AOT_AAC_LD:

    case AOT_AAC_ELD:

      invalid_bitcnt = INVALID_BITCOUNT_LD;

      break;

  }

  while (i < max_sfb) {

    if (pstr_section[i].section_bits == invalid_bitcnt) {

      pstr_section[i].section_bits = (WORD16)ia_enhaacplus_enc_find_best_book(

          bit_look_up[i], &(pstr_section[i].code_book), aot);

    }

    i++;

  }

}

static VOID ia_enhaacplus_enc_gm_stage1(

    ixheaace_section_info *pstr_section_info,

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    const WORD32 max_sfb, const WORD32 *ptr_side_info_tab, WORD32 aot) {

  WORD32 merge_start = 0, merge_end;

  do {

    for (merge_end = merge_start + 1; merge_end < max_sfb; merge_end++) {

      if (pstr_section_info[merge_start].code_book != pstr_section_info[merge_end].code_book) {

        break;

      }

      pstr_section_info[merge_start].sfb_cnt++;

      pstr_section_info[merge_start].section_bits += pstr_section_info[merge_end].section_bits;

      ia_enhaacplus_enc_merge_bit_look_up(bit_look_up[merge_start], bit_look_up[merge_end], aot);

    }

    pstr_section_info[merge_start].section_bits +=

        (WORD16)ptr_side_info_tab[pstr_section_info[merge_start].sfb_cnt];

    pstr_section_info[merge_end - 1].sfb_start = pstr_section_info[merge_start].sfb_start;

    merge_start = merge_end;

  } while (merge_start < max_sfb);

}

static VOID ia_enhaacplus_enc_gm_stage2(

    ixheaace_section_info *pstr_section_info,

    WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    const WORD32 max_sfb, const WORD32 *ptr_side_info_tab, WORD32 aot) {

  WORD32 i;

  for (i = 0; i + pstr_section_info[i].sfb_cnt < max_sfb; i += pstr_section_info[i].sfb_cnt) {

    merge_gain_look_up[i] =

        ia_enhaacplus_enc_calc_merge_gain(pstr_section_info, bit_look_up, ptr_side_info_tab, i,

                                          i + pstr_section_info[i].sfb_cnt, aot);

  }

  while (TRUE) {

    WORD32 max_merge_gain = 0, max_idx = 0, max_idx_next = 0, max_idx_last = 0;

    max_merge_gain = ia_enhaacplus_enc_find_max_merge(merge_gain_look_up, pstr_section_info,

                                                      max_sfb, &max_idx);

    if (max_merge_gain <= 0) {

      break;

    }

    max_idx_next = max_idx + pstr_section_info[max_idx].sfb_cnt;

    pstr_section_info[max_idx].sfb_cnt += pstr_section_info[max_idx_next].sfb_cnt;

    pstr_section_info[max_idx].section_bits +=

        pstr_section_info[max_idx_next].section_bits - (WORD16)max_merge_gain;

    ia_enhaacplus_enc_merge_bit_look_up(bit_look_up[max_idx], bit_look_up[max_idx_next], aot);

    if (max_idx != 0) {

      max_idx_last = pstr_section_info[max_idx - 1].sfb_start;

      merge_gain_look_up[max_idx_last] = ia_enhaacplus_enc_calc_merge_gain(

          pstr_section_info, bit_look_up, ptr_side_info_tab, max_idx_last, max_idx, aot);

    }

    max_idx_next = max_idx + pstr_section_info[max_idx].sfb_cnt;

    pstr_section_info[max_idx_next - 1].sfb_start = pstr_section_info[max_idx].sfb_start;

    if (max_idx_next < max_sfb) {

      merge_gain_look_up[max_idx] = ia_enhaacplus_enc_calc_merge_gain(

          pstr_section_info, bit_look_up, ptr_side_info_tab, max_idx, max_idx_next, aot);

    }

  }

}

static IA_ERRORCODE ia_enhaacplus_enc_noiseless_counter(

    ixheaace_section_data *pstr_section_data,

    WORD32 merge_gain_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG],

    WORD32 bit_look_up[MAXIMUM_SCALE_FACTOR_BAND_LONG][CODE_BCK_ESC_NDX + 1],

    const WORD16 *ptr_quant_spec, const UWORD16 *ptr_max_val_in_sfb, const WORD32 *ptr_sfb_offset,

    const WORD32 block_type, WORD32 *ptr_side_info_tab_long, WORD32 *ptr_side_info_tab_short,

    ixheaace_huffman_tables *pstr_huffman_tbl, WORD32 aot) {

  WORD32 grp_idx;

  WORD32 *ptr_side_info_tab = 0;

  ixheaace_section_info *pstr_section_info;

  WORD32 i;

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

    memset(bit_look_up[i], 0, (CODE_BCK_ESC_NDX + 1) * sizeof(bit_look_up[0][0]));

  }

  /* counting previous operations */

  switch (block_type) {

    case LONG_WINDOW:

    case START_WINDOW:

    case STOP_WINDOW:

      ptr_side_info_tab = ptr_side_info_tab_long;

      break;

    case SHORT_WINDOW:

      ptr_side_info_tab = ptr_side_info_tab_short;

      break;

    default:

      return IA_EXHEAACE_EXE_FATAL_INVALID_BLOCK_TYPE;

  }

  pstr_section_data->num_of_sections = 0;

  pstr_section_data->huffman_bits = 0;

  pstr_section_data->side_info_bits = 0;

  if (pstr_section_data->max_sfb_per_grp == 0) {

    return IA_NO_ERROR;

  }

  for (grp_idx = 0; grp_idx < pstr_section_data->sfb_cnt;

       grp_idx += pstr_section_data->sfb_per_group) {

    pstr_section_info = pstr_section_data->section + pstr_section_data->num_of_sections;

    ia_enhaacplus_enc_build_bit_look_up(ptr_quant_spec, pstr_section_data->max_sfb_per_grp,

                                        ptr_sfb_offset + grp_idx, ptr_max_val_in_sfb + grp_idx,

                                        bit_look_up, pstr_section_info, pstr_huffman_tbl, aot);

    ia_enhaacplus_enc_gm_stage0(pstr_section_info, bit_look_up,

                                pstr_section_data->max_sfb_per_grp, aot);

    ia_enhaacplus_enc_gm_stage1(pstr_section_info, bit_look_up,

                                pstr_section_data->max_sfb_per_grp, ptr_side_info_tab, aot);

    ia_enhaacplus_enc_gm_stage2(pstr_section_info, merge_gain_look_up, bit_look_up,

                                pstr_section_data->max_sfb_per_grp, ptr_side_info_tab, aot);

    for (i = 0; i < pstr_section_data->max_sfb_per_grp; i += pstr_section_info[i].sfb_cnt) {

      ia_enhaacplus_enc_find_best_book(bit_look_up[i], &(pstr_section_info[i].code_book), aot);

      pstr_section_info[i].sfb_start += (WORD8)grp_idx;

      pstr_section_data->huffman_bits +=

          pstr_section_info[i].section_bits - ptr_side_info_tab[pstr_section_info[i].sfb_cnt];

      pstr_section_data->side_info_bits += ptr_side_info_tab[pstr_section_info[i].sfb_cnt];

      pstr_section_data->section[pstr_section_data->num_of_sections++] = pstr_section_info[i];

    }

  }

  return IA_NO_ERROR;

}

static WORD32 ia_enhaacplus_enc_bit_count_scalefactor_delta(

    WORD32 delta, ixheaace_huffman_tables *pstr_huffman_tbl) {

  return pstr_huffman_tbl->huff_ltabscf[delta + CODE_BCK_SCF_LAV];

}

static IA_ERRORCODE ia_enhaacplus_enc_scf_count(const WORD16 *ptr_scale_fac,

                                                const UWORD16 *ptr_max_val_in_sfb,

                                                ixheaace_section_data *pstr_section_data,

                                                ixheaace_huffman_tables *pstr_huffman_tbl) {

  WORD32 sect_idx1 = 0;

  WORD32 sfb_idx1 = 0;

  WORD32 scf_idx = 0;

  WORD32 sect_idx2 = 0;

  WORD32 sfb_idx2 = 0;

  WORD32 last_val_scf = 0;

  WORD32 delta_scf = 0;

  WORD32 found = 0;

  WORD32 scf_skip_counter = 0;

  pstr_section_data->scale_fac_bits = 0;

  if (ptr_scale_fac == 0) {

    return IA_EXHEAACE_EXE_FATAL_INVALID_SCALE_FACTOR_GAIN;

  }

  last_val_scf = 0;

  pstr_section_data->first_scf = 0;

  for (sect_idx1 = 0; sect_idx1 < pstr_section_data->num_of_sections; sect_idx1++) {

    if (pstr_section_data->section[sect_idx1].code_book != CODE_BCK_ZERO_NO) {

      pstr_section_data->first_scf = pstr_section_data->section[sect_idx1].sfb_start;

      last_val_scf = ptr_scale_fac[pstr_section_data->first_scf];

      break;

    }

  }

  for (sect_idx1 = 0; sect_idx1 < pstr_section_data->num_of_sections; sect_idx1++) {

    if ((pstr_section_data->section[sect_idx1].code_book != CODE_BCK_ZERO_NO) &&

        (pstr_section_data->section[sect_idx1].code_book != CODE_BCK_PNS_NO)) {

      for (sfb_idx1 = pstr_section_data->section[sect_idx1].sfb_start;

           sfb_idx1 < pstr_section_data->section[sect_idx1].sfb_start +

                          pstr_section_data->section[sect_idx1].sfb_cnt;

           sfb_idx1++) {

        if (ptr_max_val_in_sfb[sfb_idx1] == 0) {

          found = 0;

          if (scf_skip_counter == 0) {

            if (sfb_idx1 == (pstr_section_data->section[sect_idx1].sfb_start +

                             pstr_section_data->section[sect_idx1].sfb_cnt - 1)) {

              found = 0;

            } else {

              for (scf_idx = (sfb_idx1 + 1);

                   scf_idx < pstr_section_data->section[sect_idx1].sfb_start +

                                 pstr_section_data->section[sect_idx1].sfb_cnt;

                   scf_idx++) {

                if (ptr_max_val_in_sfb[scf_idx] != 0) {

                  found = 1;

                  if ((abs32(ptr_scale_fac[scf_idx] - last_val_scf)) < CODE_BCK_SCF_LAV) {

                    delta_scf = 0;

                  } else {

                    delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);

                    last_val_scf = ptr_scale_fac[sfb_idx1];

                    scf_skip_counter = 0;

                  }

                  break;

                }

                /* count scalefactor skip */

                scf_skip_counter = scf_skip_counter + 1;

              }

            }

            /* search for the next ptr_max_val_in_sfb[] != 0 in all other sections */

            for (sect_idx2 = (sect_idx1 + 1);

                 (sect_idx2 < pstr_section_data->num_of_sections) && (found == 0); sect_idx2++) {

              if ((pstr_section_data->section[sect_idx2].code_book != CODE_BCK_ZERO_NO) &&

                  (pstr_section_data->section[sect_idx2].code_book != CODE_BCK_PNS_NO)) {

                for (sfb_idx2 = pstr_section_data->section[sect_idx2].sfb_start;

                     sfb_idx2 < pstr_section_data->section[sect_idx2].sfb_start +

                                    pstr_section_data->section[sect_idx2].sfb_cnt;

                     sfb_idx2++) {

                  if (ptr_max_val_in_sfb[sfb_idx2] != 0) {

                    found = 1;

                    if ((abs32(ptr_scale_fac[sfb_idx2] - last_val_scf)) < CODE_BCK_SCF_LAV) {

                      delta_scf = 0;

                    } else {

                      delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);

                      last_val_scf = ptr_scale_fac[sfb_idx1];

                      scf_skip_counter = 0;

                    }

                    break;

                  }

                  scf_skip_counter = scf_skip_counter + 1;

                }

              }

            }

            if (found == 0) {

              delta_scf = 0;

              scf_skip_counter = 0;

            }

          } else {

            delta_scf = 0;

            scf_skip_counter = scf_skip_counter - 1;

          }

        } else {

          delta_scf = -(ptr_scale_fac[sfb_idx1] - last_val_scf);

          last_val_scf = ptr_scale_fac[sfb_idx1];

        }

        pstr_section_data->scale_fac_bits +=

            ia_enhaacplus_enc_bit_count_scalefactor_delta(delta_scf, pstr_huffman_tbl);

      }

    }

  }

  return IA_NO_ERROR;

}

IA_ERRORCODE ia_enhaacplus_enc_dyn_bitcount(

    const WORD16 *ptr_quant_spec, const UWORD16 *ptr_max_val_in_sfb, const WORD16 *ptr_scale_fac,

    const WORD32 block_type, const WORD32 sfb_cnt, const WORD32 max_sfb_per_grp,

    const WORD32 sfb_per_grp, const WORD32 *ptr_sfb_offset,

    ixheaace_section_data *pstr_section_data, WORD32 *ptr_side_info_tab_long,

    WORD32 *ptr_side_info_tab_short, ixheaace_huffman_tables *ptr_huffman_tbl,

    WORD32 *ptr_scratch_buf, WORD32 aot, WORD32 *bit_cnt) {

  IA_ERRORCODE err_code;

  WORD32(*ptr_bit_look_up)

  [CODE_BCK_ESC_NDX + 1] = (WORD32(*)[CODE_BCK_ESC_NDX + 1]) ptr_scratch_buf;

  WORD32 *ptr_merge_gain_look_up =

      ptr_scratch_buf + MAXIMUM_SCALE_FACTOR_BAND_LONG * (CODE_BCK_ESC_NDX + 1);

  *bit_cnt = 0;

  pstr_section_data->block_type = block_type;

  pstr_section_data->sfb_cnt = sfb_cnt;

  pstr_section_data->sfb_per_group = sfb_per_grp;

  pstr_section_data->total_groups_cnt = sfb_cnt / sfb_per_grp;

  pstr_section_data->max_sfb_per_grp = max_sfb_per_grp;

  err_code = ia_enhaacplus_enc_noiseless_counter(

      pstr_section_data, ptr_merge_gain_look_up, ptr_bit_look_up, ptr_quant_spec,

      ptr_max_val_in_sfb, ptr_sfb_offset, block_type, ptr_side_info_tab_long,

      ptr_side_info_tab_short, ptr_huffman_tbl, aot);

  if (err_code != IA_NO_ERROR) {

    return err_code;

  }

  err_code = ia_enhaacplus_enc_scf_count(ptr_scale_fac, ptr_max_val_in_sfb, pstr_section_data,

                                         ptr_huffman_tbl);

  if (err_code != IA_NO_ERROR) {

    return err_code;

  }

  *bit_cnt = (pstr_section_data->huffman_bits + pstr_section_data->side_info_bits +

              pstr_section_data->scale_fac_bits);

  return IA_NO_ERROR;

}

VOID ia_enhaacplus_enc_bitcount_init(WORD32 *side_info_tab_long, WORD32 *side_info_tab_short) {

  WORD32 i;

  /* side_info_tab_long[] */

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

    side_info_tab_long[i] = ia_enhaacplus_enc_calc_side_info_bits(i, LONG_WINDOW);

  }

  /* side_info_tab_short[] */

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

    side_info_tab_short[i] = ia_enhaacplus_enc_calc_side_info_bits(i, SHORT_WINDOW);

  }

}