libxaac/encoder/ixheaace_write_bitstream.c

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

#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"

#include "ixheaace_bitbuffer.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_block_switch.h"
#include "ixheaace_psy_data.h"
#include "ixheaace_interface.h"
#include "ixheaace_bits_count.h"
#include "ixheaace_dynamic_bits.h"
#include "ixheaace_adjust_threshold_data.h"
#include "ixheaace_qc_data.h"
#include "ixheaace_write_bitstream.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"

#include "ixheaace_channel_map.h"
#include "ixheaace_write_adts_adif.h"

static VOID PLATFORM_INLINE
ia_enhaacplus_enc_encode_gain_control_data(ixheaace_bit_buf_handle pstr_bit_stream_handle)

{
  ixheaace_write_bits(pstr_bit_stream_handle, 0, 1);
}
static WORD32 ia_enhaacplus_enc_encode_spectral_data(
    WORD32 *pstr_sfb_offset, ixheaace_section_data *pstr_section_data, WORD16 *ptr_quant_spectrum,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, ixheaace_huffman_tables *ptr_huffman_tbl) {
  WORD32 i, sfb;
  WORD32 dbg_val;

  dbg_val = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);

  for (i = 0; i < pstr_section_data->num_of_sections; i++) {
    for (sfb = pstr_section_data->section[i].sfb_start;
         sfb < pstr_section_data->section[i].sfb_start + pstr_section_data->section[i].sfb_cnt;
         sfb++) {
      ia_enhaacplus_enc_code_values(ptr_quant_spectrum + pstr_sfb_offset[sfb],
                                    pstr_sfb_offset[sfb + 1] - pstr_sfb_offset[sfb],
                                    pstr_section_data->section[i].code_book,
                                    pstr_bit_stream_handle, ptr_huffman_tbl);
    }
  }

  return (ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle) - dbg_val);
}

static VOID ia_enhaacplus_enc_encode_global_gain(WORD32 global_gain, WORD32 log_norm,
                                                 WORD32 scalefac,
                                                 ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  ixheaace_write_bits(pstr_bit_stream_handle,
                      global_gain - scalefac + GLOBAL_GAIN_OFFSET - 4 * log_norm, 8);
}

static VOID ia_enhaacplus_enc_encode_ics_info(WORD32 block_type, WORD32 win_shape,
                                              WORD32 grouping_mask,
                                              ixheaace_section_data *pstr_section_data,
                                              ixheaace_bit_buf_handle pstr_bit_stream_handle,
                                              WORD32 aot) {
  WORD32 tmp;

  switch (aot) {
    case AOT_AAC_LD:
      tmp = ((ICS_RESERVED_BIT << 3) | (block_type << 1) | win_shape);
      ixheaace_write_bits(pstr_bit_stream_handle, tmp, 4);
      break;

    case AOT_AAC_LC:
    case AOT_SBR:
    case AOT_PS:
      tmp = ((ICS_RESERVED_BIT << 3) | (block_type << 1) | win_shape);
      ixheaace_write_bits(pstr_bit_stream_handle, tmp, 4);
      break;
  }
  switch (block_type) {
    case LONG_WINDOW:
    case START_WINDOW:
    case STOP_WINDOW:

      switch (aot) {
        case AOT_AAC_LC:
        case AOT_SBR:
        case AOT_PS:
          tmp = pstr_section_data->max_sfb_per_grp << 1;
          ixheaace_write_bits(pstr_bit_stream_handle, tmp, 7);
          break;

        case AOT_AAC_LD:
          tmp = pstr_section_data->max_sfb_per_grp << 1;
          ixheaace_write_bits(pstr_bit_stream_handle, tmp, 7);
          break;
        default:
          ixheaace_write_bits(pstr_bit_stream_handle, pstr_section_data->max_sfb_per_grp, 6);
      }
      break;

    case SHORT_WINDOW:

      // Write grouping bits

      tmp = pstr_section_data->max_sfb_per_grp << (TRANS_FAC - 1) | grouping_mask;
      ixheaace_write_bits(pstr_bit_stream_handle, tmp, TRANS_FAC - 1 + 4);

      break;
  }
}

