xref: /aosp_15_r20/external/libxaac/encoder/iusace_enc_main.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 <string.h>
#include <stdio.h>
#include <math.h>

#include "ixheaac_error_standards.h"
#include "iusace_type_def.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_bitbuffer.h"
#include "ixheaace_bitbuffer.h"
#include "ixheaace_mps_common_define.h"

/* DRC */
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_tables.h"
#include "impd_drc_api.h"
#include "impd_drc_uni_drc_eq.h"
#include "impd_drc_uni_drc_filter_bank.h"
#include "impd_drc_gain_enc.h"
#include "impd_drc_struct_def.h"

#include "iusace_cnst.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_psy_utils.h"
#include "iusace_fd_qc_util.h"
#include "ixheaace_memory_standards.h"
#include "iusace_tns_usac.h"
#include "iusace_config.h"
#include "iusace_arith_enc.h"
#include "iusace_fd_quant.h"
#include "iusace_ms.h"
#include "iusace_block_switch_const.h"
#include "iusace_block_switch_struct_def.h"
#include "iusace_signal_classifier.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"
#include "ixheaace_asc_write.h"
#include "iusace_main.h"
#include "iusace_write_bitstream.h"
#include "iusace_windowing.h"
#include "iusace_fd_enc.h"
#include "iusace_fd_qc_adjthr.h"
#include "iusace_config.h"
#include "iusace_tcx_mdct.h"
#include "iusace_func_prototypes.h"
#include "iusace_block_switch.h"
#include "iusace_rom.h"
#include "ixheaace_error_codes.h"

#include "ixheaace_sbr_header.h"
#include "ixheaace_sbr_def.h"
#include "ixheaace_resampler.h"
#include "ixheaace_common_rom.h"

#include "ixheaace_sbr_header.h"
#include "ixheaace_sbr_def.h"
#include "ixheaace_resampler.h"
#include "ixheaace_sbr_rom.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_sbr_hbe.h"
#include "ixheaace_sbr_qmf_enc.h"
#include "ixheaace_sbr_tran_det.h"
#include "ixheaace_sbr_frame_info_gen.h"
#include "ixheaace_sbr_env_est.h"
#include "ixheaace_sbr_code_envelope.h"
#include "ixheaace_sbr_rom.h"
#include "ixheaace_sbr_main.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_sbr_missing_harmonics_det.h"
#include "ixheaace_sbr_inv_filtering_estimation.h"
#include "ixheaace_sbr_noise_floor_est.h"
#include "ixheaace_sbr_ton_corr.h"
#include "iusace_esbr_pvc.h"
#include "iusace_esbr_inter_tes.h"
#include "ixheaace_sbr.h"
#include "ixheaace_sbr_cmondata.h"
#include "ixheaace_sbr_crc.h"
#include "ixheaace_sbr_enc_struct.h"

#include "iusace_esbr_pvc.h"
#include "iusace_esbr_inter_tes.h"

static WORD32 iusace_get_num_elements(WORD32 num_channels) {
  WORD32 num_of_elements = 0;

  switch (num_channels) {
    case 1:
    case 2:
      num_of_elements = 1;
      break;
    default:
      num_of_elements = num_channels;
      break;
  }

  return num_of_elements;
}

static UWORD32 iusace_get_element_type(WORD32 elem_idx, WORD32 num_channels) {
  UWORD32 elem_type = (UWORD32)USAC_ELEMENT_TYPE_INVALID;
  (VOID) elem_idx;

  switch (num_channels) {
    case 1:
      elem_type = USAC_ELEMENT_TYPE_SCE;
      break;
    case 2:
      elem_type = USAC_ELEMENT_TYPE_CPE;
      break;
    default:
      elem_type = USAC_ELEMENT_TYPE_SCE;
      break;
  }

  return elem_type;
}

static VOID iusace_bw_init(ia_usac_encoder_config_struct *ptr_usac_config,
                           ixheaace_audio_specific_config_struct *pstr_asc, WORD32 ele_idx) {
  ptr_usac_config->bw_limit[ele_idx] = 20000;
  (VOID) pstr_asc;
  ptr_usac_config->bw_limit[ele_idx] =
      MIN(ptr_usac_config->bw_limit[ele_idx], ptr_usac_config->core_sample_rate / 2);

  return;
}

