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

 *                                                                            *

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

#include "ixheaac_type_def.h"

#include "iusace_bitbuffer.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 "ixheaace_mps_common_define.h"

#include "iusace_cnst.h"

#include "iusace_tns_usac.h"

#include "iusace_psy_mod.h"

#include "iusace_tns_usac.h"

#include "iusace_config.h"

#include "iusace_arith_enc.h"

#include "ixheaace_adjust_threshold_data.h"

#include "iusace_block_switch_const.h"

#include "iusace_block_switch_struct_def.h"

#include "iusace_fd_qc_util.h"

#include "iusace_fd_quant.h"

#include "iusace_ms.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_rom.h"

WORD32 iusace_write_scf_data(ia_bit_buf_struct *it_bit_buf, WORD32 max_sfb, WORD32 num_sfb,

                             const WORD32 *ptr_scale_factors, WORD32 num_win_grps,

                             WORD32 global_gain, const WORD32 huff_tab[CODE_BOOK_ALPHA_LAV][2]) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 i, j, bit_count = 0;

  WORD32 diff, length, codeword;

  WORD32 index = 0;

  WORD32 previous_scale_factor = global_gain;

  for (j = 0; j < num_win_grps; j++) {

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

      if (!((i == 0) && (j == 0))) {

        diff = ptr_scale_factors[index] - previous_scale_factor;

        length = huff_tab[diff + 60][0];

        bit_count += length;

        previous_scale_factor = ptr_scale_factors[index];

        if (write_flag == 1) {

          codeword = huff_tab[diff + 60][1];

          iusace_write_bits_buf(it_bit_buf, codeword, (UWORD8)length);

        }

      }

      index++;

    }

    for (; i < num_sfb; i++) {

      index++;

    }

  }

  return (bit_count);

}

WORD32 iusace_write_ms_data(ia_bit_buf_struct *it_bit_buf, WORD32 ms_mask,

                            WORD32 ms_used[MAX_SHORT_WINDOWS][MAX_SFB_LONG], WORD32 num_win_grps,

                            WORD32 nr_of_sfb) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 bit_count = 0;

  WORD32 i, j;

  WORD32 ms_mask_write = ms_mask;

  if (write_flag) iusace_write_bits_buf(it_bit_buf, ms_mask_write, 2);

  bit_count += 2;

  if (ms_mask_write == 1) {

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

      for (j = 0; j < nr_of_sfb; j++) {

        if (write_flag) iusace_write_bits_buf(it_bit_buf, ms_used[i][j], 1);

        bit_count += 1;

      }

    }

  }

  return bit_count;

}

WORD32 iusace_write_tns_data(ia_bit_buf_struct *it_bit_buf, ia_tns_info *pstr_tns_info,

                             WORD32 window_sequence, WORD32 core_mode) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 bit_count = 0;

  WORD32 num_windows;

  WORD32 len_tns_nfilt;

  WORD32 len_tns_length;

  WORD32 len_tns_order;

  WORD32 filt;

  WORD32 res_bits;

  UWORD32 coeff;

  WORD32 w;

  if (window_sequence == EIGHT_SHORT_SEQUENCE) {

    num_windows = MAX_SHORT_WINDOWS;

    len_tns_nfilt = 1;

    len_tns_length = 4;

    len_tns_order = 3;

  } else {

    num_windows = 1;

    len_tns_nfilt = 2;

    len_tns_length = 6;

    len_tns_order = 4;

  }

  if (core_mode == 1) {

    num_windows = 1;

  }

  for (w = 0; w < num_windows; w++) {

    ia_tns_window_data *ptr_win_data = &pstr_tns_info->window_data[w];

    WORD32 n_filt = ptr_win_data->n_filt;

    if (write_flag) {

      iusace_write_bits_buf(it_bit_buf, n_filt, (UWORD8)len_tns_nfilt);

    }

    bit_count += len_tns_nfilt;

    if (n_filt) {

      res_bits = ptr_win_data->coef_res;

      if (write_flag) {

        iusace_write_bits_buf(it_bit_buf, res_bits - DEF_TNS_RES_OFFSET, 1);

      }

      bit_count += 1;

      for (filt = 0; filt < n_filt; filt++) {

        ia_tns_filter_data *ptr_tns_filt = &ptr_win_data->tns_filter[filt];

        WORD32 order = ptr_tns_filt->order;

        if (write_flag) {

          iusace_write_bits_buf(it_bit_buf, ptr_tns_filt->length, (UWORD8)len_tns_length);

          iusace_write_bits_buf(it_bit_buf, order, (UWORD8)len_tns_order);

        }

        bit_count += (len_tns_length + len_tns_order);

        if (order) {

          WORD32 i;

          if (write_flag) {

            iusace_write_bits_buf(it_bit_buf, ptr_tns_filt->direction, 1);

            iusace_write_bits_buf(it_bit_buf, ptr_tns_filt->coef_compress, 1);

          }

          bit_count += 2;

          for (i = 1; i <= order; i++) {

            if (write_flag) {

              coeff = (UWORD32)(ptr_tns_filt->index[i]) & ((1 << res_bits) - 1);

              iusace_write_bits_buf(it_bit_buf, coeff, (UWORD8)res_bits);

            }

            bit_count += res_bits;

          }

        }

      }

    }

  }

  return bit_count;

}