static WORD32 ia_enhaacplus_enc_encode_section_data(
    ixheaace_section_data *pstr_section_data, ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  WORD32 sect_escape_val = 0, sect_len_bits = 0;
  WORD32 sect_len;
  WORD32 i;
  WORD32 dbg_val = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);

  switch (pstr_section_data->block_type) {
    case LONG_WINDOW:
    case START_WINDOW:
    case STOP_WINDOW:

      sect_escape_val = SECT_ESC_VAL_LONG;
      sect_len_bits = SECT_BITS_LONG;
      break;

    case SHORT_WINDOW:

      sect_escape_val = SECT_ESC_VAL_SHORT;
      sect_len_bits = SECT_BITS_SHORT;
      break;
  }

  for (i = 0; i < pstr_section_data->num_of_sections; i++) {
    ixheaace_write_bits(pstr_bit_stream_handle, pstr_section_data->section[i].code_book, 4);

    sect_len = pstr_section_data->section[i].sfb_cnt;

    while (sect_len >= sect_escape_val) {
      ixheaace_write_bits(pstr_bit_stream_handle, sect_escape_val, (UWORD8)sect_len_bits);

      sect_len -= sect_escape_val;
    }

    ixheaace_write_bits(pstr_bit_stream_handle, sect_len, (UWORD8)sect_len_bits);
  }

  return (ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle) - dbg_val);
}

static VOID ia_enhaacplus_enc_code_scale_factor_delta_lav(WORD32 delta,
                                                            ixheaace_bit_buf_handle ptr_bitstream,
                                                            const UWORD16 *ptr_pltabscf,
                                                            const UWORD32 *ptr_pctabscf) {
  WORD32 code_word, code_length;

  code_word = ptr_pctabscf[delta];
  code_length = ptr_pltabscf[delta];

  ixheaace_write_bits(ptr_bitstream, code_word, (UWORD8)code_length);
}
static WORD32 ia_enhaacplus_enc_encode_scalefactor_data(
    UWORD16 *ptr_max_val_in_sfb, ixheaace_section_data *pstr_section_data, WORD16 *ptr_scalefac,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, ixheaace_huffman_tables *pstr_huffman_tbl) {
  WORD32 i, j, last_val_scf, delta_scf;
  WORD32 dbg_val = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);
  const UWORD16 *ptr_pltabscf = &pstr_huffman_tbl->huff_ltabscf[CODE_BCK_SCF_LAV];
  const UWORD32 *ptr_pctabscf = &pstr_huffman_tbl->huff_ctabscf[CODE_BCK_SCF_LAV];

  last_val_scf = ptr_scalefac[pstr_section_data->first_scf];

  for (i = 0; i < pstr_section_data->num_of_sections; i++) {
    if (pstr_section_data->section[i].code_book != CODE_BCK_ZERO_NO) {
      for (j = pstr_section_data->section[i].sfb_start;
           j < pstr_section_data->section[i].sfb_start + pstr_section_data->section[i].sfb_cnt;
           j++) {
        if (ptr_max_val_in_sfb[j] == 0) {
          delta_scf = 0;
        } else {
          delta_scf = -(ptr_scalefac[j] - last_val_scf);

          last_val_scf = ptr_scalefac[j];
        }
        ia_enhaacplus_enc_code_scale_factor_delta_lav(delta_scf, pstr_bit_stream_handle,
                                                          ptr_pltabscf, ptr_pctabscf);
      }
    }
  }

  return (ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle) - dbg_val);
}

