/src/libxaac/encoder/ixheaace_dynamic_bits.c

Source (jump to first uncovered line)
/******************************************************************************
 *                                                                            *
 * 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);
  }
}

Coverage Report

Created: 2025-07-12 07:02