static WORD32 iusace_calc_grouping_bits(const WORD32 *ptr_win_grp_len, WORD32 num_win_grps) {

  WORD32 grouping_bits = 0;

  WORD32 tmp[8] = {0};

  WORD32 i, j;

  WORD32 index = 0;

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

    for (j = 0; j < ptr_win_grp_len[i]; j++) {

      tmp[index++] = i;

    }

  }

  for (i = 1; i < 8; i++) {

    grouping_bits = grouping_bits << 1;

    if (tmp[i] == tmp[i - 1]) {

      grouping_bits++;

    }

  }

  return (grouping_bits);

}

WORD32 iusace_write_ics_info(ia_bit_buf_struct *it_bit_buf, ia_sfb_params_struct *pstr_sfb_prms,

                             WORD32 ch) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 bit_count = 0;

  WORD32 win_seq = 0;

  WORD32 grouping_bits = 0;

  WORD32 max_sfb = pstr_sfb_prms->max_sfb[ch];

  WORD32 window_sequence = pstr_sfb_prms->window_sequence[ch];

  WORD32 window_shape = pstr_sfb_prms->window_shape[ch];

  WORD32 num_win_grps = pstr_sfb_prms->num_window_groups[ch];

  switch (window_sequence) {

    case EIGHT_SHORT_SEQUENCE:

      win_seq = 2;

      break;

    case ONLY_LONG_SEQUENCE:

      win_seq = 0;

      break;

    case LONG_START_SEQUENCE:

    case STOP_START_SEQUENCE:

      win_seq = 1;

      break;

    case LONG_STOP_SEQUENCE:

      win_seq = 3;

      break;

    default:

      win_seq = 3;

      break;

  }

  if (write_flag) iusace_write_bits_buf(it_bit_buf, win_seq, 2);

  bit_count += 2;

  if (write_flag) iusace_write_bits_buf(it_bit_buf, window_shape, 1);

  bit_count += 1;

  if (window_sequence == EIGHT_SHORT_SEQUENCE) {

    if (write_flag) iusace_write_bits_buf(it_bit_buf, max_sfb, 4);

    bit_count += 4;

    grouping_bits =

        iusace_calc_grouping_bits(pstr_sfb_prms->window_group_length[ch], num_win_grps);

    if (write_flag) iusace_write_bits_buf(it_bit_buf, grouping_bits, 7);

    bit_count += 7;

  } else {

    if (write_flag) iusace_write_bits_buf(it_bit_buf, max_sfb, 6);

    bit_count += 6;

  }

  return (bit_count);

}