VOID iusace_scratch_mem_init(ia_usac_data_struct *usac_data, WORD32 total_ch, WORD32 sr) {
  iusace_scratch_mem *pstr_scratch = &usac_data->str_scratch;
  UWORD8 *temp_ptr = pstr_scratch->ptr_scratch_buf;

  pstr_scratch->ptr_stack_mem = (FLOAT32 *)(temp_ptr);
  temp_ptr += USACE_SCR_STACK;

  pstr_scratch->p_fd_mdct_windowed_long_buf = (FLOAT64 *)(temp_ptr);
  temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT64);

  pstr_scratch->p_fd_mdct_windowed_short_buf = (FLOAT64 *)(temp_ptr);
  // Size needed for above pointer is (2 * FRAME_LEN_LONG) * sizeof(FLOAT64)

  temp_ptr = (UWORD8 *)pstr_scratch->p_fd_mdct_windowed_short_buf;

  pstr_scratch->p_tns_filter = (FLOAT64 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT64);

  pstr_scratch->ptr_tns_scratch = (FLOAT64 *)(temp_ptr);
  temp_ptr +=
      (MAX_SHIFT_LEN_LONG + (TNS_MAX_ORDER + 1) * 2) * sizeof(pstr_scratch->ptr_tns_scratch[0]);

  pstr_scratch->p_left_fac_time_data = (FLOAT64 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT64);

  pstr_scratch->p_fac_win = (FLOAT64 *)(temp_ptr);
  // Size needed for above pointer is (2 * FAC_LENGTH) * sizeof(FLOAT64)

  temp_ptr = (UWORD8 *)pstr_scratch->p_left_fac_time_data;

  pstr_scratch->p_sort_grouping_scratch = (FLOAT64 *)(temp_ptr);
  // Size needed for above pointer is (LN2) * sizeof(FLOAT64)

  temp_ptr = (UWORD8 *)pstr_scratch->p_sort_grouping_scratch;

  pstr_scratch->p_noise_filling_highest_tone = (FLOAT64 *)(temp_ptr);
  temp_ptr += (LN2) * sizeof(FLOAT64);

  pstr_scratch->p_quant_spectrum_spec_scratch = (FLOAT64 *)(temp_ptr);
  temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT64);

  pstr_scratch->p_cmpx_mdct_temp_buf = (FLOAT64 *)(temp_ptr);
  // Size needed for above pointer is (LN2) * sizeof(FLOAT64)

  temp_ptr = (UWORD8 *)pstr_scratch->p_noise_filling_highest_tone;

  for (WORD32 i = 0; i < total_ch; i++) {
    pstr_scratch->p_reconstructed_time_signal[i] = (FLOAT64 *)(temp_ptr);
    temp_ptr += (4 * FRAME_LEN_LONG) * sizeof(FLOAT64);
  }
  pstr_scratch->ptr_next_win_scratch = (WORD32 *)(temp_ptr);
  temp_ptr += (2 * MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_next_win_scratch[0]);

  pstr_scratch->p_fft_p2_y = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_fft_p3_data_3 = (FLOAT32 *)(temp_ptr);
  temp_ptr += (800) * sizeof(FLOAT32);

  pstr_scratch->p_fft_p3_y = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_time_signal = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_complex_fft = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_tonal_flag = (WORD32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG / 2) * sizeof(WORD32);

  pstr_scratch->p_pow_spec = (FLOAT32 *)(temp_ptr);
  // Size needed for above pointer is (FRAME_LEN_LONG / 2) * sizeof(FLOAT32)
  temp_ptr = (UWORD8 *)pstr_scratch->p_time_signal;

  pstr_scratch->p_temp_mdct = (FLOAT32 *)(temp_ptr);
  temp_ptr += (1024) * sizeof(FLOAT32);

  pstr_scratch->p_buf_synthesis_tool = (FLOAT32 *)(temp_ptr);
  temp_ptr += (LEN_FRAME_16K + ORDER_LP_FILT_16K) * sizeof(FLOAT32);

  pstr_scratch->p_mdct_spec_float = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_sq_gain_en = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG / 4) * sizeof(FLOAT32);

  pstr_scratch->p_fft_mdct_buf = (FLOAT32 *)(temp_ptr);
  temp_ptr += (4 * FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_arith_map_prev_scratch = (WORD32 *)(temp_ptr);
  temp_ptr += (516) * sizeof(WORD32);

  pstr_scratch->p_arith_map_pres_scratch = (WORD32 *)(temp_ptr);
  temp_ptr += (516) * sizeof(WORD32);

  pstr_scratch->p_ol_pitch_buf_tmp = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_ol_pitch_speech_buf = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG + LAG_MAX) * sizeof(FLOAT32);

  pstr_scratch->p_ol_pitch_w_table = (FLOAT32 *)(temp_ptr);
  temp_ptr += (LEN_CORR_R) * sizeof(FLOAT32);

  pstr_scratch->p_ol_pitch_R = (FLOAT32 *)(temp_ptr);
  temp_ptr += (LEN_CORR_R) * sizeof(FLOAT32);

  WORD32 R0_size = (54 + 6 * ((WORD32)(34.f * ((FLOAT32)sr / 2.f) / 12800.f + 0.5f) * 2)) / 2;
  pstr_scratch->p_ol_pitch_R0 = (FLOAT32 *)(temp_ptr);
  temp_ptr += (R0_size) * sizeof(FLOAT32);

  pstr_scratch->p_lpd_frm_enc_scratch = (FLOAT32 *)(temp_ptr);
  temp_ptr += (LEN_FRAME + 1) * sizeof(FLOAT32);

  pstr_scratch->p_wsig_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
  temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_wsyn_tcx_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
  temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_synth_tcx_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
  temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_wsyn_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
  temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_synth_buf = (FLOAT32 *)(temp_ptr + 128 * sizeof(FLOAT32));
  temp_ptr += (128 + FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_temp_wsyn_buf = (FLOAT32 *)temp_ptr;
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_lp_filter_coeff = (FLOAT32 *)(temp_ptr);
  temp_ptr += ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32);

  pstr_scratch->p_lp_filter_coeff_q = (FLOAT32 *)(temp_ptr);
  temp_ptr += ((NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) * sizeof(FLOAT32);

  pstr_scratch->p_wsp_prev_buf = (FLOAT32 *)(temp_ptr);
  temp_ptr += ((MAX_PITCH1 / OPL_DECIM) + LEN_FRAME) * sizeof(FLOAT32);

  pstr_scratch->ptr_lpd_scratch = (UWORD8 *)temp_ptr;
  temp_ptr += ((2 * (NUM_SUBFR_SUPERFRAME + 1) * (ORDER + 1)) + (4 * (NUM_FRAMES + 1) * ORDER) +
               (((NUM_FRAMES >> 1) + 1) * ORDER) * 4) *
                  sizeof(FLOAT32) +
              100 * sizeof(WORD32) + 6 * sizeof(ia_usac_lpd_scratch);

  pstr_scratch->p_prm_tcx = (WORD32 *)(temp_ptr);
  temp_ptr += (NUM_TCX80_PRM) * sizeof(WORD32);

  pstr_scratch->p_buf_speech = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * LEN_FRAME + ORDER) * sizeof(FLOAT32);

  pstr_scratch->p_buf_res = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * LEN_FRAME) * sizeof(FLOAT32);

  pstr_scratch->p_buf_signal = (FLOAT32 *)(temp_ptr);
  temp_ptr += (ORDER + LEN_FRAME) * sizeof(FLOAT32);

  pstr_scratch->p_xn1_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_xn_buf_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (128 + FRAME_LEN_LONG + 128) * sizeof(FLOAT32);

  pstr_scratch->p_x_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_x_tmp_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_en_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_alfd_gains_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG / (4 * 8)) * sizeof(FLOAT32);

  pstr_scratch->p_sq_enc_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_sq_quant_tcx = (WORD32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD32);

  pstr_scratch->p_gain1_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_gain2_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_facelp_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_xn2_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_fac_window_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_x1_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_x2_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_y_tcx = (WORD32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(WORD32);

  pstr_scratch->p_in_out_tcx = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG * 2 * 2) * sizeof(FLOAT32);

  pstr_scratch->p_tcx_input = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->ptr_tcx_scratch = (FLOAT32 *)(temp_ptr);
  temp_ptr += 3 * (FRAME_LEN_LONG) * sizeof(pstr_scratch->ptr_tcx_scratch[0]);

  pstr_scratch->p_tcx_output = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_buf_aut_corr = (FLOAT32 *)(temp_ptr);
  // Size needed for above pointer is (LEN_WIN_PLUS) * sizeof(FLOAT32)
  temp_ptr = (UWORD8 *)pstr_scratch->p_buf_aut_corr;

  pstr_scratch->p_xn2 = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH + ORDER) * sizeof(FLOAT32);

  pstr_scratch->p_fac_dec = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_right_fac_spec = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_x2 = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_param = (WORD32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH + 1) * sizeof(WORD32);

  pstr_scratch->p_x = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_xn_2 = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT32);

  pstr_scratch->p_fac_window = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_fir_sig_buf = (FLOAT32 *)(temp_ptr);
  // Size needed for above pointer is (3 + LEN_FRAME) * sizeof(FLOAT32)
  temp_ptr = (UWORD8 *)pstr_scratch->p_fir_sig_buf;

  pstr_scratch->p_acelp_ir_buf = (FLOAT32 *)(temp_ptr);

  temp_ptr += (4 * LEN_SUBFR) * sizeof(FLOAT32);

  pstr_scratch->ptr_acelp_scratch = (FLOAT32 *)(temp_ptr);
  temp_ptr += ((11 * LEN_SUBFR) + (ORDER + LEN_SUBFR + 8) + 1024) *
              sizeof(pstr_scratch->ptr_acelp_scratch[0]);

  pstr_scratch->p_acelp_exc_buf = (FLOAT32 *)(temp_ptr);
  // Size needed for above pointer is ((3 * LEN_FRAME) + 1 + 41) * sizeof(FLOAT32)

  temp_ptr = (UWORD8 *)pstr_scratch->p_lpd_frm_enc_scratch;

  pstr_scratch->p_fac_bits_word = (WORD16 *)(temp_ptr);
  temp_ptr += (5000) * sizeof(WORD16);

  pstr_scratch->p_left_fac_timedata_flt = (FLOAT32 *)(temp_ptr);
  temp_ptr += (2 * FAC_LENGTH + ORDER) * sizeof(FLOAT32);

  pstr_scratch->p_left_fac_spec = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH) * sizeof(FLOAT32);

  pstr_scratch->p_fac_prm = (WORD32 *)(temp_ptr);
  temp_ptr += (FAC_LENGTH + 1) * sizeof(WORD32);

  pstr_scratch->p_acelp_folded_scratch = (FLOAT32 *)(temp_ptr);
  // Size needed for above pointer is (FAC_LENGTH) * sizeof(FLOAT32)

  temp_ptr = (UWORD8 *)pstr_scratch->p_fac_bits_word;

  pstr_scratch->p_exp_spec = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_adjthr_ptr_exp_spec = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_adjthr_mdct_spec_float = (FLOAT32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(FLOAT32);

  pstr_scratch->p_adjthr_quant_spec_temp = (WORD16 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD16);

  pstr_scratch->p_degroup_scratch = (WORD32 *)(temp_ptr);
  temp_ptr += (FRAME_LEN_LONG) * sizeof(WORD32);

  /*Newly added*/
  pstr_scratch->ptr_drc_scratch_buf = (UWORD8 *)(temp_ptr);

  pstr_scratch->ptr_num_fac_bits = (WORD32 *)temp_ptr;
  temp_ptr += MAX_TIME_CHANNELS * sizeof(pstr_scratch->ptr_num_fac_bits[0]);
  pstr_scratch->ptr_tns_data_present = (WORD32 *)temp_ptr;
  temp_ptr += MAX_TIME_CHANNELS * sizeof(pstr_scratch->ptr_tns_data_present[0]);

  pstr_scratch->ptr_tmp_lp_res = (FLOAT32 *)temp_ptr;
  temp_ptr += FAC_LENGTH * sizeof(pstr_scratch->ptr_tmp_lp_res[0]);

  for (WORD32 i = 0; i < total_ch; i++) {
    pstr_scratch->ptr_sfb_form_fac[i] = (FLOAT32 *)temp_ptr;
    temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
  }
  for (WORD32 i = 0; i < total_ch; i++) {
    pstr_scratch->ptr_sfb_num_relevant_lines[i] = (FLOAT32 *)temp_ptr;
    temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
  }
  for (WORD32 i = 0; i < total_ch; i++) {
    pstr_scratch->ptr_sfb_ld_energy[i] = (FLOAT32 *)temp_ptr;
    temp_ptr += (MAX_NUM_GROUPED_SFB) * sizeof(FLOAT32);
  }
  pstr_scratch->ptr_num_scfs = (WORD32 *)temp_ptr;
  temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_num_scfs[0]);

  pstr_scratch->ptr_max_ch_dyn_bits = (WORD32 *)temp_ptr;
  temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_max_ch_dyn_bits[0]);
  pstr_scratch->ptr_ch_bit_dist = (FLOAT32 *)temp_ptr;
  temp_ptr += (MAX_TIME_CHANNELS) * sizeof(pstr_scratch->ptr_ch_bit_dist[0]);
  pstr_scratch->ptr_fd_scratch = (UWORD8 *)temp_ptr;
  // Size needed for above pointer is (IXHEAACE_MAX_CH_IN_BS_ELE * MAX_NUM_GROUPED_SFB * 3) *
  // sizeof(WORD32)

  return;
}