static VOID ia_enhaacplus_enc_encode_ms_info(WORD32 sfb_cnt, WORD32 sfb_grp, WORD32 max_sfb,
                                             WORD32 ms_digest, WORD32 *js_flags,
                                             ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  WORD32 sfb, sfb_offset;
  UWORD32 tmp_var = 0;
  WORD32 *jsflag;
  UWORD8 num_of_bits, remaining = 0;

  switch (ms_digest) {
    case MS_NONE:
      ixheaace_write_bits(pstr_bit_stream_handle, SI_MS_MASK_NONE, 2);
      break;

    case MS_ALL:
      ixheaace_write_bits(pstr_bit_stream_handle, SI_MS_MASK_ALL, 2);
      break;

    case MS_SOME:
      ixheaace_write_bits(pstr_bit_stream_handle, SI_MS_MASK_SOME, 2);

      if (max_sfb > 32) {
        num_of_bits = 32;
        remaining = (UWORD8)(max_sfb - 32);
      } else
        num_of_bits = (UWORD8)max_sfb;

      for (sfb_offset = 0; sfb_offset < sfb_cnt; sfb_offset += sfb_grp) {
        WORD8 flag;
        jsflag = &js_flags[sfb_offset];
        tmp_var = 0;

        for (sfb = num_of_bits - 1; sfb >= 0; sfb--) {
          flag = (WORD8)(*jsflag++);
          tmp_var = ((tmp_var << 1) | flag);
        }

        ixheaace_write_bits(pstr_bit_stream_handle, tmp_var, num_of_bits);

        if (remaining) {
          for (sfb = remaining - 1; sfb >= 0; sfb--) {
            flag = (WORD8)(*jsflag++);
            tmp_var = ((tmp_var << 1) | flag);
          }

          ixheaace_write_bits(pstr_bit_stream_handle, tmp_var, remaining);
        }
      }

      break;
  }
}

static VOID ia_enhaacplus_enc_encode_tns_data(
    ixheaace_temporal_noise_shaping_params pstr_tns_info, WORD32 block_type,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, WORD32 aot) {
  WORD32 i, k;
  WORD32 tns_present;
  WORD32 num_windows;
  WORD32 coef_bits;

  UWORD32 tmp;
  UWORD8 val;

  num_windows = (block_type == 2 ? TRANS_FAC : 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 == 0) {
    ixheaace_write_bits(pstr_bit_stream_handle, 0, 1);

    if (AOT_AAC_LD == aot) {
      ia_enhaacplus_enc_encode_gain_control_data(pstr_bit_stream_handle);
    }
  } else {
    /* there is data to be written*/

    ixheaace_write_bits(pstr_bit_stream_handle, 1, 1); /* data_present */

    if (aot == AOT_AAC_LD) {
      ia_enhaacplus_enc_encode_gain_control_data(pstr_bit_stream_handle);
    }

    for (i = 0; i < num_windows; i++) {
      ixheaace_write_bits(pstr_bit_stream_handle, pstr_tns_info.tns_active[i],
                          (UWORD8)(block_type == 2 ? 1 : 2));

      if (pstr_tns_info.tns_active[i]) {
        tmp = ((pstr_tns_info.coef_res[i] == 4 ? 1 : 0)
                   << ((block_type == 2 ? 4 : 6) + (block_type == 2 ? 3 : 5)) |
               pstr_tns_info.length[i] << (block_type == 2 ? 3 : 5) | pstr_tns_info.order[i]);

        val = (UWORD8)(1 + (block_type == 2 ? 4 : 6) + (block_type == 2 ? 3 : 5));

        ixheaace_write_bits(pstr_bit_stream_handle, tmp, val);

        if (pstr_tns_info.order[i]) {
          ixheaace_write_bits(pstr_bit_stream_handle, FILTER_DIRECTION, 1);

          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;
              }
            }
          }

          ixheaace_write_bits(pstr_bit_stream_handle, -(coef_bits - pstr_tns_info.coef_res[i]),
                              1); /*coef_compres*/

          for (k = 0; k < pstr_tns_info.order[i]; k++) {
            static const WORD32 rmask[] = {0, 1, 3, 7, 15};

            ixheaace_write_bits(
                pstr_bit_stream_handle,
                pstr_tns_info.coef[i * TEMPORAL_NOISE_SHAPING_MAX_ORDER_SHORT + k] &
                    rmask[coef_bits],
                (UWORD8)coef_bits);
          }
        }
      }
    }
  }
}

static VOID PLATFORM_INLINE
ia_enhaacplus_enc_encode_pulse_data(ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  ixheaace_write_bits(pstr_bit_stream_handle, 0, 1);
}