WORD32 iusace_write_cplx_pred_data(ia_bit_buf_struct *it_bit_buf, WORD32 num_win_grps,

                                   WORD32 num_sfb, WORD32 complex_coef,

                                   WORD32 pred_coeffs_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

                                   WORD32 pred_coeffs_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

                                   const WORD32 huff_tab[CODE_BOOK_ALPHA_LAV][2],

                                   WORD32 const usac_independency_flg, WORD32 pred_dir,

                                   WORD32 cplx_pred_used[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

                                   WORD32 cplx_pred_all, WORD32 *ptr_prev_alpha_coeff_re,

                                   WORD32 *ptr_prev_alpha_coeff_im, WORD32 *delta_code_time) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 bit_count = 0;

  WORD32 i, j;

  WORD32 g;

  WORD32 sfb;

  const WORD32 sfb_per_pred_band = 2;

  WORD32 length_temp1_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      length_temp2_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      length_temp1_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      length_temp2_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG];

  WORD32 code_word_temp1_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      code_word_temp2_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      code_word_temp1_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG],

      code_word_temp2_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG];

  WORD32 length_tot1 = 0, length_tot2 = 0;

  if (write_flag) iusace_write_bits_buf(it_bit_buf, cplx_pred_all, 1);

  bit_count += 1;

  if (cplx_pred_all == 0) {

    for (g = 0; g < num_win_grps; g++) {

      for (sfb = 0; sfb < num_sfb; sfb += sfb_per_pred_band) {

        iusace_write_bits_buf(it_bit_buf, cplx_pred_used[g][sfb], 1);

        bit_count += 1;

      }

    }

  }

  if (write_flag) iusace_write_bits_buf(it_bit_buf, pred_dir, 1);

  bit_count += 1;

  if (write_flag) iusace_write_bits_buf(it_bit_buf, complex_coef, 1);

  bit_count += 1;

  if (complex_coef) {

    if (!usac_independency_flg) {

      if (write_flag) iusace_write_bits_buf(it_bit_buf, 1, 1); /* use_prev_frame */

      bit_count += 1;

    }

  }

  if (usac_independency_flg) {

    *delta_code_time = 0;

  }

  /* Switching mechanism for delta_code_time */

  WORD32 prev_pred_coeff_re_temp1 = 0, prev_pred_coeff_re_temp2 = 0;

  WORD32 diff_pred_coeff_re_temp1 = 0, diff_pred_coeff_re_temp2 = 0;

  WORD32 prev_pred_coeff_im_temp1 = 0, prev_pred_coeff_im_temp2 = 0;

  WORD32 diff_pred_coeff_im_temp1 = 0, diff_pred_coeff_im_temp2 = 0;

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

    /* delta_code_time = 0*/

    prev_pred_coeff_re_temp1 = 0;

    if (complex_coef == 1) {

      prev_pred_coeff_im_temp1 = 0;

    }

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

      if (!usac_independency_flg) {

        /* delta_code_time = 1*/

        if (i > 0) {

          prev_pred_coeff_re_temp2 = pred_coeffs_re[i - 1][j];

          if (complex_coef == 1) {

            prev_pred_coeff_im_temp2 = pred_coeffs_im[i - 1][j];

          }

        } else {

          prev_pred_coeff_re_temp2 = ptr_prev_alpha_coeff_re[j];

          if (complex_coef == 1) {

            prev_pred_coeff_im_temp2 = ptr_prev_alpha_coeff_im[j];

          }

        }

      }

      if (cplx_pred_used[i][j] == 1) {

        /*Differential Huffman coding of real prediction coefficients*/

        diff_pred_coeff_re_temp1 =

            pred_coeffs_re[i][j] - prev_pred_coeff_re_temp1; /* delta_code_time = 0 */

        prev_pred_coeff_re_temp1 = pred_coeffs_re[i][j];     /* delta_code_time = 0 */

        if (!usac_independency_flg) {

          diff_pred_coeff_re_temp2 =

              pred_coeffs_re[i][j] - prev_pred_coeff_re_temp2; /* delta_code_time = 1 */

        }

        /* delta_code_time = 0 */

        length_temp1_re[i][j] = huff_tab[diff_pred_coeff_re_temp1 + 60][0];

        code_word_temp1_re[i][j] = huff_tab[diff_pred_coeff_re_temp1 + 60][1];

        length_tot1 += length_temp1_re[i][j];

        if (!usac_independency_flg) {

          /*delta_code_time = 1 */

          length_temp2_re[i][j] = huff_tab[diff_pred_coeff_re_temp2 + 60][0];

          code_word_temp2_re[i][j] = huff_tab[diff_pred_coeff_re_temp2 + 60][1];

          length_tot2 += length_temp2_re[i][j];

        }

        if (complex_coef == 1) {

          /*Differential Huffman coding of imaginary prediction coefficients*/

          diff_pred_coeff_im_temp1 =

              pred_coeffs_im[i][j] - prev_pred_coeff_im_temp1; /* delta_code_time = 0 */

          prev_pred_coeff_im_temp1 = pred_coeffs_im[i][j];     /* delta_code_time = 0*/

          if (!usac_independency_flg) {

            diff_pred_coeff_im_temp2 =

                pred_coeffs_im[i][j] - prev_pred_coeff_im_temp2; /* delta_code_time = 1 */

          }

          /*delta_code_time = 0*/

          length_temp1_im[i][j] = huff_tab[diff_pred_coeff_im_temp1 + 60][0];

          code_word_temp1_im[i][j] = huff_tab[diff_pred_coeff_im_temp1 + 60][1];

          length_tot1 += length_temp1_im[i][j];

          if (!usac_independency_flg) {

            /*delta_code_time = 1*/

            length_temp2_im[i][j] = huff_tab[diff_pred_coeff_im_temp2 + 60][0];

            code_word_temp2_im[i][j] = huff_tab[diff_pred_coeff_im_temp2 + 60][1];

            length_tot2 += length_temp2_im[i][j];

          }

        }

      } else {

        pred_coeffs_re[i][j] = 0;

        /*delta_code_time = 0*/

        prev_pred_coeff_re_temp1 = pred_coeffs_re[i][j];

        if (complex_coef == 1) {

          pred_coeffs_im[i][j] = 0;

          /*delta_code_time = 0*/

          prev_pred_coeff_im_temp1 = pred_coeffs_im[i][j];

        }

      }

      ptr_prev_alpha_coeff_re[j] = pred_coeffs_re[i][j];

      if (complex_coef == 1) {

        ptr_prev_alpha_coeff_im[j] = pred_coeffs_im[i][j];

      }

    }

    for (j = num_sfb; j < MAX_SFB_LONG; j++) {

      pred_coeffs_re[i][j] = 0;

      ptr_prev_alpha_coeff_re[j] = 0;

      if (complex_coef == 1) {

        pred_coeffs_im[i][j] = 0;

        ptr_prev_alpha_coeff_im[j] = 0;

      }

    }

  }

  /*Make a decison on the value of delta_code_time per frame */

  if (!usac_independency_flg) {

    // Compare the code-word lengths

    if (length_tot1 <= length_tot2) {

      *delta_code_time = 0;

    } else {

      *delta_code_time = 1;

    }

    /* Write the value of delta_code_time to bitstream */

    if (write_flag) iusace_write_bits_buf(it_bit_buf, *delta_code_time, 1);

    bit_count += 1;

  }

  if (*delta_code_time == 0) {

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

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

        if (cplx_pred_used[i][j] == 1) {

          if (write_flag)

            iusace_write_bits_buf(it_bit_buf, code_word_temp1_re[i][j],

                                  (UWORD8)length_temp1_re[i][j]);

          bit_count += length_temp1_re[i][j];

          if (complex_coef == 1) {

            if (write_flag)

              iusace_write_bits_buf(it_bit_buf, code_word_temp1_im[i][j],

                                    (UWORD8)length_temp1_im[i][j]);

            bit_count += length_temp1_im[i][j];

          }

        }

      }

    }

  } else {

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

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

        if (cplx_pred_used[i][j] == 1) {

          if (write_flag)

            iusace_write_bits_buf(it_bit_buf, code_word_temp2_re[i][j],

                                  (UWORD8)length_temp2_re[i][j]);

          bit_count += length_temp2_re[i][j];

          if (complex_coef == 1) {

            if (write_flag)

              iusace_write_bits_buf(it_bit_buf, code_word_temp2_im[i][j],

                                    (UWORD8)length_temp2_im[i][j]);

            bit_count += length_temp2_im[i][j];

          }

        }

      }

    }

  }

  return bit_count;

}