WORD32 iusace_limitbitrate(WORD32 core_sample_rate, WORD32 frame_len, WORD32 num_ch,
                           WORD32 bit_rate) {
  WORD32 transport_bits, prev_bit_rate, shift = 0, iter = 0;

  while ((frame_len & ~((1 << (shift + 1)) - 1)) == frame_len &&
         (core_sample_rate & ~((1 << (shift + 1)) - 1)) == core_sample_rate) {
    shift++;
  }

  do {
    prev_bit_rate = bit_rate;
    /* Assume some worst case */
    transport_bits = 208;

    bit_rate =
        MAX(bit_rate, ((((40 * num_ch) + transport_bits) * (core_sample_rate)) / frame_len));
    bit_rate =
        MIN(bit_rate, ((num_ch * 6144) * (core_sample_rate >> shift)) / (frame_len >> shift));

  } while (prev_bit_rate != bit_rate && iter++ < 3);

  return bit_rate;
}

WORD32 iusace_map_sample_rate(WORD32 sample_rate)
{
  WORD32 mapped_sample_rate = sample_rate;

  if ((mapped_sample_rate >= 0) && (mapped_sample_rate < 9391))
  {
    mapped_sample_rate = 8000;
  }
  else if ((mapped_sample_rate >= 9391) && (mapped_sample_rate < 11502))
  {
    mapped_sample_rate = 11025;
  }
  else if ((mapped_sample_rate >= 11502) && (mapped_sample_rate < 13856))
  {
    mapped_sample_rate = 12000;
  }
  else if ((mapped_sample_rate >= 13856) && (mapped_sample_rate < 18783))
  {
    mapped_sample_rate = 16000;
  }
  else if ((mapped_sample_rate >= 18783) && (mapped_sample_rate < 23004))
  {
    mapped_sample_rate = 22050;
  }
  else if ((mapped_sample_rate >= 23004) && (mapped_sample_rate < 27713))
  {
    mapped_sample_rate = 24000;
  }
  else if ((mapped_sample_rate >= 27713) && (mapped_sample_rate < 37566))
  {
    mapped_sample_rate = 32000;
  }
  else if ((mapped_sample_rate >= 37566) && (mapped_sample_rate < 46009))
  {
    mapped_sample_rate = 44100;
  }
  else if ((mapped_sample_rate >= 46009) && (mapped_sample_rate < 55426))
  {
    mapped_sample_rate = 48000;
  }
  else if ((mapped_sample_rate >= 55426) && (mapped_sample_rate < 75132))
  {
    mapped_sample_rate = 64000;
  }
  else if ((mapped_sample_rate >= 75132) && (mapped_sample_rate < 92017))
  {
    mapped_sample_rate = 88200;
  }
  else if (mapped_sample_rate >= 92017)
  {
    mapped_sample_rate = 96000;
  }
  else
  {
    mapped_sample_rate = 48000;
  }
  return mapped_sample_rate;
}

/**
 *  iusace_enc_init
 *
 *  \brief Enocder initialization
 *
 *  \param [in] ptr_usac_config  Pointer to encoder config structure
 *  \param [in] ptr_asc          Pointer to audio specific config strcuture
 *  \param [in] pstr_state       Poniter to encoder handle structure
 *
 *  \return IA_ERRORCODE         Error code
 */