static IA_ERRORCODE ia_enhaacplus_enc_write_ic_stream(
    WORD32 common_window, WORD32 win_shape, WORD32 grouping_mask, WORD32 *pstr_sfb_offset,
    WORD16 *ptr_scf, UWORD16 *ptr_max_val_in_sfb, WORD32 global_gain, WORD16 *ptr_quant_spec,
    ixheaace_section_data *pstr_section_data, ixheaace_bit_buf_handle pstr_bit_stream_handle,
    WORD32 aot, ixheaace_temporal_noise_shaping_params pstr_tns_info,
    ixheaace_aac_tables *pstr_aac_tables) {
  WORD32 log_norm = -1;

  ia_enhaacplus_enc_encode_global_gain(
      global_gain, log_norm, ptr_scf[pstr_section_data->first_scf], pstr_bit_stream_handle);
  if (!common_window) {
    ia_enhaacplus_enc_encode_ics_info(pstr_section_data->block_type, win_shape, grouping_mask,
                                      pstr_section_data, pstr_bit_stream_handle, aot);
  }

  if (ia_enhaacplus_enc_encode_section_data(pstr_section_data, pstr_bit_stream_handle) !=
      pstr_section_data->side_info_bits) {
    return IA_EXHEAACE_EXE_FATAL_INVALID_SIDE_INFO_BITS;
  }

  if (ia_enhaacplus_enc_encode_scalefactor_data(
          ptr_max_val_in_sfb, pstr_section_data, ptr_scf, pstr_bit_stream_handle,
          pstr_aac_tables->pstr_huff_tab) != pstr_section_data->scale_fac_bits) {
    return IA_EXHEAACE_EXE_FATAL_INVALID_SCALE_FACTOR_BITS;
  }

  if (aot == AOT_AAC_LC || aot == AOT_AAC_LD || aot == AOT_SBR || aot == AOT_PS) {
    ia_enhaacplus_enc_encode_pulse_data(pstr_bit_stream_handle);
  }
  ia_enhaacplus_enc_encode_tns_data(pstr_tns_info, pstr_section_data->block_type,
                                    pstr_bit_stream_handle, aot);

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
    ia_enhaacplus_enc_encode_gain_control_data(pstr_bit_stream_handle);
  }

  if (ia_enhaacplus_enc_encode_spectral_data(
          pstr_sfb_offset, pstr_section_data, ptr_quant_spec, pstr_bit_stream_handle,
          pstr_aac_tables->pstr_huff_tab) != pstr_section_data->huffman_bits) {
    return IA_EXHEAACE_EXE_FATAL_INVALID_HUFFMAN_BITS;
  }
  return IA_NO_ERROR;
}

static IA_ERRORCODE ia_enhaacplus_enc_write_single_chan_elem(
    WORD32 instance_tag, WORD32 *pstr_sfb_offset, ixheaace_qc_out_channel *pstr_qc_out_ch,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, WORD32 aot,
    ixheaace_temporal_noise_shaping_params pstr_tns_info, ixheaace_aac_tables *pstr_aac_tables) {
  IA_ERRORCODE err_code;

  switch (aot) {
    case AOT_AAC_LC:
    case AOT_SBR:
    case AOT_PS:
      ixheaace_write_bits(pstr_bit_stream_handle, ID_SCE, 3);
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      break;
    case AOT_AAC_LD:
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      break;
  }

  err_code = ia_enhaacplus_enc_write_ic_stream(
      0, pstr_qc_out_ch->win_shape, pstr_qc_out_ch->grouping_mask, pstr_sfb_offset,
      pstr_qc_out_ch->scalefactor, pstr_qc_out_ch->max_val_in_sfb, pstr_qc_out_ch->global_gain,
      pstr_qc_out_ch->quant_spec, &(pstr_qc_out_ch->section_data), pstr_bit_stream_handle, aot,
      pstr_tns_info, pstr_aac_tables);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  return IA_NO_ERROR;
}

