xref: /aosp_15_r20/external/libxaac/encoder/ixheaace_static_bits.c (revision 15dc779a375ca8b5125643b829a8aa4b70d7f451)

/******************************************************************************
 *                                                                            *
 * 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 <stddef.h>
#include "ixheaac_type_def.h"
#include "ixheaace_aac_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_adjust_threshold_data.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_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"

static WORD32 ia_enhaacplus_enc_count_ms_mask_bits(WORD32 sfb_cnt, WORD32 sfb_per_group,
                                                   WORD32 max_sfb_per_grp,
                                                   ixheaace_tools_info *pstr_tools_info) {
  WORD32 ms_bits = 0, sfb_off;

  switch (pstr_tools_info->ms_digest) {
    case MS_NONE:
    case MS_ALL:
      break;

    case MS_SOME:

      for (sfb_off = 0; sfb_off < sfb_cnt; sfb_off += sfb_per_group) {
        ms_bits += max_sfb_per_grp;
      }
      break;
  }

  return ms_bits;
}

static WORD32 ia_enhaacplus_enc_tns_count(ixheaace_temporal_noise_shaping_params *pstr_tns_info,
                                          WORD32 block_type) {
  WORD32 i, k;
  WORD32 tns_present;
  WORD32 num_windows;
  WORD32 count;
  WORD32 coef_bits;

  count = 0;
  num_windows = (block_type == 2 ? 8 : 1);
  tns_present = 0;

  for (i = 0; i < num_windows; i++) {
    if (pstr_tns_info->tns_active[i] == 1) {
      tns_present = 1;
    }
  }

  if (tns_present == 1) {
    for (i = 0; i < num_windows; i++) {
      count += (block_type == SHORT_WINDOW ? 1 : 2);

      if (pstr_tns_info->tns_active[i]) {
        count += (block_type == SHORT_WINDOW ? 8 : 12);

        if (pstr_tns_info->order[i]) {
          count += 2; /*coef_compression */

          if (pstr_tns_info->coef_res[i] == 4) {
            coef_bits = 3;

            for (k = 0; k < pstr_tns_info->order[i]; k++) {
              if (pstr_tns_info->coef[i * TEMPORAL_NOISE_SHAPING_MAX_ORDER_SHORT + k] > 3 ||
                  pstr_tns_info->coef[i * TEMPORAL_NOISE_SHAPING_MAX_ORDER_SHORT + k] < -4) {
                coef_bits = 4;
                break;
              }
            }
          } else {
            coef_bits = 2;

            for (k = 0; k < pstr_tns_info->order[i]; k++) {
              if (pstr_tns_info->coef[i * TEMPORAL_NOISE_SHAPING_MAX_ORDER_SHORT + k] > 1 ||
                  pstr_tns_info->coef[i * TEMPORAL_NOISE_SHAPING_MAX_ORDER_SHORT + k] < -2) {
                coef_bits = 3;
                break;
              }
            }
          }

          for (k = 0; k < pstr_tns_info->order[i]; k++) {
            count += coef_bits;
          }
        }
      }
    }
  }

  return count;
}

static WORD32 ia_enhaacplus_enc_count_tns_bits(
    ixheaace_temporal_noise_shaping_params *pstr_tns_info, WORD32 block_type) {
  return (ia_enhaacplus_enc_tns_count(pstr_tns_info, block_type));
}

WORD32 ia_enhaacplus_enc_count_static_bitdemand(
    ixheaace_psy_out_channel **psy_out_ch,
    ixheaace_psy_out_element *pstr_psy_out_element, WORD32 channels, WORD32 aot, WORD32 adts_flag,
    WORD32 stat_bits_flag, WORD32 flag_last_element) {
  WORD32 static_bits = 0;
  WORD32 ch;

  switch (channels) {
    case 1:

      static_bits += SI_ID_BITS + SI_SCE_BITS + SI_ICS_BITS;

      static_bits += ia_enhaacplus_enc_count_tns_bits(&(psy_out_ch[0]->tns_info),
                                                      psy_out_ch[0]->window_sequence);
      switch (psy_out_ch[0]->window_sequence) {
        case LONG_WINDOW:
        case START_WINDOW:
        case STOP_WINDOW:

          static_bits += SI_ICS_INFO_BITS_LONG;
          break;

        case SHORT_WINDOW:

          static_bits += SI_ICS_INFO_BITS_SHORT;
          break;
      }
      break;

    case 2:
      static_bits += SI_ID_BITS + SI_CPE_BITS + 2 * SI_ICS_BITS;

      static_bits += SI_CPE_MS_MASK_BITS;

      static_bits += ia_enhaacplus_enc_count_ms_mask_bits(
          psy_out_ch[0]->sfb_count, psy_out_ch[0]->sfb_per_group, psy_out_ch[0]->max_sfb_per_grp,
          &pstr_psy_out_element->tools_info);

      switch (psy_out_ch[0]->window_sequence) {
        case LONG_WINDOW:
        case START_WINDOW:
        case STOP_WINDOW:

          static_bits += SI_ICS_INFO_BITS_LONG;
          break;

        case SHORT_WINDOW:

          static_bits += SI_ICS_INFO_BITS_SHORT;
          break;
      }

      for (ch = 0; ch < 2; ch++) {
        static_bits += ia_enhaacplus_enc_count_tns_bits(&(psy_out_ch[ch]->tns_info),
                                                        psy_out_ch[ch]->window_sequence);
      }

      break;
  }

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
    if (!(adts_flag)) {
      return static_bits + stat_bits_flag * 8;
    }

    if (adts_flag && (stat_bits_flag) && (flag_last_element)) {
      return static_bits + 56;
    } else {
      return static_bits;
    }
  } else {
    return static_bits;  // Default Case
  }
}