IA_ERRORCODE iusace_enc_init(ia_usac_encoder_config_struct *ptr_usac_config,
                             ixheaace_audio_specific_config_struct *pstr_asc,
                             ia_usac_data_struct *pstr_state) {
  IA_ERRORCODE err_code = IA_NO_ERROR;
  WORD32 i, j, k, idx, i_ch;
  UWORD32 elem_idx = 0;
  ia_usac_data_struct *usac_data = (pstr_state);
  ixheaace_audio_specific_config_struct *p_audio_specific_config = pstr_asc;
  ia_usac_config_struct *pstr_asc_usac_config = &(p_audio_specific_config->str_usac_config);
  WORD32 nbuff = 2048;
  usac_data->usac_independency_flag_count = 0;
  usac_data->usac_independency_flag_interval = 25;
  usac_data->use_acelp_only = ptr_usac_config->use_acelp_only;
  for (j = 0; j < MAX_TIME_CHANNELS; j++) {
    memset(usac_data->overlap_buf[j], 0, nbuff * sizeof(FLOAT64 *));

    usac_data->str_ms_info[j].ms_mask = 0;
    for (i = 0; i < MAX_SHORT_WINDOWS; i++) {
      for (k = 0; k < MAX_SFB_LONG; k++) {
        usac_data->str_ms_info[j].ms_used[i][k] = 0;
      }
    }
  }

  iusace_scratch_mem_init(usac_data, ptr_usac_config->channels,
                          ptr_usac_config->core_sample_rate);

  for (i = 0; i < MAX_TIME_CHANNELS; i++) {
    if (ptr_usac_config->cmplx_pred_flag) {
      usac_data->str_ms_info[i].ms_mask = 3;
    }
    usac_data->ptr_dmx_re_save[i] = &usac_data->arr_dmx_save_float[i][0];
    usac_data->ptr_dmx_im[i] = &usac_data->arr_dmx_im[i][0];
  }

  pstr_asc_usac_config->num_elements = 0;
  pstr_asc_usac_config->usac_cfg_ext_present = 0;
  pstr_asc_usac_config->num_config_extensions = 0;

  if (ptr_usac_config->channels > 0) {
    if (ptr_usac_config->channels < 7) {
      p_audio_specific_config->channel_configuration = ptr_usac_config->channels;
    }
  }
  ia_usac_enc_element_config_struct *pstr_usac_elem_config =
      &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
  pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
  pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_AUDIOPREROLL;
  pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
  pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
  pstr_usac_elem_config->usac_ext_ele_cfg_len = 0;
  pstr_asc_usac_config->num_elements++;
  // DRC Config
  if (ptr_usac_config->use_drc_element) {
    ptr_usac_config->str_drc_cfg.str_uni_drc_config.str_channel_layout.base_ch_count =
        ptr_usac_config->channels;

    memset(&usac_data->str_drc_state, 0, sizeof(ia_drc_enc_state));

    err_code = impd_drc_enc_init(&usac_data->str_drc_state, pstr_state->str_scratch.drc_scratch,
                                 &ptr_usac_config->str_drc_cfg);
    if (err_code & IA_FATAL_ERROR) {
      return err_code;
    }
    if (err_code) {
      ptr_usac_config->use_drc_element = 0;
      err_code = IA_NO_ERROR;
    }

    if (ptr_usac_config->use_drc_element) {
      ia_usac_enc_element_config_struct *pstr_usac_elem_config =
          &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
      pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
      pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_UNI_DRC;
      pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
      pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
      pstr_usac_elem_config->drc_config_data = usac_data->str_drc_state.bit_buf_base_cfg;
      pstr_usac_elem_config->usac_ext_ele_cfg_len =
          (usac_data->str_drc_state.drc_config_data_size_bit + 7) >> 3;
      pstr_asc_usac_config->num_elements++;
    }
  } else {
    err_code =
        impd_loudness_info_init(&usac_data->str_drc_state, &ptr_usac_config->str_drc_cfg);
    if (err_code) {
      return err_code;
    }
  }

  pstr_asc_usac_config->usac_config_ext_type[pstr_asc_usac_config->num_config_extensions] =
      ID_CONFIG_EXT_STREAM_ID;
  pstr_asc_usac_config->usac_config_ext_len[pstr_asc_usac_config->num_config_extensions] =
      CONFIG_EXT_LEN_STREAM_ID;
  pstr_asc_usac_config->num_config_extensions++;
  pstr_asc_usac_config->stream_identifier = ptr_usac_config->stream_id;

  pstr_asc_usac_config->usac_config_ext_type[pstr_asc_usac_config->num_config_extensions] =
      ID_CONFIG_EXT_LOUDNESS_INFO;
  pstr_asc_usac_config->usac_config_ext_len[pstr_asc_usac_config->num_config_extensions] =
      (usac_data->str_drc_state.drc_config_ext_data_size_bit + 7) >> 3;
  pstr_asc_usac_config->usac_config_ext_buf[pstr_asc_usac_config->num_config_extensions] =
      usac_data->str_drc_state.bit_buf_base_cfg_ext;
  pstr_asc_usac_config->num_config_extensions++;

  if (pstr_asc_usac_config->num_config_extensions) {
    pstr_asc_usac_config->usac_cfg_ext_present = 1;
  }

  p_audio_specific_config->sampling_frequency = ptr_usac_config->native_sample_rate;
  p_audio_specific_config->num_audio_channels = ptr_usac_config->channels;
  elem_idx = pstr_asc_usac_config->num_elements;
  ptr_usac_config->num_ext_elements = elem_idx;
  pstr_asc_usac_config->num_ext_elements = elem_idx;
  i = elem_idx;

  if (ptr_usac_config->channels != 0) {
    ptr_usac_config->num_elements = iusace_get_num_elements(ptr_usac_config->channels);
    pstr_asc_usac_config->num_elements += ptr_usac_config->num_elements;

    for (; i < (WORD32)pstr_asc_usac_config->num_elements; i++) {
      pstr_asc_usac_config->usac_element_type[i] = iusace_get_element_type(
          (i - ptr_usac_config->num_ext_elements), ptr_usac_config->channels);
    }
  }

  WORD32 count = ptr_usac_config->num_elements;
  ptr_usac_config->num_elements = pstr_asc_usac_config->num_elements;
  iusace_qc_create(&usac_data->str_qc_main);

  if (count > 2) {
    WORD32 num_mono = 0, num_stereo = 0, num_lfe = 0;

    for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
      switch (
          pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
        case ID_USAC_SCE:
          num_mono++;
          break;
        case ID_USAC_CPE:
          num_stereo++;
          break;
        case ID_USAC_EXT:
          break;
        default:
          return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_ELEMENT_TYPE;
      }
    }

    WORD32 bitrate_per_stereo = (WORD32)((ptr_usac_config->basic_bitrate - (num_lfe)*8000) /
                                         (num_mono * 0.625 + num_stereo));
    WORD32 bitrate_per_mono = (WORD32)(0.625 * bitrate_per_stereo);

    for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
      switch (
          pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
        case ID_USAC_SCE:
          usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = bitrate_per_mono;
          break;
        case ID_USAC_CPE:
          usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = bitrate_per_stereo;
          break;
        case ID_USAC_EXT:
          break;
        default:
          return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_ELEMENT_TYPE;
      }

      usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = 1;
      if (ID_USAC_CPE ==
          pstr_asc_usac_config->usac_element_type[ch_idx + ptr_usac_config->num_ext_elements]) {
        usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = 2;
      }

      usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
          MIN(360000 * usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
              usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);
      usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
          MAX(8000 * usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
              usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);

      usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate =
          iusace_limitbitrate(ptr_usac_config->core_sample_rate, 512,
                              usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
                              usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate);

      usac_data->str_qc_main.str_qc_data[ch_idx].avg_bits =
          (usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate * ptr_usac_config->ccfl) /
          ptr_usac_config->core_sample_rate;
    }
  } else {
    for (WORD8 ch_idx = 0; ch_idx < count; ch_idx++) {
      usac_data->str_qc_main.str_qc_data[ch_idx].num_ch = (WORD8)ptr_usac_config->channels;
      usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate = ptr_usac_config->basic_bitrate;
      usac_data->str_qc_main.str_qc_data[ch_idx].avg_bits =
          (usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate * ptr_usac_config->ccfl) /
          ptr_usac_config->core_sample_rate;
    }
  }

  for (i_ch = 0;
       i_ch < (WORD32)(ptr_usac_config->num_elements - ptr_usac_config->num_ext_elements);
       i_ch++) {
    iusace_bw_init(ptr_usac_config, p_audio_specific_config, i_ch);

    usac_data->noise_filling[i_ch] = ptr_usac_config->flag_noiseFilling;
  }

  memset(&usac_data->str_psy_mod.str_psy_out_data, 0,
         sizeof(ia_psy_mod_out_data_struct) * MAX_TIME_CHANNELS);

  i_ch = 0;
  for (UWORD32 ch_idx = 0;
       ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
       ch_idx++) {
    iusace_psy_mod_init(
        &usac_data->str_psy_mod,
        ((LEN_SUPERFRAME_768 == ptr_usac_config->ccfl) && (0 == ptr_usac_config->sbr_enable)) ?
        (iusace_map_sample_rate((ptr_usac_config->core_sample_rate * 4) / 3)) :
        (ptr_usac_config->core_sample_rate),
        usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate, ptr_usac_config->bw_limit[ch_idx],
        usac_data->str_qc_main.str_qc_data[ch_idx].num_ch, i_ch, ch_idx, ptr_usac_config->ccfl);
    i_ch += usac_data->str_qc_main.str_qc_data[ch_idx].num_ch;
  }

  for (; elem_idx < pstr_asc_usac_config->num_elements; elem_idx++) {
    idx = elem_idx - pstr_asc_usac_config->num_ext_elements;
    pstr_asc_usac_config->str_usac_element_config[elem_idx].noise_filling =
        usac_data->noise_filling[idx];
    usac_data->channel_elem_type[idx] = pstr_asc_usac_config->usac_element_type[elem_idx];
  }

  if (ptr_usac_config->use_fill_element) {
    ia_usac_enc_element_config_struct *pstr_usac_elem_config =
        &(pstr_asc_usac_config->str_usac_element_config[pstr_asc_usac_config->num_elements]);
    pstr_asc_usac_config->usac_element_type[pstr_asc_usac_config->num_elements] = ID_USAC_EXT;
    pstr_usac_elem_config->usac_ext_ele_type = ID_EXT_ELE_FILL;
    pstr_usac_elem_config->usac_ext_ele_cfg_len = 0;
    pstr_usac_elem_config->usac_ext_ele_dflt_len_present = 0;
    pstr_usac_elem_config->usac_ext_ele_payload_present = 0;
    pstr_asc_usac_config->num_elements++;
    ptr_usac_config->num_ext_elements++;
    ptr_usac_config->num_elements++;
  }

  if (ptr_usac_config->codec_mode == USAC_SWITCHED) {
    iusace_init_classification(&usac_data->str_sig_class_data);
  }

  i_ch = 0;
  for (UWORD32 ch_idx = 0;
       ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
       ch_idx++) {
    for (idx = 0; idx < usac_data->str_qc_main.str_qc_data[ch_idx].num_ch; idx++, i_ch++) {
      iusace_init_block_switching(&usac_data->block_switch_ctrl[i_ch],
                                  usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate,
                                  usac_data->str_qc_main.str_qc_data[ch_idx].num_ch);
    }
  }

  pstr_asc_usac_config->str_usac_element_config[elem_idx].stereo_config_index = 0;

  for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
    ptr_usac_config->window_sequence[i_ch] = ONLY_LONG_SEQUENCE;
    ptr_usac_config->window_shape_prev[i_ch] = WIN_SEL_0;
  }

  for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
    memset(usac_data->td_in_buf[i_ch], 0,
           (FRAME_LEN_LONG + LEN_NEXT_HIGH_RATE) * sizeof(usac_data->td_in_buf[i_ch][0]));
  }

  usac_data->max_bitreservoir_bits = MAX_CHANNEL_BITS * ptr_usac_config->channels;
  usac_data->available_bitreservoir_bits = usac_data->max_bitreservoir_bits;
  usac_data->available_bitreservoir_bits -=
      (ptr_usac_config->bit_rate * ptr_usac_config->ccfl) / ptr_usac_config->core_sample_rate;

  if (usac_data->available_bitreservoir_bits < 0) {
    return IA_EXHEAACE_INIT_FATAL_USAC_BITRES_SIZE_TOO_SMALL;
  }
  i_ch = 0;
  for (UWORD32 ch_idx = 0;
       ch_idx < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements;
       ch_idx++) {
    for (idx = 0; idx < usac_data->str_qc_main.str_qc_data[ch_idx].num_ch; idx++, i_ch++) {
      usac_data->td_encoder[i_ch]->max_sfb_short =
          usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_count;
      if (ptr_usac_config->tns_select == 0) {
        usac_data->pstr_tns_info[i_ch] = NULL;
      } else {
        usac_data->pstr_tns_info[i_ch]->sfb_offset_table_short =
            usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_offset;
        usac_data->pstr_tns_info[i_ch]->sfb_offset_table_long =
            usac_data->str_psy_mod.str_psy_long_config[ch_idx].sfb_offset;
        usac_data->pstr_tns_info[i_ch]->max_sfb_short =
            usac_data->str_psy_mod.str_psy_short_config[ch_idx].sfb_count;
        usac_data->pstr_tns_info[i_ch]->max_sfb_long =
            usac_data->str_psy_mod.str_psy_long_config[ch_idx].sfb_count;

        err_code = iusace_tns_init(ptr_usac_config->core_sample_rate,
                            usac_data->str_qc_main.str_qc_data[ch_idx].ch_bitrate /
                                usac_data->str_qc_main.str_qc_data[ch_idx].num_ch,
                            usac_data->pstr_tns_info[i_ch],
                            usac_data->str_qc_main.str_qc_data[ch_idx].num_ch);
        if (err_code) {
          return err_code;
        }
      }
    }
  }

  for (i = 0; i < MAX_TIME_CHANNELS; i++) usac_data->str_quant_info[i].reset = 1;

  if (ptr_usac_config->codec_mode == USAC_SWITCHED ||
      ptr_usac_config->codec_mode == USAC_ONLY_TD) {
    for (i_ch = 0; i_ch < ptr_usac_config->channels; i_ch++) {
      if ((ptr_usac_config->core_sample_rate) < SR_MIN ||
          (ptr_usac_config->core_sample_rate) > SR_MAX) {
        return IA_EXHEAACE_CONFIG_FATAL_USAC_SAMP_FREQ;
      } else {
        usac_data->td_encoder[i_ch]->fscale = ptr_usac_config->core_sample_rate;

        iusace_init_td_data(usac_data->td_encoder[i_ch], ptr_usac_config->ccfl);
      }

      usac_data->td_bitrate[i_ch] = ptr_usac_config->bit_rate;
      usac_data->td_bitrate[i_ch] /= ptr_usac_config->channels;
      iusace_config_acelp_core_mode(usac_data->td_encoder[i_ch],
                                    ptr_usac_config->core_sample_rate,
                                    usac_data->td_bitrate[i_ch]);

      usac_data->acelp_core_mode[i_ch] = (usac_data->td_encoder[i_ch])->acelp_core_mode;
      if (ptr_usac_config->core_sample_rate == 8000) {
        usac_data->use_acelp_only = 1;
      }
    }
  } else {
    usac_data->acelp_core_mode[0] = 0;
  }

  for (UWORD32 ch = 0;
       ch < pstr_asc_usac_config->num_elements - ptr_usac_config->num_ext_elements; ch++) {
    iusace_qc_init(&usac_data->str_qc_main.str_qc_data[ch], MAX_CHANNEL_BITS,
                   ptr_usac_config->core_sample_rate, ptr_usac_config->bw_limit[ch],
                   usac_data->str_qc_main.str_qc_data[ch].num_ch, ptr_usac_config->ccfl);
  }

  return err_code;
}

