| /****************************************************************************** |
| * * |
| * 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 <math.h> |
| #include <stdlib.h> |
| |
| #include "ixheaac_type_def.h" |
| #include "ixheaac_constants.h" |
| #include "ixheaace_aac_constants.h" |
| |
| #include "ixheaac_error_standards.h" |
| #include "ixheaace_error_codes.h" |
| #include "ixheaace_psy_const.h" |
| #include "ixheaace_tns.h" |
| #include "ixheaace_tns_params.h" |
| #include "ixheaace_rom.h" |
| #include "ixheaace_common_rom.h" |
| #include "ixheaace_quant.h" |
| #include "ixheaace_block_switch.h" |
| #include "ixheaace_bitbuffer.h" |
| |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops16.h" |
| #include "ixheaac_basic_ops40.h" |
| #include "ixheaac_basic_ops.h" |
| |
| #include "ixheaace_tns.h" |
| #include "ixheaace_psy_data.h" |
| #include "ixheaace_interface.h" |
| #include "ixheaace_adjust_threshold_data.h" |
| |
| #include "ixheaace_dynamic_bits.h" |
| #include "ixheaace_qc_data.h" |
| #include "ixheaace_adjust_threshold.h" |
| |
| #include "ixheaace_sf_estimation.h" |
| |
| #include "ixheaace_static_bits.h" |
| |
| #include "ixheaace_bits_count.h" |
| |
| #include "ixheaace_channel_map.h" |
| #include "ixheaace_write_bitstream.h" |
| #include "ixheaace_psy_configuration.h" |
| #include "ixheaace_psy_mod.h" |
| #include "ixheaace_tns_params.h" |
| #include "ixheaace_stereo_preproc.h" |
| #include "ixheaace_enc_main.h" |
| #include "ixheaace_qc_util.h" |
| #include "ixheaace_common_utils.h" |
| |
| IA_ERRORCODE ia_enhaacplus_enc_qc_main( |
| ixheaace_qc_state *pstr_qc_state, WORD32 num_channels, ixheaace_element_bits *pstr_el_bits, |
| ixheaace_psy_out_channel **psy_out_ch, |
| ixheaace_psy_out_element *pstr_psy_out_element, |
| ixheaace_qc_out_channel **pstr_qc_out_ch, |
| ixheaace_qc_out_element *pstr_qc_out_element, WORD32 ancillary_data_bytes, |
| ixheaace_aac_tables *pstr_aac_tables, WORD32 adts_flag, WORD32 aot, WORD32 stat_bits_flag, |
| WORD32 flag_last_element, WORD32 frame_len_long, WORD8 *ptr_scratch, |
| WORD32 *is_quant_spec_zero, WORD32 *is_gain_limited) { |
| IA_ERRORCODE err_code; |
| WORD32 ch; |
| WORD32 i = 0; |
| WORD32 k = 0; |
| WORD32 j = 0; |
| WORD32 iterations = 0; |
| WORD32 constraints_fulfilled; |
| WORD32 ch_dyn_bits; |
| WORD32 max_ch_dyn_bits[IXHEAACE_MAX_CH_IN_BS_ELE]; |
| FLOAT32 ch_bit_dist[IXHEAACE_MAX_CH_IN_BS_ELE]; |
| ixheaace_qc_stack *ptr_stack = (ixheaace_qc_stack *)ptr_scratch; |
| ptr_scratch += sizeof(ixheaace_qc_stack); |
| |
| ia_adj_thr_elem_struct *pstr_adj_thr_elem = &pstr_qc_state->str_adj_thr.str_adj_thr_ele; |
| WORD32 gain; |
| |
| if (pstr_el_bits->bit_res_level < 0) { |
| return IA_EXHEAACE_EXE_FATAL_INVALID_BIT_RES_LEVEL; |
| } |
| |
| if (pstr_el_bits->bit_res_level > pstr_el_bits->max_bit_res_bits) { |
| return IA_EXHEAACE_EXE_FATAL_INVALID_BIT_RES_LEVEL; |
| } |
| pstr_qc_out_element->static_bits_used = |
| ia_enhaacplus_enc_count_static_bitdemand(psy_out_ch, pstr_psy_out_element, num_channels, |
| aot, adts_flag, stat_bits_flag, flag_last_element); |
| |
| if (ancillary_data_bytes) { |
| pstr_qc_out_element->anc_bits_used = |
| 7 + 8 * (ancillary_data_bytes + (ancillary_data_bytes >= 15)); |
| } else { |
| pstr_qc_out_element->anc_bits_used = 0; |
| } |
| |
| for (ch = 0; ch < num_channels; ch++) { |
| iaace_calc_form_fac_per_chan(ptr_stack->sfb_form_fac[ch], |
| ptr_stack->sfb_num_relevant_lines[ch], psy_out_ch[ch], |
| ptr_stack->sfb_ld_energy[ch]); |
| } |
| |
| iaace_adjust_threshold( |
| &pstr_qc_state->str_adj_thr, pstr_adj_thr_elem, psy_out_ch, ch_bit_dist, |
| pstr_qc_out_element, |
| pstr_el_bits->average_bits - pstr_qc_out_element->static_bits_used - |
| pstr_qc_out_element->anc_bits_used, |
| pstr_el_bits->bit_res_level, pstr_el_bits->max_bit_res_bits, |
| pstr_qc_out_element->static_bits_used + pstr_qc_out_element->anc_bits_used, |
| &pstr_qc_state->max_bit_fac, ptr_stack->sfb_num_relevant_lines[0], |
| ptr_stack->sfb_ld_energy[0], num_channels, 0, aot, ptr_scratch); |
| |
| iaace_estimate_scfs_chan(psy_out_ch, pstr_qc_out_ch, ptr_stack->sfb_form_fac, |
| ptr_stack->sfb_num_relevant_lines, num_channels, 0, frame_len_long); |
| |
| for (ch = 0; ch < num_channels; ch++) { |
| max_ch_dyn_bits[ch] = |
| (pstr_el_bits->average_bits + pstr_el_bits->bit_res_level - 7 - |
| pstr_qc_out_element->static_bits_used - pstr_qc_out_element->anc_bits_used); |
| |
| max_ch_dyn_bits[ch] = (WORD32)floor(ch_bit_dist[ch] * (FLOAT32)(max_ch_dyn_bits[ch])); |
| } |
| |
| pstr_qc_out_element->dyn_bits_used = 0; |
| |
| for (ch = 0; ch < num_channels; ch++) { |
| /* now loop until bitstream constraints (ch_dyn_bits < maxChDynBits) |
| are fulfilled */ |
| WORD32 spec_idx, sfb_offs, sfb; |
| iterations = 0; |
| gain = 0; |
| for (spec_idx = 0; spec_idx < frame_len_long; spec_idx++) { |
| ptr_stack->exp_spec[spec_idx] = (FLOAT32)psy_out_ch[ch]->ptr_spec_coeffs[spec_idx]; |
| ptr_stack->mdct_spec_float[spec_idx] = (FLOAT32)psy_out_ch[ch]->ptr_spec_coeffs[spec_idx]; |
| } |
| do { |
| WORD32 max_val; |
| constraints_fulfilled = 1; |
| WORD32 quant_spec_is_zero = 1; |
| if (iterations > 0) { |
| for (sfb_offs = 0; sfb_offs < psy_out_ch[ch]->sfb_count; |
| sfb_offs += psy_out_ch[ch]->sfb_per_group) { |
| for (sfb = 0; sfb < psy_out_ch[ch]->max_sfb_per_grp; sfb++) { |
| WORD32 scalefactor = pstr_qc_out_ch[ch]->scalefactor[sfb + sfb_offs]; |
| gain = MAX(gain, pstr_qc_out_ch[ch]->global_gain - scalefactor); |
| iaace_quantize_lines( |
| pstr_qc_out_ch[ch]->global_gain - scalefactor, |
| psy_out_ch[ch]->sfb_offsets[sfb_offs + sfb + 1] - |
| psy_out_ch[ch]->sfb_offsets[sfb_offs + sfb], |
| ptr_stack->exp_spec + psy_out_ch[ch]->sfb_offsets[sfb_offs + sfb], |
| pstr_qc_out_ch[ch]->quant_spec + psy_out_ch[ch]->sfb_offsets[sfb_offs + sfb], |
| ptr_stack->mdct_spec_float + psy_out_ch[ch]->sfb_offsets[sfb_offs + sfb]); |
| } |
| } |
| } |
| |
| max_val = iaace_calc_max_val_in_sfb( |
| psy_out_ch[ch]->sfb_count, psy_out_ch[ch]->max_sfb_per_grp, |
| psy_out_ch[ch]->sfb_per_group, |
| psy_out_ch[ch]->sfb_offsets, pstr_qc_out_ch[ch]->quant_spec, |
| pstr_qc_out_ch[ch]->max_val_in_sfb); |
| |
| if (max_val > MAXIMUM_QUANT) { |
| constraints_fulfilled = 0; |
| } |
| |
| for (k = 0; ((k < psy_out_ch[ch]->sfb_count) && (quant_spec_is_zero)); |
| k += psy_out_ch[ch]->sfb_per_group) { |
| for (i = 0; ((i < psy_out_ch[ch]->max_sfb_per_grp) && (quant_spec_is_zero)); i++) { |
| for (j = psy_out_ch[ch]->sfb_offsets[i+k]; j < psy_out_ch[ch]->sfb_offsets[i+k+1]; j++) |
| { |
| if (pstr_qc_out_ch[ch]->quant_spec[j] != 0) { |
| quant_spec_is_zero = 0; |
| break; |
| } |
| } |
| } |
| } |
| err_code = ia_enhaacplus_enc_dyn_bitcount( |
| pstr_qc_out_ch[ch]->quant_spec, pstr_qc_out_ch[ch]->max_val_in_sfb, |
| pstr_qc_out_ch[ch]->scalefactor, psy_out_ch[ch]->window_sequence, |
| psy_out_ch[ch]->sfb_count, psy_out_ch[ch]->max_sfb_per_grp, |
| psy_out_ch[ch]->sfb_per_group, |
| psy_out_ch[ch]->sfb_offsets, &pstr_qc_out_ch[ch]->section_data, |
| pstr_qc_state->side_info_tab_long, pstr_qc_state->side_info_tab_short, |
| pstr_aac_tables->pstr_huff_tab, pstr_qc_state->qc_scr.shared_buffer_2, aot, |
| &ch_dyn_bits); |
| |
| if (err_code != IA_NO_ERROR) { |
| return err_code; |
| } |
| |
| if (ch_dyn_bits >= max_ch_dyn_bits[ch]) { |
| constraints_fulfilled = 0; |
| } |
| |
| if (quant_spec_is_zero == 1) { |
| constraints_fulfilled = 1; |
| /*Bit consuption is exceding bit reservoir, there is no scope left for bit consumption |
| reduction, as spectrum is zero. Hence breaking the quantization loop. */ |
| if (iterations > 0) { |
| *is_quant_spec_zero = 1; |
| ch_dyn_bits = max_ch_dyn_bits[ch]; |
| } |
| } |
| if ((gain == MAX_GAIN_INDEX) && (constraints_fulfilled == 0)) { |
| /* Bit consuption is exceding bit reservoir, there is no scope left for bit consumption |
| reduction, as gain has reached the maximum value. Hence breaking the quantization |
| loop. */ |
| constraints_fulfilled = 1; |
| *is_gain_limited = 1; |
| ch_dyn_bits = max_ch_dyn_bits[ch]; |
| } |
| if (!constraints_fulfilled) { |
| pstr_qc_out_ch[ch]->global_gain++; |
| } |
| iterations++; |
| |
| } while (!constraints_fulfilled); |
| |
| pstr_qc_out_element->dyn_bits_used += ch_dyn_bits; |
| |
| pstr_qc_out_ch[ch]->grouping_mask = psy_out_ch[ch]->grouping_mask; |
| pstr_qc_out_ch[ch]->win_shape = psy_out_ch[ch]->window_shape; |
| } |
| |
| pstr_adj_thr_elem->dyn_bits_last = pstr_qc_out_element->dyn_bits_used; |
| { |
| WORD32 bit_res_space = pstr_el_bits->max_bit_res_bits - pstr_el_bits->bit_res_level; |
| WORD32 delta_bit_res = pstr_el_bits->average_bits - (pstr_qc_out_element->static_bits_used + |
| pstr_qc_out_element->dyn_bits_used + |
| pstr_qc_out_element->anc_bits_used); |
| |
| pstr_qc_out_element->fill_bits = MAX(0, (delta_bit_res - bit_res_space)); |
| } |
| |
| return IA_NO_ERROR; |
| } |
| |
| WORD32 iaace_calc_max_val_in_sfb(WORD32 sfb_count, WORD32 max_sfb_per_grp, WORD32 ptr_sfb_per_grp, |
| WORD32 *ptr_sfb_offset, WORD16 *ptr_quant_spec, |
| UWORD16 *ptr_max_value) { |
| WORD32 sfb; |
| WORD32 max = 0; |
| WORD32 sfb_offs; |
| |
| for (sfb_offs = 0; sfb_offs < sfb_count; sfb_offs += ptr_sfb_per_grp) { |
| for (sfb = 0; sfb < max_sfb_per_grp; sfb++) { |
| WORD32 line; |
| WORD32 local_max = 0; |
| for (line = ptr_sfb_offset[sfb + sfb_offs]; line < ptr_sfb_offset[sfb + sfb_offs + 1]; |
| line++) { |
| if (abs(ptr_quant_spec[line]) > local_max) { |
| local_max = abs(ptr_quant_spec[line]); |
| } |
| } |
| ptr_max_value[sfb_offs + sfb] = (UWORD16)local_max; |
| if (local_max > max) { |
| max = local_max; |
| } |
| } |
| } |
| |
| return max; |
| } |