static IA_ERRORCODE ia_enhaacplus_enc_write_channel_pair_element(
    WORD32 instance_tag, WORD32 ms_digest, WORD32 ms_flags[MAXIMUM_GROUPED_SCALE_FACTOR_BAND],
    WORD32 *pstr_sfb_offset[2], ixheaace_qc_out_channel pstr_qc_out_ch[2],
    ixheaace_bit_buf_handle pstr_bit_stream_handle, WORD32 aot,
    ixheaace_temporal_noise_shaping_params pstr_tns_info[2],
    ixheaace_aac_tables *pstr_aac_tables) {
  IA_ERRORCODE err_code;

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
    ixheaace_write_bits(pstr_bit_stream_handle, ID_CPE, 3);
  }

  switch (aot) {
    case AOT_AAC_LD:
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      ixheaace_write_bits(pstr_bit_stream_handle, 1, 1); /* common window */
      break;

    case AOT_AAC_LC:
    case AOT_SBR:
    case AOT_PS:
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      ixheaace_write_bits(pstr_bit_stream_handle, 1, 1);
      break;
  }

  ia_enhaacplus_enc_encode_ics_info(pstr_qc_out_ch[0].section_data.block_type,
                                    pstr_qc_out_ch[0].win_shape, pstr_qc_out_ch[0].grouping_mask,
                                    &(pstr_qc_out_ch[0].section_data), pstr_bit_stream_handle,
                                    aot);

  ia_enhaacplus_enc_encode_ms_info(pstr_qc_out_ch[0].section_data.sfb_cnt,
                                   pstr_qc_out_ch[0].section_data.sfb_per_group,
                                   pstr_qc_out_ch[0].section_data.max_sfb_per_grp, ms_digest,
                                   ms_flags, pstr_bit_stream_handle);
  err_code = ia_enhaacplus_enc_write_ic_stream(
      1, pstr_qc_out_ch[0].win_shape, pstr_qc_out_ch[0].grouping_mask, pstr_sfb_offset[0],
      pstr_qc_out_ch[0].scalefactor, pstr_qc_out_ch[0].max_val_in_sfb,
      pstr_qc_out_ch[0].global_gain, pstr_qc_out_ch[0].quant_spec,
      &(pstr_qc_out_ch[0].section_data), pstr_bit_stream_handle, aot, pstr_tns_info[0],
      pstr_aac_tables);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  err_code = ia_enhaacplus_enc_write_ic_stream(
      1, pstr_qc_out_ch[1].win_shape, pstr_qc_out_ch[1].grouping_mask, pstr_sfb_offset[1],
      pstr_qc_out_ch[1].scalefactor, pstr_qc_out_ch[1].max_val_in_sfb,
      pstr_qc_out_ch[1].global_gain, pstr_qc_out_ch[1].quant_spec,
      &(pstr_qc_out_ch[1].section_data), pstr_bit_stream_handle, aot, pstr_tns_info[1],
      pstr_aac_tables);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  return IA_NO_ERROR;
}

static VOID ia_enhaacplus_enc_write_fill_element_LD(
    const UWORD8 *ptr_anc_bytes, WORD32 total_fill_bits,
    ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  WORD32 i, cnt, cnt1, remaining = 0;

  /*
    Write fill Element(s):
    amount of a fill element can be 7+X*8 Bits, X element of [0..270]
  */
  // ID_FIL and the FILL element payload size, ( 3+ 4 bits) are not sent.
  // but they are accounted in the earlier code, so subtracting it here

  total_fill_bits -= 7;
  while (total_fill_bits > 0) {
    cnt = MIN((total_fill_bits >> 3), ((1 << 4) - 1));

    if (ptr_anc_bytes) {
      for (i = 0; i < cnt; i++) {
        ixheaace_write_bits(pstr_bit_stream_handle, *ptr_anc_bytes++, 8);
        total_fill_bits -= 8;
      }
      if (total_fill_bits < 8) {
        ixheaace_write_bits(pstr_bit_stream_handle, *ptr_anc_bytes++, (UWORD8)total_fill_bits);
        ixheaace_write_bits(pstr_bit_stream_handle, 0, (UWORD8)(8 - total_fill_bits));
        total_fill_bits = 0;
      }
    } else {
      cnt1 = cnt >> 2;
      remaining = cnt - (cnt1 << 2);

      for (i = 0; i < cnt1; i++) {
        ixheaace_write_bits(pstr_bit_stream_handle, 0, 32);
        total_fill_bits -= 32;
      }
      if (remaining)
        for (i = 0; i < remaining; i++) {
          ixheaace_write_bits(pstr_bit_stream_handle, 0, 8);
          total_fill_bits -= 8;
        }
    }
  }
}