static WORD32 iexheaax_append_bitstream(ixheaace_bit_buf_handle hdl_bitbuf_write,
                                        ixheaace_bit_buf_handle hdl_bitbuf_read,
                                        WORD32 num_bits) {
  WORD32 idx;
  UWORD32 value;

  if (num_bits > 16) {
    WORD32 cnt, rem;
    cnt = num_bits >> 4;
    rem = num_bits % 16;

    for (idx = 0; idx < cnt; idx++) {
      value = ixheaace_readbits(hdl_bitbuf_read, 16);
      ixheaace_write_bits(hdl_bitbuf_write, value, 16);
    }
    if (rem) {
      value = ixheaace_readbits(hdl_bitbuf_read, (UWORD8)rem);
      ixheaace_write_bits(hdl_bitbuf_write, value, (UWORD8)rem);
    }
  } else {
    value = ixheaace_readbits(hdl_bitbuf_read, (UWORD8)num_bits);
    ixheaace_write_bits(hdl_bitbuf_write, value, (UWORD8)num_bits);
  }

  return num_bits;
}

static IA_ERRORCODE iusace_enc_ext_elemts(UWORD32 usac_ext_ele_type,
                                          ia_usac_encoder_config_struct *pstr_usac_config,
                                          ia_usac_data_struct *pstr_usac_data,
                                          ixheaace_audio_specific_config_struct *pstr_asc,
                                          FLOAT32 **pptr_input, ia_bit_buf_struct *it_bit_buff,
                                          WORD32 *num_bits_written) {
  WORD8 idx = 0;
  LOOPIDX idx_2 = 0;
  WORD32 num_bits_payload = 0;
  WORD32 num_byts_payload = 0;
  ia_usac_config_struct *pstr_asc_usac_config = &(pstr_asc->str_usac_config);
  VOID *pstr_scratch = &pstr_usac_data->str_scratch;
  IA_ERRORCODE err_code = IA_NO_ERROR;

  for (idx = 0; idx < (WORD32)pstr_asc_usac_config->num_elements; idx++) {
    if (ID_USAC_EXT != pstr_asc_usac_config->usac_element_type[idx]) {
      continue;
    }

    ia_usac_enc_element_config_struct *pstr_usac_elem_config =
        &(pstr_asc_usac_config->str_usac_element_config[idx]);

    if (usac_ext_ele_type != pstr_usac_elem_config->usac_ext_ele_type) {
      continue;
    }

    switch (pstr_usac_elem_config->usac_ext_ele_type) {
      case ID_EXT_ELE_UNI_DRC: {
        if (pstr_usac_data->str_drc_state.is_first_drc_process_complete == 0) {
          iusace_reset_bit_buffer(&pstr_usac_data->str_drc_state.str_bit_buf_out);
          err_code = impd_drc_enc(&pstr_usac_data->str_drc_state, pptr_input, 0,
                                  &num_bits_payload, pstr_scratch);
          if (err_code) {
            return err_code;
          }
          pstr_usac_data->str_drc_state.is_first_drc_process_complete = 1;
          num_bits_payload = 0;
        }

        iusace_reset_bit_buffer(&pstr_usac_data->str_drc_state.str_bit_buf_out);
        err_code =
            impd_drc_enc(&pstr_usac_data->str_drc_state, pptr_input,
                         pstr_usac_config->drc_frame_size, &num_bits_payload, pstr_scratch);
        if (err_code) {
          return err_code;
        }
        num_byts_payload = (num_bits_payload + 7) >> 3;
      } break;
      default: {
      } break;
    }

    if (num_byts_payload <= 0) {
      *num_bits_written += iusace_write_bits_buf(it_bit_buff, 0, 1);  // usacExtElementPresent
    } else {
      *num_bits_written += iusace_write_bits_buf(it_bit_buff, 1, 1);  // usacExtElementPresent

      *num_bits_written +=
          iusace_write_bits_buf(it_bit_buff, 0, 1);  // usacExtElementUseDefaultLength

      if (num_byts_payload >= 255) {
        *num_bits_written +=
            iusace_write_bits_buf(it_bit_buff, 255, 8);  // usacExtElementPayloadLength

        UWORD16 value_add = (UWORD16)(num_byts_payload - 255 + 2);
        *num_bits_written += iusace_write_bits_buf(it_bit_buff, value_add, 16);
      } else {
        *num_bits_written += iusace_write_bits_buf(it_bit_buff, num_byts_payload,
                                                   8);  // usacExtElementPayloadLength
      }

      switch (pstr_usac_elem_config->usac_ext_ele_type) {
        case ID_EXT_ELE_UNI_DRC: {
          for (idx_2 = 0; idx_2 < num_byts_payload; idx_2++) {
            *num_bits_written += iusace_write_bits_buf(
                it_bit_buff, pstr_usac_data->str_drc_state.bit_buf_base_out[idx_2], 8);
          }
        } break;
        default: {
        } break;
      }
    }
  }

  return err_code;
}

