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