WORD32 iusace_write_cpe(ia_sfb_params_struct *pstr_sfb_prms, ia_bit_buf_struct *it_bit_buf,

                        WORD32 *tns_data_present, WORD32 const usac_independency_flg,

                        ia_usac_encoder_config_struct *pstr_usac_config,

                        ia_usac_data_struct *pstr_usac_data, WORD32 ch) {

  WORD32 bit_count = 0;

  WORD32 ms_mask = pstr_usac_data->str_ms_info[ch].ms_mask;

  WORD32 common_max_sfb = 1;

  WORD32 tns_active = tns_data_present[0] || tns_data_present[1];

  ia_tns_info *pstr_tns_info = pstr_usac_data->pstr_tns_info[ch];

  (VOID) pstr_usac_config;

  iusace_write_bits_buf(it_bit_buf, tns_active, 1);

  bit_count += 1;

  iusace_write_bits_buf(it_bit_buf, pstr_sfb_prms->common_win[ch], 1);

  bit_count += 1;

  if (pstr_sfb_prms->max_sfb[ch] != pstr_sfb_prms->max_sfb[ch + 1]) {

    common_max_sfb = 0;

  }

  if (pstr_sfb_prms->common_win[ch]) {

    bit_count += iusace_write_ics_info(it_bit_buf, pstr_sfb_prms, ch);

    iusace_write_bits_buf(it_bit_buf, common_max_sfb, 1);

    bit_count += 1;

    if (common_max_sfb == 0) {

      if (pstr_sfb_prms->window_sequence[ch] != EIGHT_SHORT_SEQUENCE) {

        iusace_write_bits_buf(it_bit_buf, pstr_sfb_prms->max_sfb[ch + 1], 6);

        bit_count += 6;

      } else {

        iusace_write_bits_buf(it_bit_buf, pstr_sfb_prms->max_sfb[ch + 1], 4);

        bit_count += 4;

      }

    }

    pstr_sfb_prms->max_sfb_ste = MAX(pstr_sfb_prms->max_sfb[ch], pstr_sfb_prms->max_sfb[ch + 1]);

    bit_count +=

        iusace_write_ms_data(it_bit_buf, ms_mask, pstr_usac_data->str_ms_info[ch].ms_used,

                             pstr_sfb_prms->num_window_groups[ch], pstr_sfb_prms->max_sfb_ste);

    {

      if ((ms_mask == 3) && (pstr_usac_data->stereo_config_index == 0)) {

        bit_count += iusace_write_cplx_pred_data(

            it_bit_buf, pstr_sfb_prms->num_window_groups[ch], pstr_sfb_prms->max_sfb_ste,

            pstr_usac_data->complex_coef[ch], pstr_usac_data->pred_coef_re[ch],

            pstr_usac_data->pred_coef_im[ch], iusace_huffman_code_table, usac_independency_flg,

            pstr_usac_data->pred_dir_idx[ch], pstr_usac_data->cplx_pred_used[ch],

            pstr_usac_data->cplx_pred_all[ch], pstr_usac_data->pred_coef_re_prev[ch],

            pstr_usac_data->pred_coef_im_prev[ch], &pstr_usac_data->delta_code_time[ch]);

      }

    }

  }

  if (tns_active) {

    WORD32 common_tns = 0;

    WORD32 tns_on_lr = 1;

    WORD32 tns_present_both = tns_data_present[0] && tns_data_present[1];

    WORD32 tns_data_present1 = tns_data_present[1];

    if (pstr_sfb_prms->common_win[ch]) {

      iusace_write_bits_buf(it_bit_buf, common_tns, 1);

      bit_count += 1;

    }

    iusace_write_bits_buf(it_bit_buf, tns_on_lr, 1);

    bit_count += 1;

    if (common_tns) {

      bit_count +=

          iusace_write_tns_data(it_bit_buf, pstr_tns_info, pstr_sfb_prms->window_sequence[ch], 0);

    } else {

      iusace_write_bits_buf(it_bit_buf, tns_present_both, 1);

      bit_count += 1;

      if (!tns_present_both) {

        iusace_write_bits_buf(it_bit_buf, tns_data_present1, 1);

        bit_count += 1;

      }

    }

  }

  return (bit_count);

}