static VOID ia_enhaacplus_enc_write_fill_element_LC(const UWORD8 *ptr_anc_bytes,
                                                    WORD32 total_fill_bits,
                                                    ixheaace_bit_buf_handle pstr_h_bit_stream) {
  WORD32 i, cnt, esc_count;

  while (total_fill_bits >= (3 + 4)) {
    cnt = MIN((total_fill_bits - (3 + 4)) / 8, ((1 << 4) - 1));

    ixheaace_write_bits(pstr_h_bit_stream, ID_FIL, 3);

    ixheaace_write_bits(pstr_h_bit_stream, cnt, 4);

    total_fill_bits -= (3 + 4);

    if (cnt == (1 << 4) - 1) {
      esc_count = MIN((total_fill_bits / 8) - ((1 << 4) - 1), (1 << 8) - 1);

      ixheaace_write_bits(pstr_h_bit_stream, esc_count, 8);

      total_fill_bits -= 8;

      cnt += esc_count - 1;
    }

    for (i = 0; i < cnt; i++) {
      if (ptr_anc_bytes)
        ixheaace_write_bits(pstr_h_bit_stream, *ptr_anc_bytes++, 8);
      else
        ixheaace_write_bits(pstr_h_bit_stream, 0, 8);

      total_fill_bits -= 8;
    }
  }
}

static IA_ERRORCODE ia_enhaacplus_enc_write_single_channel_element_LFE(
    WORD32 instance_tag, WORD32 *ptr_sfb_offset, ixheaace_qc_out_channel *pstr_qc_out_ch,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, WORD32 aot,
    ixheaace_temporal_noise_shaping_params pstr_tns_info, ixheaace_aac_tables *pstr_aac_tables) {
  IA_ERRORCODE err_code;
  switch (aot) {
    case AOT_AAC_LC:
    case AOT_SBR:
    case AOT_PS:
      ixheaace_write_bits(pstr_bit_stream_handle, ID_LFE, 3);
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      break;

    case AOT_AAC_LD:
      ixheaace_write_bits(pstr_bit_stream_handle, instance_tag, 4);
      break;
  }

  err_code = ia_enhaacplus_enc_write_ic_stream(
      0, pstr_qc_out_ch->win_shape, pstr_qc_out_ch->grouping_mask, ptr_sfb_offset,
      pstr_qc_out_ch->scalefactor, pstr_qc_out_ch->max_val_in_sfb, pstr_qc_out_ch->global_gain,
      pstr_qc_out_ch->quant_spec, &(pstr_qc_out_ch->section_data), pstr_bit_stream_handle, aot,
      pstr_tns_info, pstr_aac_tables);

  if (err_code != IA_NO_ERROR) {
    return err_code;
  }
  return IA_NO_ERROR;
}

