740 lines
24 KiB
C
740 lines
24 KiB
C
/******************************************************************************
|
|
* *
|
|
* Copyright (C) 2023 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*****************************************************************************
|
|
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
|
|
*/
|
|
|
|
#include <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"
|
|
|
|
#if DEBUG_DUMP
|
|
extern FILE *out_file;
|
|
#endif
|
|
|
|
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 sf_out = 0;
|
|
WORD32 sf_not_out = 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);
|
|
sf_out++;
|
|
}
|
|
}
|
|
index++;
|
|
}
|
|
for (; i < num_sfb; i++) {
|
|
sf_not_out++;
|
|
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) {
|
|
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);
|
|
}
|
|
|
|
#if DEBUG_DUMP
|
|
WORD32 bit_count_start = bit_count;
|
|
#endif
|
|
|
|
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 DEBUG_DUMP
|
|
WORD32 bit_count_mid_1 = bit_count;
|
|
#endif
|
|
|
|
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 DEBUG_DUMP
|
|
WORD32 bit_count_mid_2 = bit_count;
|
|
#endif
|
|
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);
|
|
|
|
#if DEBUG_DUMP
|
|
WORD32 bit_count_end = bit_count;
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
|
|
#if DEBUG_DUMP
|
|
fprintf(out_file, "%d\t",
|
|
bit_count - (bit_count_mid_1 - bit_count_start) - (bit_count_end - bit_count_mid_2));
|
|
#endif
|
|
|
|
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;
|
|
}
|