WORD32 iusace_write_fd_data(ia_bit_buf_struct *it_bit_buf, ia_sfb_params_struct *pstr_sfb_prms,

                            WORD32 num_fac_bits, WORD32 usac_independency_flg,

                            ia_usac_data_struct *pstr_usac_data,

                            ia_usac_encoder_config_struct *pstr_usac_config, WORD32 ch_idx,

                            WORD32 ele_id, WORD32 idx) {

  WORD32 bit_count = 0;

  WORD32 fac_data_present = (num_fac_bits > 0) ? 1 : 0;

  WORD16 *ptr_fac_data = pstr_usac_data->fac_out_stream[ch_idx];

  WORD32 is_noise_filling = pstr_usac_data->noise_filling[ele_id];

  WORD32 common_window = pstr_sfb_prms->common_win[ch_idx];

  ia_usac_quant_info_struct *pstr_quant_info = &(pstr_usac_data->str_quant_info[idx]);

  ia_tns_info *pstr_tns_info = pstr_usac_data->pstr_tns_info[ch_idx];

  WORD32 global_gain = pstr_usac_data->str_quant_info[idx].scale_factor[0];

  iusace_write_bits_buf(it_bit_buf, global_gain, 8);

  bit_count += 8;

  if (is_noise_filling) {

    iusace_write_bits_buf(it_bit_buf, pstr_usac_data->noise_level[idx], 3);

    iusace_write_bits_buf(it_bit_buf, pstr_usac_data->noise_offset[idx], 5);

    bit_count += 8;

  }

  if (!common_window) {

    bit_count += iusace_write_ics_info(it_bit_buf, pstr_sfb_prms, ch_idx);

  }

  bit_count += iusace_write_scf_data(

      it_bit_buf, pstr_sfb_prms->max_sfb[ch_idx], pstr_sfb_prms->num_sfb[ch_idx],

      pstr_quant_info->scale_factor, pstr_sfb_prms->num_window_groups[ch_idx], global_gain,

      iusace_huffman_code_table);

  if (pstr_tns_info != NULL && pstr_tns_info->tns_data_present == 1) {

    bit_count += iusace_write_tns_data(it_bit_buf, pstr_tns_info,

                                       pstr_sfb_prms->window_sequence[ch_idx], 0);

  }

  if (!usac_independency_flg) {

    iusace_write_bits_buf(it_bit_buf, pstr_quant_info->reset, 1);

    bit_count += 1;

  }

  if (pstr_quant_info->max_spec_coeffs == FRAME_LEN_SHORT_768) {

    pstr_quant_info->max_spec_coeffs = pstr_quant_info->max_spec_coeffs;

  }

  bit_count += iusace_arith_enc_spec(

      it_bit_buf, pstr_sfb_prms->window_sequence[ch_idx], pstr_quant_info->quant_degroup,

      pstr_quant_info->max_spec_coeffs, pstr_quant_info->c_pres, pstr_quant_info->c_prev,

      &(pstr_quant_info->arith_size_prev), usac_independency_flg || pstr_quant_info->reset,

      pstr_usac_config->ccfl);

  iusace_write_bits_buf(it_bit_buf, fac_data_present, 1);

  bit_count += 1;

  if (fac_data_present) {

    WORD32 i;

    for (i = 0; i < num_fac_bits; i += 8) {

      WORD32 bits_to_write = MIN(8, num_fac_bits - i);

      iusace_write_bits_buf(it_bit_buf, ptr_fac_data[i / 8] >> (8 - bits_to_write),

                            (UWORD8)bits_to_write);

    }

    bit_count += num_fac_bits;

  }

  return (bit_count);

}