static IA_ERRORCODE ia_enhaacplus_enc_write_single_channel_ind_coupling_element(
    WORD32 *ptr_sfb_offset, ixheaace_qc_out_channel *pstr_qc_out_ch,
    ixheaace_bit_buf_handle pstr_bit_stream_handle, WORD32 aot,
    ixheaace_temporal_noise_shaping_params pstr_tns_info, ixheaace_aac_tables *pstr_aac_tables) {
  IA_ERRORCODE err_code;
  ixheaace_write_bits(pstr_bit_stream_handle, ID_CCE, 3);

  /*Flag indication that this is an independent coupling channel*/
  ixheaace_write_bits(pstr_bit_stream_handle, 1, 1);

  /*number of coupled channel elements*/
  ixheaace_write_bits(pstr_bit_stream_handle, NUM_COUPLED_ELE, 3);

  /*Flag indicating target is CPE*/
  ixheaace_write_bits(pstr_bit_stream_handle, 1, 1);

  /*Instance tag of target CPE*/
  ixheaace_write_bits(pstr_bit_stream_handle, 0, 4);

  ixheaace_write_bits(pstr_bit_stream_handle, 3, 2);

  /*Flag indicating coupling after TNS*/
  ixheaace_write_bits(pstr_bit_stream_handle, 1, 1);

  /*Flag indicating sign of coupling*/
  ixheaace_write_bits(pstr_bit_stream_handle, 0, 1);

  /*Flag indicating Scale of coupling*/
  ixheaace_write_bits(pstr_bit_stream_handle, SCALE_COUPLING_LEVEL0, 2);

  err_code = ia_enhaacplus_enc_write_ic_stream(
      0, pstr_qc_out_ch->win_shape, pstr_qc_out_ch->grouping_mask, ptr_sfb_offset,
      pstr_qc_out_ch->scalefactor, pstr_qc_out_ch->max_val_in_sfb, pstr_qc_out_ch->global_gain,
      pstr_qc_out_ch->quant_spec, &(pstr_qc_out_ch->section_data), pstr_bit_stream_handle, aot,
      pstr_tns_info, pstr_aac_tables);
  if (err_code != IA_NO_ERROR) {
    return err_code;
  }

  ia_enhaacplus_enc_code_scale_factor_delta(-1, pstr_bit_stream_handle,
                                            pstr_aac_tables->pstr_huff_tab);

  return IA_NO_ERROR;
}