IA_ERRORCODE ixheaace_usac_encode(FLOAT32 **ptr_input,
                                  ia_usac_encoder_config_struct *ptr_usac_config,
                                  ia_usac_data_struct *pstr_state,
                                  ixheaace_audio_specific_config_struct *pstr_asc,
                                  ia_bit_buf_struct *pstr_it_bit_buff,
                                  ixheaace_pstr_sbr_enc ptr_env_encoder, FLOAT32 **pp_drc_inp,
                                  WORD32 *is_quant_spec_zero, WORD32 *is_gain_limited) {
  IA_ERRORCODE err = IA_NO_ERROR;
  WORD32 i_ch, i, k;
  ia_usac_data_struct *ptr_usac_data = pstr_state;
  iusace_scratch_mem *pstr_scratch = &ptr_usac_data->str_scratch;
  WORD32 bits_written = 0;

  WORD32 *next_window_sequence = pstr_scratch->ptr_next_win_scratch;
  WORD32 *new_win_seq = pstr_scratch->ptr_next_win_scratch + MAX_TIME_CHANNELS;
  memset(next_window_sequence, 0, MAX_TIME_CHANNELS * sizeof(next_window_sequence));
  memset(new_win_seq, 0, MAX_TIME_CHANNELS * sizeof(new_win_seq));
  ia_sfb_params_struct *pstr_sfb_prms = &ptr_usac_config->str_sfb_prms;
  memset(pstr_sfb_prms, 0, sizeof(ia_sfb_params_struct));

  WORD32 *num_window_groups = pstr_sfb_prms->num_window_groups;
  WORD32 average_bits_total;
  WORD32 num_bits;
  WORD32 padding_bits;
  WORD32 *common_win = pstr_sfb_prms->common_win;
  WORD32 usac_independency_flg;
  WORD32 mod[NUM_FRAMES] = {0};
  WORD32 len_frame;
  WORD32 len_lpc0;
  WORD32 len_next_high_rate;
  WORD8 elem_idx, nr_core_coder_channels = 0, chn = 0;
  WORD32 ch_offset = 0;
  WORD32 elem_idx_max = ptr_usac_config->num_elements - ptr_usac_config->num_ext_elements;
  WORD32 td_buffer_offset = (TD_BUFFER_OFFSET * ptr_usac_config->ccfl) / FRAME_LEN_LONG;
  usac_independency_flg = ptr_usac_data->usac_independency_flag;

  len_frame = ptr_usac_config->ccfl;
  len_lpc0 = (LEN_LPC0 * len_frame) / FRAME_LEN_LONG;
  len_next_high_rate = (LEN_NEXT_HIGH_RATE * len_frame) / FRAME_LEN_LONG;

  average_bits_total =
      (ptr_usac_config->bit_rate * ptr_usac_config->ccfl) / ptr_usac_config->core_sample_rate;

  ptr_usac_data->min_bits_needed =
      (long)(ptr_usac_data->available_bitreservoir_bits + 2 * average_bits_total -
             ptr_usac_data->max_bitreservoir_bits);
  if (ptr_usac_data->min_bits_needed < 0) {
    ptr_usac_data->min_bits_needed = 0;
  }

  num_bits = 0;
  if (ptr_usac_config->preroll_flag) {
    if (ptr_usac_config->iframes_interval != ptr_usac_config->num_preroll_frames) {
      iusace_write_bits_buf(pstr_it_bit_buff, usac_independency_flg, 1);
      num_bits++;
    }
  } else {
    iusace_write_bits_buf(pstr_it_bit_buff, usac_independency_flg, 1);
    num_bits++;
  }
  for (elem_idx = 0; elem_idx < elem_idx_max; elem_idx++) {
    switch (ptr_usac_data->channel_elem_type[elem_idx]) {
      case USAC_ELEMENT_TYPE_SCE:
        nr_core_coder_channels = 1;
        break;
      case USAC_ELEMENT_TYPE_CPE:
        nr_core_coder_channels = 2;
        break;
    }

    if (ptr_usac_data->core_mode[0] == CORE_MODE_FD) {
      for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
        iusace_block_switching(&ptr_usac_data->block_switch_ctrl[i_ch], ptr_input[i_ch],
                               ptr_usac_config->ccfl);
      }
    }

    i_ch = ch_offset;
    if (nr_core_coder_channels == 2) {
      iusace_sync_block_switching(&ptr_usac_data->block_switch_ctrl[i_ch],
                                  &ptr_usac_data->block_switch_ctrl[i_ch + 1]);
    }

    for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
      switch (ptr_usac_config->codec_mode) {
        case USAC_SWITCHED:
          if (ptr_usac_data->str_sig_class_data.coding_mode == 2) {
            ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_FD;
          } else {
            ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_TD;
          }
          break;
        case USAC_ONLY_FD:
          ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_FD;
          break;
        case USAC_ONLY_TD:
          ptr_usac_data->core_mode_next[i_ch] = CORE_MODE_TD;
          break;
        default:
          return IA_EXHEAACE_INIT_FATAL_USAC_INVALID_CODEC_MODE;
      }
      if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD) {
        for (i = 0; i < ptr_usac_config->ccfl; i++) {
          ptr_usac_data->ptr_2frame_time_data[i_ch][i] = ptr_usac_data->ptr_time_data[i_ch][i];
          ptr_usac_data->ptr_2frame_time_data[i_ch][ptr_usac_config->ccfl + i] =
              ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
          ptr_usac_data->ptr_time_data[i_ch][i] =
              ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
          ptr_usac_data->ptr_look_ahead_time_data[i_ch][i] = (FLOAT64)ptr_input[i_ch][i];
        }
      } else {
        for (i = 0; i < ptr_usac_config->ccfl; i++) {
          ptr_usac_data->ptr_2frame_time_data[i_ch][i] = ptr_usac_data->ptr_time_data[i_ch][i];
          ptr_usac_data->ptr_2frame_time_data[i_ch][ptr_usac_config->ccfl + i] =
              ptr_usac_data->ptr_look_ahead_time_data[i_ch][i];
          ptr_usac_data->ptr_time_data[i_ch][i] = ptr_input[i_ch][i];
          ptr_usac_data->ptr_look_ahead_time_data[i_ch][i] = (FLOAT64)ptr_input[i_ch][i];
        }
      }

      for (i = 0; i < len_frame + len_next_high_rate; i++) {
        ptr_usac_data->td_in_buf[i_ch][i] =
            (FLOAT32)(ptr_usac_data->ptr_2frame_time_data[i_ch][i + td_buffer_offset]);
      }
      for (i = 0; i < len_frame + len_next_high_rate + len_lpc0; i++) {
        ptr_usac_data->td_in_prev_buf[i_ch][i] =
            (FLOAT32)(ptr_usac_data->ptr_2frame_time_data[i_ch][i + td_buffer_offset - len_lpc0]);
      }

      if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_FD) {
        ptr_usac_data->window_size_samples[i_ch] = ptr_usac_config->ccfl;
        pstr_sfb_prms->window_sequence[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].window_seq;
        ptr_usac_config->window_sequence[i_ch] = pstr_sfb_prms->window_sequence[i_ch];
        new_win_seq[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].next_win_seq;
      }

      err = iusace_sfb_params_init(((LEN_SUPERFRAME_768 == ptr_usac_config->ccfl) &&
                                  (0 == ptr_usac_config->sbr_enable)) ?
                                  (iusace_map_sample_rate((ptr_usac_config->core_sample_rate
                                   * 4) / 3)) :(ptr_usac_config->core_sample_rate),
                                   ptr_usac_config->ccfl, pstr_sfb_prms->sfb_width_table[i_ch],
                                   &pstr_sfb_prms->num_sfb[i_ch],
                                   pstr_sfb_prms->window_sequence[i_ch]);

      if (err) {
        return err;
      }

      pstr_sfb_prms->sfb_offset[i_ch][0] = 0;
      k = 0;
      for (i = 0; i < pstr_sfb_prms->num_sfb[i_ch]; i++) {
        pstr_sfb_prms->sfb_offset[i_ch][i] = k;
        k += pstr_sfb_prms->sfb_width_table[i_ch][i];
      }
      pstr_sfb_prms->sfb_offset[i_ch][i] = k;

      if (ptr_usac_data->core_mode[i_ch] != CORE_MODE_TD) {
        next_window_sequence[i_ch] = new_win_seq[i_ch];
        if (ptr_usac_data->core_mode_next[i_ch] == CORE_MODE_TD) {
          next_window_sequence[i_ch] = EIGHT_SHORT_SEQUENCE;
        }

        if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD &&
            ptr_usac_data->core_mode_next[i_ch] != CORE_MODE_TD) {
          next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
        }

        if (next_window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
          if (pstr_sfb_prms->window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
            pstr_sfb_prms->window_sequence[i_ch] = LONG_START_SEQUENCE;
          }
          if (pstr_sfb_prms->window_sequence[i_ch] == LONG_STOP_SEQUENCE) {
            pstr_sfb_prms->window_sequence[i_ch] = STOP_START_SEQUENCE;
          }
        }

        if (next_window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
          if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
            next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
          }
        }

        if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
          num_window_groups[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].tot_grps_cnt;
          for (i = 0; i < 8; i++) {
            pstr_sfb_prms->window_group_length[i_ch][i] =
                ptr_usac_data->block_switch_ctrl[i_ch].group_len[i];
          }
        } else {
          num_window_groups[i_ch] = 1;
          pstr_sfb_prms->window_group_length[i_ch][0] = 1;
        }

        pstr_sfb_prms->window_shape[i_ch] = ptr_usac_config->window_shape_prev[i_ch];

        err = iusace_fd_mdct(ptr_usac_data, ptr_usac_config, i_ch);

        if (err) {
          return err;
        }

        if (pstr_sfb_prms->window_sequence[i_ch] != EIGHT_SHORT_SEQUENCE) {
          iusace_psy_mod_lb(&ptr_usac_data->str_psy_mod, pstr_sfb_prms,
                            ptr_usac_data->spectral_line_vector[i_ch],
                            ptr_usac_data->pstr_tns_info, ptr_usac_config->tns_select, i_ch, chn,
                            ptr_usac_data->channel_elem_type[elem_idx],
                            pstr_scratch->p_tns_filter, elem_idx, pstr_scratch->ptr_tns_scratch,
                            ptr_usac_config->ccfl);
        } else {
          iusace_psy_mod_sb(&(ptr_usac_data->str_psy_mod), pstr_sfb_prms,
                            ptr_usac_data->spectral_line_vector[i_ch],
                            ptr_usac_data->pstr_tns_info, ptr_usac_config->tns_select, i_ch, chn,
                            ptr_usac_data->channel_elem_type[elem_idx],
                            pstr_scratch->p_tns_filter, elem_idx, pstr_scratch->ptr_tns_scratch,
                            ptr_usac_config->ccfl);
        }

        pstr_sfb_prms->max_sfb[i_ch] =
            ptr_usac_data->str_psy_mod.str_psy_out_data[i_ch].max_sfb_per_grp;
      }
    }
    for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
      if (nr_core_coder_channels == 2) {
        if ((pstr_sfb_prms->window_shape[i_ch] == pstr_sfb_prms->window_shape[i_ch + 1]) &&
            (pstr_sfb_prms->window_sequence[i_ch] == pstr_sfb_prms->window_sequence[i_ch + 1]) &&
            (ptr_usac_data->core_mode[i_ch] == ptr_usac_data->core_mode[i_ch + 1])) {
          common_win[i_ch] = common_win[i_ch + 1] = 1;
        } else {
          common_win[i_ch] = 0;
        }
        chn++;
      } else {
        common_win[i_ch] = 0;
      }
    }
    if (nr_core_coder_channels == 2) {
      if (i_ch == (ch_offset + 1)) {
        if (pstr_sfb_prms->window_sequence[i_ch] != EIGHT_SHORT_SEQUENCE) {
          iusace_calc_ms_band_energy(
              ptr_usac_data->spectral_line_vector[ch_offset],
              ptr_usac_data->spectral_line_vector[ch_offset + 1],
              ptr_usac_data->str_psy_mod.str_psy_long_config[elem_idx].sfb_offset,
              ptr_usac_data->str_psy_mod.str_psy_long_config[elem_idx].sfb_active,
              ptr_usac_data->str_psy_mod.str_psy_data[ch_offset].ptr_sfb_energy_long_ms,
              ptr_usac_data->str_psy_mod.str_psy_data[ch_offset + 1].ptr_sfb_energy_long_ms);
        } else {
          WORD32 frame_len_short = (ptr_usac_config->ccfl * FRAME_LEN_SHORT_128) / FRAME_LEN_LONG;
          for (WORD32 w = 0; w < MAX_SHORT_WINDOWS; w++) {
            WORD32 w_offset = w * frame_len_short;

            iusace_calc_ms_band_energy(
                ptr_usac_data->spectral_line_vector[ch_offset] + w_offset,
                ptr_usac_data->spectral_line_vector[ch_offset + 1] + w_offset,
                ptr_usac_data->str_psy_mod.str_psy_short_config[elem_idx].sfb_offset,
                ptr_usac_data->str_psy_mod.str_psy_short_config[elem_idx].sfb_active,
                ptr_usac_data->str_psy_mod.str_psy_data[ch_offset].ptr_sfb_energy_short_ms[w],
                ptr_usac_data->str_psy_mod.str_psy_data[ch_offset + 1]
                    .ptr_sfb_energy_short_ms[w]);
          }
        }
      }
    }
    if ((nr_core_coder_channels == 2)
            ? ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD) &&
               (ptr_usac_data->core_mode[ch_offset + 1] == CORE_MODE_FD))
            : ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD))) {
      iusace_grouping(pstr_sfb_prms, nr_core_coder_channels, ptr_usac_data, ptr_usac_config,
                      ch_offset, elem_idx);

      if (nr_core_coder_channels == 2) {
        err = iusace_stereo_proc(pstr_sfb_prms, usac_independency_flg, ptr_usac_data,
                                 ptr_usac_config, ch_offset);
        if (err != IA_NO_ERROR) {
          return err;
        }
      }
    }
    if (ptr_usac_config->preroll_flag) {
      if (ptr_usac_config->iframes_interval != ptr_usac_config->num_preroll_frames) {
        iusace_write_bits_buf(pstr_it_bit_buff, 0, 1);  // extension element present
        num_bits++;
      }
    }
    if (ptr_usac_config->use_drc_element) {
      WORD32 num_bits_ext_elem = 0;
      err = iusace_enc_ext_elemts(ID_EXT_ELE_UNI_DRC, ptr_usac_config, pstr_state, pstr_asc,
                                  pp_drc_inp, pstr_it_bit_buff, &num_bits_ext_elem);
      if (err & IA_FATAL_ERROR) {
        return err;
      }
      num_bits += num_bits_ext_elem;
      ptr_usac_data->num_drc_bits = num_bits_ext_elem;
#ifdef DRC_BITRATE_CONSIDERATION
      ptr_usac_data->drc_data_bit_cnt = num_bits_ext_elem;
#endif
    }

    for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
      iusace_write_bits_buf(pstr_it_bit_buff, ptr_usac_data->core_mode[i_ch], 1);
      num_bits++;
    }

    for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
      if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_FD) {
        ptr_usac_data->window_size_samples[i_ch] = ptr_usac_config->ccfl;
        pstr_sfb_prms->window_sequence[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].window_seq;
        ptr_usac_config->window_sequence[i_ch] = pstr_sfb_prms->window_sequence[i_ch];
        new_win_seq[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].next_win_seq;
      }

      if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD) {
        WORD32 error;

        error = iusace_lpd_frm_enc(ptr_usac_data, mod, usac_independency_flg, len_frame, i_ch,
                                   pstr_it_bit_buff);
        if (error) return error;

        num_bits = pstr_it_bit_buff->cnt_bits;

        if ((ptr_usac_data->core_mode_prev[i_ch] == CORE_MODE_FD) && (mod[0] == 0)) {
          for (i = 0; i < ptr_usac_data->num_td_fac_bits[i_ch]; i++) {
            iusace_write_bits_buf(pstr_it_bit_buff, ptr_usac_data->fac_out_stream[i_ch][i], 1);
            num_bits++;
          }
        }
      } else {
        next_window_sequence[i_ch] = new_win_seq[i_ch];
        if (ptr_usac_data->core_mode_next[i_ch] == CORE_MODE_TD) {
          next_window_sequence[i_ch] = EIGHT_SHORT_SEQUENCE;
        }

        if (ptr_usac_data->core_mode[i_ch] == CORE_MODE_TD &&
            ptr_usac_data->core_mode_next[i_ch] != CORE_MODE_TD) {
          next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
        }

        if (next_window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
          if (pstr_sfb_prms->window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
            pstr_sfb_prms->window_sequence[i_ch] = LONG_START_SEQUENCE;
          }
          if (pstr_sfb_prms->window_sequence[i_ch] == LONG_STOP_SEQUENCE) {
            pstr_sfb_prms->window_sequence[i_ch] = STOP_START_SEQUENCE;
          }
        }
        if (next_window_sequence[i_ch] == ONLY_LONG_SEQUENCE) {
          if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
            next_window_sequence[i_ch] = LONG_STOP_SEQUENCE;
          }
        }
        if (pstr_sfb_prms->window_sequence[i_ch] == EIGHT_SHORT_SEQUENCE) {
          num_window_groups[i_ch] = ptr_usac_data->block_switch_ctrl[i_ch].tot_grps_cnt;
          for (i = 0; i < 8; i++) {
            pstr_sfb_prms->window_group_length[i_ch][i] =
                ptr_usac_data->block_switch_ctrl[i_ch].group_len[i];
          }
        } else {
          num_window_groups[i_ch] = 1;
          pstr_sfb_prms->window_group_length[i_ch][0] = 1;
        }
        pstr_sfb_prms->window_shape[i_ch] = ptr_usac_config->window_shape_prev[i_ch];
      }
    }

    if ((nr_core_coder_channels == 2)
            ? ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD) &&
               (ptr_usac_data->core_mode[ch_offset + 1] == CORE_MODE_FD))
            : ((ptr_usac_data->core_mode[ch_offset] == CORE_MODE_FD))) {
      err = iusace_fd_encode(pstr_sfb_prms, usac_independency_flg, ptr_usac_data, ptr_usac_config,
                             pstr_it_bit_buff, nr_core_coder_channels, ch_offset, elem_idx,
                             &bits_written, is_quant_spec_zero, is_gain_limited);

      if (err) {
        return err;
      }

      num_bits += bits_written;
    }

    for (chn = 0, i_ch = ch_offset; chn < nr_core_coder_channels; chn++, i_ch++) {
      ptr_usac_config->window_shape_prev[i_ch] = pstr_sfb_prms->window_shape[i_ch];
      ptr_usac_config->window_sequence_prev[i_ch] = ptr_usac_config->window_sequence[i_ch];
      ptr_usac_config->window_sequence[i_ch] = next_window_sequence[i_ch];
      ptr_usac_data->core_mode_prev[i_ch] = ptr_usac_data->core_mode[i_ch];
      ptr_usac_data->core_mode[i_ch] = ptr_usac_data->core_mode_next[i_ch];
    }
    ch_offset += nr_core_coder_channels;
  }

  if (1 == ptr_usac_config->sbr_enable) {
    // Append SBR bits
    ixheaace_bit_buf_handle pstr_it_bit_buff_temp =
        &ptr_env_encoder->str_cmon_data.str_sbr_bit_buf;
    WORD32 check_num_bits = ia_enhaacplus_enc_get_bits_available(pstr_it_bit_buff_temp);

    num_bits += iexheaax_append_bitstream((ixheaace_bit_buf_handle)pstr_it_bit_buff,
                                          pstr_it_bit_buff_temp, check_num_bits);
  }

  if (ptr_usac_config->use_fill_element) {
    WORD32 full_elem_num_bits = 0;
    padding_bits = ptr_usac_data->min_bits_needed - num_bits;
    full_elem_num_bits = iusace_write_fill_ele(pstr_it_bit_buff, padding_bits);
    num_bits += full_elem_num_bits;
  }

  ptr_usac_data->available_bitreservoir_bits -= num_bits;

  if (num_bits % 8) {
    ptr_usac_data->available_bitreservoir_bits -= 8 - (num_bits % 8);
  }
  ptr_usac_data->available_bitreservoir_bits += average_bits_total;

  if (ptr_usac_data->available_bitreservoir_bits > ptr_usac_data->max_bitreservoir_bits) {
    ptr_usac_data->available_bitreservoir_bits = ptr_usac_data->max_bitreservoir_bits;
  }

  return err;
}