WORD32 iusace_count_fd_bits(ia_sfb_params_struct *pstr_sfb_prms,

                            ia_usac_data_struct *pstr_usac_data, WORD32 usac_independency_flg,

                            ia_usac_encoder_config_struct *pstr_usac_config, WORD32 ch_idx,

                            WORD32 idx) {

  WORD32 bit_count = 0;

  ia_usac_quant_info_struct *pstr_quant_info = &pstr_usac_data->str_quant_info[idx];

  WORD32 window_sequence = pstr_sfb_prms->window_sequence[ch_idx];

  WORD32 global_gain = pstr_quant_info->scale_factor[0];

  WORD32 max_sfb = pstr_sfb_prms->max_sfb[ch_idx];

  WORD32 num_sfb = pstr_sfb_prms->num_sfb[ch_idx];

  WORD32 num_win_grps = pstr_sfb_prms->num_window_groups[ch_idx];

  bit_count += iusace_write_scf_data(NULL, max_sfb, num_sfb, pstr_quant_info->scale_factor,

                                     num_win_grps, global_gain, iusace_huffman_code_table);

  WORD32 temp_c_pres[516], temp_c_prev[516], temp_size = pstr_quant_info->arith_size_prev;

  memcpy(temp_c_pres, pstr_quant_info->c_pres, 516 * sizeof(pstr_quant_info->c_pres[0]));

  memcpy(temp_c_prev, pstr_quant_info->c_prev, 516 * sizeof(pstr_quant_info->c_prev[0]));

  bit_count += iusace_arith_enc_spec(

      NULL, window_sequence, pstr_quant_info->quant_degroup, pstr_quant_info->max_spec_coeffs,

      temp_c_pres, temp_c_prev, &(temp_size), usac_independency_flg || pstr_quant_info->reset,

      pstr_usac_config->ccfl);

  return (bit_count);

}