IA_ERRORCODE ia_enhaacplus_enc_write_bitstream(
    ixheaace_bit_buf_handle pstr_bit_stream_handle, ixheaace_element_info pstr_element_info,
    ixheaace_qc_out *pstr_qc_out, ixheaace_psy_out *pstr_psy_out, WORD32 *glob_used_bits,
    const UWORD8 *ptr_anc_bytes, ixheaace_aac_tables *pstr_aac_tables, FLAG flag_last_element,
    WORD32 *write_program_config_element, WORD32 i_num_coup_channels, WORD32 i_channels_mask,
    WORD32 i_samp_freq, WORD32 ele_idx, WORD32 aot, WORD32 *total_fill_bits) {
  IA_ERRORCODE err_code;
  WORD32 bit_markup, element_used_bits, frame_bits;

  bit_markup = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);

  *glob_used_bits = 0;

  {
    WORD32 *ptr_sfb_offset[2];
    ixheaace_temporal_noise_shaping_params tns_info[2];

    element_used_bits = 0;

    if ((*write_program_config_element == 1) && (ele_idx == 0)) {
      WORD32 samp_rate = i_samp_freq, ch_mask = i_channels_mask, n_cc_ch = i_num_coup_channels;

      /*Write Program Config Element*/
      ixheaace_write_bits(pstr_bit_stream_handle, ID_PCE, 3);
      ia_enhaacplus_enc_write_pce(samp_rate, ch_mask, n_cc_ch, pstr_bit_stream_handle);
      *write_program_config_element = 0;
    }

    switch (pstr_element_info.el_type) {
      case ID_SCE: /* single channel */

        ptr_sfb_offset[0] =
            pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->sfb_offsets;
        tns_info[0] = pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->tns_info;

        err_code = ia_enhaacplus_enc_write_single_chan_elem(
            pstr_element_info.instance_tag, ptr_sfb_offset[0],
            pstr_qc_out->qc_channel[pstr_element_info.channel_index[0]], pstr_bit_stream_handle,
            aot, tns_info[0], pstr_aac_tables);

        if (err_code != IA_NO_ERROR) {
          return err_code;
        }
        break;

      case ID_CCE: /* single channel independent coupling element*/

        ptr_sfb_offset[0] =
            pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->sfb_offsets;
        tns_info[0] = pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->tns_info;

        err_code = ia_enhaacplus_enc_write_single_channel_ind_coupling_element(
            ptr_sfb_offset[0], pstr_qc_out->qc_channel[pstr_element_info.channel_index[0]],
            pstr_bit_stream_handle, aot, tns_info[0], pstr_aac_tables);

        if (err_code != IA_NO_ERROR) {
          return err_code;
        }
        break;

      case ID_LFE: /* single channel */

        ptr_sfb_offset[0] =
            pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->sfb_offsets;
        tns_info[0] = pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->tns_info;

        err_code = ia_enhaacplus_enc_write_single_channel_element_LFE(
            pstr_element_info.instance_tag, ptr_sfb_offset[0],
            pstr_qc_out->qc_channel[pstr_element_info.channel_index[0]], pstr_bit_stream_handle,
            aot, tns_info[0], pstr_aac_tables);

        if (err_code != IA_NO_ERROR) {
          return err_code;
        }
        break;

      case ID_CPE: /* channel pair */
      {
        WORD32 ms_digest = pstr_psy_out->psy_out_element.tools_info.ms_digest;
        WORD32 *ms_flags = pstr_psy_out->psy_out_element.tools_info.ms_mask;

        ptr_sfb_offset[0] =
            pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->sfb_offsets;
        ptr_sfb_offset[1] =
            pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[1]]->sfb_offsets;

        tns_info[0] = pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[0]]->tns_info;
        tns_info[1] = pstr_psy_out->psy_out_ch[pstr_element_info.channel_index[1]]->tns_info;

        err_code = ia_enhaacplus_enc_write_channel_pair_element(
            pstr_element_info.instance_tag, ms_digest, ms_flags, ptr_sfb_offset,
            pstr_qc_out->qc_channel[pstr_element_info.channel_index[0]], pstr_bit_stream_handle,
            aot, tns_info, pstr_aac_tables);
        if (err_code != IA_NO_ERROR) {
          return err_code;
        }
      } break;

      default:
        return IA_EXHEAACE_INIT_FATAL_INVALID_ELEMENT_TYPE;

    } /* switch */

    element_used_bits -= bit_markup;

    bit_markup = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);

    frame_bits = element_used_bits + bit_markup;
  }

  if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
    ia_enhaacplus_enc_write_fill_element_LC(ptr_anc_bytes, pstr_qc_out->tot_anc_bits_used,
                                            pstr_bit_stream_handle);
  }

  if (flag_last_element) {
    if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
      ia_enhaacplus_enc_write_fill_element_LC(NULL, *total_fill_bits, pstr_bit_stream_handle);

      *total_fill_bits = 0;

      ixheaace_write_bits(pstr_bit_stream_handle, ID_END, 3);
    }

    if (aot == AOT_AAC_LD || aot == AOT_AAC_ELD) {
      {
        WORD32 i, cnt = 0;
        ia_enhaacplus_enc_write_fill_element_LD(ptr_anc_bytes, pstr_qc_out->tot_anc_bits_used,
                                                pstr_bit_stream_handle);

        *total_fill_bits += pstr_qc_out->total_fill_bits;
        *total_fill_bits += pstr_qc_out->align_bits;
        cnt = *total_fill_bits >> 3;
        for (i = 0; i < cnt; i++) {
          ixheaace_write_bits(pstr_bit_stream_handle, 0, 8);
        }
        cnt = *total_fill_bits - (cnt << 3);
        ixheaace_write_bits(pstr_bit_stream_handle, 0, (UWORD8)cnt);
        *total_fill_bits = 0;
      }
    }
    /* byte alignement */

    ixheaace_write_bits(pstr_bit_stream_handle, 0,
                        (UWORD8)((8 - (pstr_bit_stream_handle->cnt_bits % 8)) % 8));
  }

  *glob_used_bits -= bit_markup;

  bit_markup = ia_enhaacplus_enc_get_bits_available(pstr_bit_stream_handle);

  *glob_used_bits += bit_markup;

  frame_bits += *glob_used_bits;

  if (frame_bits != pstr_qc_out->tot_static_bits_used + pstr_qc_out->tot_dyn_bits_used +
                        pstr_qc_out->tot_anc_bits_used + +pstr_qc_out->total_fill_bits +
                        pstr_qc_out->align_bits) {
  }

  return IA_NO_ERROR;
}