WORD32 iusace_write_fill_ele(ia_bit_buf_struct *it_bit_buf, WORD32 num_bits) {

  WORD32 write_flag = (it_bit_buf != NULL);

  WORD32 bit_count = 0;

  if (num_bits <= 8) {

    if (write_flag) {

      iusace_write_bits_buf(it_bit_buf, 0, 1);

    }

    bit_count++;

    num_bits--;

  } else {

    if (write_flag) {

      iusace_write_bits_buf(it_bit_buf, 1, 1);

    }

    bit_count++;

    num_bits--;

    if (num_bits <= 8) {

      if (write_flag) {

        iusace_write_bits_buf(it_bit_buf, 1, 1);

      }

      bit_count++;

      num_bits--;

    } else {

      WORD32 bytes_to_write = 0;

      if (write_flag) {

        iusace_write_bits_buf(it_bit_buf, 0, 1);

      }

      bit_count++;

      num_bits--;

      bytes_to_write = num_bits >> 3;

      if (bytes_to_write > 255) {

        bytes_to_write -= 3;

        if (write_flag) {

          iusace_write_bits_buf(it_bit_buf, 255, 8);

        }

        if (write_flag) {

          iusace_write_bits_buf(it_bit_buf, bytes_to_write - 253, 16);

        }

        bit_count += 24;

        num_bits -= 24;

      } else {

        bytes_to_write--;

        if (write_flag) {

          iusace_write_bits_buf(it_bit_buf, bytes_to_write, 8);

        }

        bit_count += 8;

        num_bits -= 8;

      }

      while (bytes_to_write > 0) {

        if (write_flag) {

          iusace_write_bits_buf(it_bit_buf, 0xA9, 8);

        }

        bit_count += 8;

        num_bits -= 8;

        bytes_to_write--;

      }

    }

  }

  return bit_count;

}