| /****************************************************************************** |
| * * |
| * 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 <stdlib.h> |
| #include <math.h> |
| |
| #include <string.h> |
| |
| #include "ixheaac_type_def.h" |
| #include "ixheaac_constants.h" |
| #include "impd_drc_common_enc.h" |
| #include "impd_drc_uni_drc.h" |
| #include "impd_drc_tables.h" |
| #include "impd_drc_api.h" |
| #include "ixheaace_api.h" |
| #include "ixheaace_aac_constants.h" |
| #include "ixheaac_error_standards.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_bitbuffer.h" |
| |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops16.h" |
| #include "ixheaac_basic_ops40.h" |
| #include "ixheaac_basic_ops.h" |
| |
| #include "ixheaace_block_switch.h" |
| #include "ixheaace_psy_utils_spreading.h" |
| #include "ixheaace_psy_utils.h" |
| #include "ixheaace_calc_ms_band_energy.h" |
| #include "ixheaace_tns.h" |
| #include "ixheaace_adjust_threshold_data.h" |
| #include "ixheaace_dynamic_bits.h" |
| #include "ixheaace_qc_data.h" |
| #include "ixheaace_psy_data.h" |
| #include "ixheaace_ms_stereo.h" |
| #include "ixheaace_interface.h" |
| |
| #include "ixheaace_write_bitstream.h" |
| #include "ixheaace_psy_configuration.h" |
| #include "ixheaace_psy_mod.h" |
| #include "ixheaace_stereo_preproc.h" |
| #include "ixheaace_enc_main.h" |
| #include "ixheaace_group_data.h" |
| |
| #include "ixheaace_tns_func.h" |
| |
| #include "ixheaace_tns_params.h" |
| #include "ixheaace_common_utils.h" |
| #include "ixheaace_fft.h" |
| |
| static WORD32 ia_enhaacplus_enc_block_type_to_window_shape_lc[] = {KBD_WINDOW, SINE_WINDOW, |
| SINE_WINDOW, KBD_WINDOW}; |
| |
| static WORD32 ia_enhaacplus_enc_block_type_to_window_shape_ld[] = {SINE_WINDOW, LD_WINDOW, |
| LD_WINDOW, SINE_WINDOW}; |
| |
| WORD32 ia_enhaacplus_enc_psy_new(ixheaace_psy_kernel *pstr_h_psy, WORD32 num_chan, |
| WORD32 *ptr_shared_buffer_2, WORD32 long_frame_len) |
| |
| { |
| WORD32 i; |
| for (i = 0; i < num_chan; i++) { |
| pstr_h_psy->psy_data[i]->ptr_spec_coeffs = |
| (FLOAT32 *)(&ptr_shared_buffer_2[i * long_frame_len]); |
| |
| memset(pstr_h_psy->psy_data[i]->ptr_spec_coeffs, 0, |
| long_frame_len * sizeof(*pstr_h_psy->psy_data[i]->ptr_spec_coeffs)); |
| } |
| |
| pstr_h_psy->p_scratch_tns_float = (FLOAT32 *)(&ptr_shared_buffer_2[2 * long_frame_len]); |
| if (long_frame_len == FRAME_LEN_960) { |
| pstr_h_psy->p_scratch_tns_float = pstr_h_psy->p_scratch_tns_float + 128; |
| } |
| |
| memset(pstr_h_psy->p_scratch_tns_float, 0, |
| long_frame_len * sizeof(*pstr_h_psy->p_scratch_tns_float)); |
| |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE ia_enhaacplus_enc_psy_main_init(ixheaace_psy_kernel *pstr_h_psy, WORD32 sample_rate, |
| WORD32 bit_rate, WORD32 channels, WORD32 tns_mask, |
| WORD32 bandwidth, WORD32 aot, |
| ixheaace_aac_tables *pstr_aac_tables, |
| WORD32 frame_len_long) |
| |
| { |
| WORD32 ch; |
| IA_ERRORCODE err; |
| |
| err = ia_enhaacplus_enc_init_psy_configuration(bit_rate / channels, sample_rate, bandwidth, aot, |
| &(pstr_h_psy->psy_conf_long), pstr_aac_tables, |
| frame_len_long); |
| if (err != IA_NO_ERROR) { |
| return err; |
| } |
| |
| if (!err) { |
| err = ia_enhaacplus_enc_init_tns_configuration( |
| bit_rate, sample_rate, channels, &pstr_h_psy->psy_conf_long.str_tns_conf, |
| &(pstr_h_psy->psy_conf_long), (WORD32)(tns_mask & 1), pstr_aac_tables->pstr_tns_tab, |
| frame_len_long, aot); |
| |
| if (err != IA_NO_ERROR) { |
| return err; |
| } |
| } |
| if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) { |
| if (!err) { |
| err = ia_enhaacplus_enc_init_psy_configuration_short( |
| bit_rate / channels, sample_rate, bandwidth, aot, &pstr_h_psy->psy_conf_short, |
| pstr_aac_tables, frame_len_long / BLK_SWITCH_WIN); |
| if (err != IA_NO_ERROR) { |
| return err; |
| } |
| } |
| |
| if (!err) { |
| err = ia_enhaacplus_enc_init_tns_configuration_short( |
| bit_rate, sample_rate, channels, &pstr_h_psy->psy_conf_short.str_tns_conf, |
| &(pstr_h_psy->psy_conf_short), (WORD32)(tns_mask & 1), pstr_aac_tables->pstr_tns_tab, |
| frame_len_long / BLK_SWITCH_WIN, aot); |
| if (err != IA_NO_ERROR) { |
| return err; |
| } |
| } |
| } |
| |
| if (!err) { |
| /* pstr_h_psy->psy_data[] */ |
| for (ch = 0; ch < channels; ch++) { |
| switch (aot) { |
| case AOT_AAC_LC: |
| case AOT_SBR: |
| case AOT_PS: |
| iaace_init_block_switching(&pstr_h_psy->psy_data[ch]->blk_switch_cntrl, bit_rate, |
| channels); |
| break; |
| |
| case AOT_AAC_LD: |
| case AOT_AAC_ELD: |
| pstr_h_psy->psy_data[ch]->blk_switch_cntrl.win_seq = LONG_WINDOW; |
| pstr_h_psy->psy_data[ch]->blk_switch_cntrl.nxt_win_seq = LONG_WINDOW; |
| break; |
| } |
| ia_enhaacplus_enc_init_pre_echo_control(pstr_h_psy->psy_data[ch]->sfb_threshold_nm1_float, |
| pstr_h_psy->psy_conf_long.sfb_cnt, |
| pstr_h_psy->psy_conf_long.sfb_threshold_quiet); |
| } |
| } |
| |
| return IA_NO_ERROR; |
| } |
| |
| static VOID ia_enhaacplus_enc_advance_psy_long_ms( |
| ixheaace_psy_data **psy_data, |
| ixheaace_psy_configuration_long *pstr_psy_conf_long) { |
| ia_enhaacplus_enc_calc_band_energy_ms( |
| psy_data[0]->ptr_spec_coeffs, psy_data[1]->ptr_spec_coeffs, pstr_psy_conf_long->sfb_offsets, |
| pstr_psy_conf_long->sfb_active, pstr_psy_conf_long->sfb_cnt, |
| psy_data[0]->sfb_energy_ms.long_nrg, &psy_data[0]->sfb_energy_sum_ms.long_nrg, |
| psy_data[1]->sfb_energy_ms.long_nrg, &psy_data[1]->sfb_energy_sum_ms.long_nrg); |
| } |
| |
| static VOID ia_enhaacplus_enc_advance_psy_short_ms( |
| ixheaace_psy_data **psy_data, |
| ixheaace_psy_configuration_short *pstr_psy_conf_short, WORD32 ccfl) { |
| WORD32 w; |
| WORD32 frame_len_short = FRAME_LEN_SHORT_128; |
| |
| if (ccfl == FRAME_LEN_960) { |
| frame_len_short = FRAME_LEN_SHORT_120; |
| } |
| for (w = 0; w < TRANS_FAC; w++) { |
| WORD32 w_offset = w * frame_len_short; |
| |
| ia_enhaacplus_enc_calc_band_energy_ms( |
| psy_data[0]->ptr_spec_coeffs + w_offset, psy_data[1]->ptr_spec_coeffs + w_offset, |
| pstr_psy_conf_short->sfb_offsets, pstr_psy_conf_short->sfb_active, |
| pstr_psy_conf_short->sfb_cnt, psy_data[0]->sfb_energy_ms.short_nrg[w], |
| &psy_data[0]->sfb_energy_sum_ms.short_nrg[w], psy_data[1]->sfb_energy_ms.short_nrg[w], |
| &psy_data[1]->sfb_energy_sum_ms.short_nrg[w]); |
| } |
| } |
| |
| static IA_ERRORCODE ia_enhaacplus_enc_advance_psy_short( |
| ixheaace_psy_data *pstr_psy_data, ixheaace_temporal_noise_shaping_data *pstr_tns_data, |
| ixheaace_psy_configuration_short *pstr_psy_conf_short, |
| ixheaace_psy_out_channel *pstr_psy_out_ch, FLOAT32 *ptr_tns_scratch, |
| const ixheaace_temporal_noise_shaping_data *ptr_tns_data2, const WORD32 ch, WORD32 aot, |
| FLOAT32 *ptr_shared_buffer1, ixheaace_aac_tables *pstr_aac_tables, WORD32 frame_len_long) { |
| IA_ERRORCODE error_code = IA_NO_ERROR; |
| WORD32 w; |
| FLOAT32 energy_shift = 0.25f; |
| FLOAT32 clip_energy = pstr_psy_conf_short->clip_energy * energy_shift; |
| |
| for (w = 0; w < TRANS_FAC; w++) { |
| WORD32 w_offset = w * frame_len_long; |
| WORD32 i, offset; |
| FLOAT32 *ptr_mdct = |
| &pstr_psy_data->ptr_spec_coeffs[pstr_psy_conf_short->lowpass_line + w_offset]; |
| |
| /* Low pass */ |
| offset = frame_len_long - pstr_psy_conf_short->lowpass_line; |
| memset(ptr_mdct, 0, sizeof(FLOAT32) * offset); |
| |
| /* Calc sfb-bandwise MDCT-energies for left and right channel */ |
| ia_enhaacplus_enc_calc_band_energy( |
| pstr_psy_data->ptr_spec_coeffs + w_offset, pstr_psy_conf_short->sfb_offsets, |
| pstr_psy_conf_short->sfb_active, pstr_psy_data->sfb_energy.short_nrg[w], |
| pstr_psy_conf_short->sfb_cnt, &pstr_psy_data->sfb_energy_sum.short_nrg[w]); |
| |
| /* TNS Detect*/ |
| error_code = ia_enhaacplus_enc_tns_detect( |
| pstr_tns_data, pstr_psy_conf_short->str_tns_conf, ptr_tns_scratch, |
| pstr_psy_conf_short->sfb_offsets, pstr_psy_data->ptr_spec_coeffs + w_offset, w, |
| pstr_psy_data->blk_switch_cntrl.win_seq, aot, pstr_psy_data->sfb_energy.short_nrg[w], |
| ptr_shared_buffer1, frame_len_long); |
| |
| if (error_code != IA_NO_ERROR) { |
| return error_code; |
| } |
| |
| /* TNS Sync */ |
| if (ch == 1) { |
| ia_enhaacplus_enc_tns_sync(pstr_tns_data, ptr_tns_data2, pstr_psy_conf_short->str_tns_conf, |
| w, (WORD32)pstr_psy_data->blk_switch_cntrl.win_seq); |
| } |
| |
| /* TNS Encode */ |
| ia_enhaacplus_enc_tns_encode( |
| &pstr_psy_out_ch->tns_info, pstr_tns_data, pstr_psy_conf_short->sfb_cnt, |
| pstr_psy_conf_short->str_tns_conf, pstr_psy_conf_short->lowpass_line, |
| pstr_psy_data->ptr_spec_coeffs + w_offset, w, pstr_psy_data->blk_switch_cntrl.win_seq, |
| pstr_aac_tables->pstr_tns_tab); |
| |
| for (i = 0; i < pstr_psy_conf_short->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold.short_nrg[w][i] = |
| pstr_psy_data->sfb_energy.short_nrg[w][i] * pstr_psy_conf_short->ratio_float; |
| |
| pstr_psy_data->sfb_threshold.short_nrg[w][i] = |
| MIN(pstr_psy_data->sfb_threshold.short_nrg[w][i], clip_energy); |
| } |
| |
| /* Calc sfb-bandwise MDCT-energies for left and right channel again, if TNS has modified the |
| * spectrum */ |
| if (pstr_psy_out_ch->tns_info.tns_active[w]) { |
| ia_enhaacplus_enc_calc_band_energy( |
| pstr_psy_data->ptr_spec_coeffs + w_offset, pstr_psy_conf_short->sfb_offsets, |
| pstr_psy_conf_short->sfb_active, pstr_psy_data->sfb_energy.short_nrg[w], |
| pstr_psy_conf_short->sfb_cnt, &pstr_psy_data->sfb_energy_sum.short_nrg[w]); |
| } |
| |
| /* Spreading */ |
| ia_enhaacplus_enc_spreading_max( |
| pstr_psy_conf_short->sfb_cnt, pstr_psy_conf_short->sfb_mask_low_factor, |
| pstr_psy_conf_short->sfb_mask_high_factor, pstr_psy_data->sfb_threshold.short_nrg[w]); |
| |
| for (i = 0; i < pstr_psy_conf_short->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold.short_nrg[w][i] = |
| MAX(pstr_psy_data->sfb_threshold.short_nrg[w][i], |
| (pstr_psy_conf_short->sfb_threshold_quiet[i] * energy_shift)); |
| } |
| |
| /* Pre-echo Control */ |
| ia_enhaacplus_enc_pre_echo_control(pstr_psy_data->sfb_threshold_nm1_float, |
| pstr_psy_conf_short->sfb_cnt, |
| pstr_psy_conf_short->min_remaining_threshold_factor, |
| pstr_psy_data->sfb_threshold.short_nrg[w]); |
| |
| /* Apply TNS mult table on CB thresholds */ |
| if (pstr_psy_out_ch->tns_info.tns_active[w]) { |
| ia_enhaacplus_enc_apply_tns_mult_table_to_ratios( |
| pstr_psy_conf_short->str_tns_conf.tns_ratio_patch_lowest_cb, |
| pstr_psy_conf_short->str_tns_conf.tns_start_band, |
| pstr_psy_data->sfb_threshold.short_nrg[w]); |
| } |
| |
| /* Spreaded energy for avoid hole detection */ |
| for (i = 0; i < pstr_psy_conf_short->sfb_cnt; i++) { |
| pstr_psy_data->sfb_sreaded_energy.short_nrg[w][i] = |
| pstr_psy_data->sfb_energy.short_nrg[w][i]; |
| } |
| |
| ia_enhaacplus_enc_spreading_max(pstr_psy_conf_short->sfb_cnt, |
| pstr_psy_conf_short->sfb_mask_low_factor_spread_nrg, |
| pstr_psy_conf_short->sfb_mask_high_factor_spread_nrg, |
| pstr_psy_data->sfb_sreaded_energy.short_nrg[w]); |
| } |
| return error_code; |
| } |
| |
| static IA_ERRORCODE ia_enhaacplus_enc_advance_psy_long( |
| ixheaace_psy_data *pstr_psy_data, ixheaace_temporal_noise_shaping_data *pstr_tns_data, |
| ixheaace_psy_configuration_long *pstr_psy_conf_long, |
| ixheaace_psy_out_channel *pstr_psy_out_ch, FLOAT32 *ptr_scratch_tns, |
| const ixheaace_temporal_noise_shaping_data *pstr_tns_data2, const WORD32 ch, WORD32 aot, |
| FLOAT32 *ptr_shared_buffer1, ixheaace_aac_tables *pstr_aac_tables, WORD32 frame_len_long) { |
| WORD32 i; |
| IA_ERRORCODE error_code = IA_NO_ERROR; |
| FLOAT32 energy_shift = 0.25f; |
| FLOAT32 clip_energy = pstr_psy_conf_long->clip_energy / 4; |
| FLOAT32 *ptr_sfb_energy_long = pstr_psy_data->sfb_energy.long_nrg; |
| FLOAT32 *ptr_sfb_spreaded_energy = pstr_psy_data->sfb_sreaded_energy.long_nrg; |
| |
| /* Low pass */ |
| memset(&pstr_psy_data->ptr_spec_coeffs[pstr_psy_conf_long->lowpass_line], 0, |
| sizeof(*pstr_psy_data->ptr_spec_coeffs) * |
| (frame_len_long - pstr_psy_conf_long->lowpass_line)); |
| |
| /* Calculate scale_factor_band - bandwise MDCT-energies for left and right channels */ |
| ia_enhaacplus_enc_calc_band_energy( |
| pstr_psy_data->ptr_spec_coeffs, pstr_psy_conf_long->sfb_offsets, |
| pstr_psy_conf_long->sfb_active, pstr_psy_data->sfb_energy.long_nrg, |
| pstr_psy_conf_long->sfb_cnt, &pstr_psy_data->sfb_energy_sum.long_nrg); |
| |
| /* TNS Detect */ |
| error_code = ia_enhaacplus_enc_tns_detect( |
| pstr_tns_data, pstr_psy_conf_long->str_tns_conf, ptr_scratch_tns, |
| pstr_psy_conf_long->sfb_offsets, pstr_psy_data->ptr_spec_coeffs, 0, |
| pstr_psy_data->blk_switch_cntrl.win_seq, aot, pstr_psy_data->sfb_energy.long_nrg, |
| ptr_shared_buffer1, frame_len_long); |
| |
| if (error_code != IA_NO_ERROR) { |
| return error_code; |
| } |
| |
| /* TNS Sync */ |
| if (ch == 1) { |
| ia_enhaacplus_enc_tns_sync(pstr_tns_data, pstr_tns_data2, pstr_psy_conf_long->str_tns_conf, 0, |
| (WORD32)pstr_psy_data->blk_switch_cntrl.win_seq); |
| } |
| |
| /* TNS Encode */ |
| ia_enhaacplus_enc_tns_encode(&pstr_psy_out_ch->tns_info, pstr_tns_data, |
| pstr_psy_conf_long->sfb_cnt, pstr_psy_conf_long->str_tns_conf, |
| pstr_psy_conf_long->lowpass_line, pstr_psy_data->ptr_spec_coeffs, |
| 0, (WORD32)pstr_psy_data->blk_switch_cntrl.win_seq, |
| pstr_aac_tables->pstr_tns_tab); |
| |
| if (aot == AOT_AAC_ELD) { |
| for (i = 0; i < pstr_psy_conf_long->sfb_active; i++) { |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| pstr_psy_data->sfb_energy.long_nrg[i] * pstr_psy_conf_long->ratio_float; |
| |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| MIN(pstr_psy_data->sfb_threshold.long_nrg[i], clip_energy); |
| } |
| } else { |
| for (i = 0; i < pstr_psy_conf_long->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| pstr_psy_data->sfb_energy.long_nrg[i] * pstr_psy_conf_long->ratio_float; |
| |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| MIN(pstr_psy_data->sfb_threshold.long_nrg[i], clip_energy); |
| } |
| } |
| |
| /* Calculate scale factor band - bandwise MDCT-energies for left and right channel again, if TNS |
| * has modified the spectrum */ |
| if (pstr_psy_out_ch->tns_info.tns_active[0] == 1) { |
| ia_enhaacplus_enc_calc_band_energy( |
| pstr_psy_data->ptr_spec_coeffs, pstr_psy_conf_long->sfb_offsets, |
| pstr_psy_conf_long->sfb_active, pstr_psy_data->sfb_energy.long_nrg, |
| pstr_psy_conf_long->sfb_cnt, &pstr_psy_data->sfb_energy_sum.long_nrg); |
| } |
| |
| /* Spreading */ |
| if (aot == AOT_AAC_ELD) { |
| ia_enhaacplus_enc_spreading_max( |
| pstr_psy_conf_long->sfb_active, pstr_psy_conf_long->sfb_mask_low_factor, |
| pstr_psy_conf_long->sfb_mask_high_factor, pstr_psy_data->sfb_threshold.long_nrg); |
| } else { |
| ia_enhaacplus_enc_spreading_max( |
| pstr_psy_conf_long->sfb_cnt, pstr_psy_conf_long->sfb_mask_low_factor, |
| pstr_psy_conf_long->sfb_mask_high_factor, pstr_psy_data->sfb_threshold.long_nrg); |
| } |
| |
| /* Threshold in quiet */ |
| if (aot == AOT_AAC_ELD) { |
| for (i = 0; i < pstr_psy_conf_long->sfb_active; i++) { |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| MAX(pstr_psy_data->sfb_threshold.long_nrg[i], |
| (pstr_psy_conf_long->sfb_threshold_quiet[i] * energy_shift)); |
| } |
| } else { |
| for (i = 0; i < pstr_psy_conf_long->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold.long_nrg[i] = |
| MAX(pstr_psy_data->sfb_threshold.long_nrg[i], |
| (pstr_psy_conf_long->sfb_threshold_quiet[i] * energy_shift)); |
| } |
| } |
| |
| /* Pre-echo control */ |
| if (pstr_psy_data->blk_switch_cntrl.win_seq == STOP_WINDOW) { |
| /* Prevent pre-echo control from comparing stop thresholds with short thresholds */ |
| for (i = 0; i < pstr_psy_conf_long->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold_nm1_float[i] = 1.0e20f; |
| } |
| } |
| |
| ia_enhaacplus_enc_pre_echo_control( |
| pstr_psy_data->sfb_threshold_nm1_float, pstr_psy_conf_long->sfb_cnt, |
| pstr_psy_conf_long->min_remaining_threshold_factor, pstr_psy_data->sfb_threshold.long_nrg); |
| |
| if (pstr_psy_data->blk_switch_cntrl.win_seq == START_WINDOW) { |
| /* Prevent pre-echo control in next frame from comparing start thresholds with short |
| * thresholds */ |
| for (i = 0; i < pstr_psy_conf_long->sfb_cnt; i++) { |
| pstr_psy_data->sfb_threshold_nm1_float[i] = 1.0e20f; |
| } |
| } |
| |
| /* Apply TNS mult table on CB thresholds */ |
| if (pstr_psy_out_ch->tns_info.tns_active[0]) { |
| ia_enhaacplus_enc_apply_tns_mult_table_to_ratios( |
| pstr_psy_conf_long->str_tns_conf.tns_ratio_patch_lowest_cb, |
| pstr_psy_conf_long->str_tns_conf.tns_start_band, pstr_psy_data->sfb_threshold.long_nrg); |
| } |
| |
| /* Spreaded energy for avoid hole detection */ |
| |
| memcpy(&ptr_sfb_spreaded_energy[0], &ptr_sfb_energy_long[0], |
| sizeof(ptr_sfb_spreaded_energy[0]) * pstr_psy_conf_long->sfb_cnt); |
| |
| if (aot == AOT_AAC_ELD) { |
| ia_enhaacplus_enc_spreading_max(pstr_psy_conf_long->sfb_active, |
| pstr_psy_conf_long->sfb_mask_low_factor_spread_nrg, |
| pstr_psy_conf_long->sfb_mask_high_factor_spread_nrg, |
| pstr_psy_data->sfb_sreaded_energy.long_nrg); |
| } else { |
| ia_enhaacplus_enc_spreading_max(pstr_psy_conf_long->sfb_cnt, |
| pstr_psy_conf_long->sfb_mask_low_factor_spread_nrg, |
| pstr_psy_conf_long->sfb_mask_high_factor_spread_nrg, |
| pstr_psy_data->sfb_sreaded_energy.long_nrg); |
| } |
| |
| return error_code; |
| } |
| |
| IA_ERRORCODE ia_enhaacplus_enc_psy_main( |
| WORD32 time_sn_stride, ixheaace_element_info *pstr_elem_info, const FLOAT32 *ptr_time_signal, |
| WORD32 aot, ixheaace_psy_data **psy_data, |
| ixheaace_temporal_noise_shaping_data **tns_data, |
| ixheaace_psy_configuration_long *pstr_psy_conf_long, |
| ixheaace_psy_configuration_short *pstr_psy_conf_short, |
| ixheaace_psy_out_channel **psy_out_ch, |
| ixheaace_psy_out_element *pstr_psy_out_element, FLOAT32 *ptr_scratch_tns, |
| FLOAT32 *ptr_shared_buffer1, WORD8 *ptr_shared_buffer5, ixheaace_aac_tables *pstr_aac_tables, |
| WORD32 frame_len_long) |
| |
| { |
| IA_ERRORCODE error_code = IA_NO_ERROR; |
| WORD32 grouped_sfb_offset[IXHEAACE_MAX_CH_IN_BS_ELE][MAXIMUM_GROUPED_SCALE_FACTOR_BAND + |
| 1]; /* plus one for last dummy offset ! */ |
| FLOAT32 grouped_sfb_min_snr[IXHEAACE_MAX_CH_IN_BS_ELE][MAXIMUM_GROUPED_SCALE_FACTOR_BAND]; |
| WORD32 max_sfb_per_grp[IXHEAACE_MAX_CH_IN_BS_ELE] = {0}; |
| WORD32 ch, sfb, line; |
| WORD32 num_channels = pstr_elem_info->n_channels_in_el; |
| |
| if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) { |
| if (pstr_elem_info->el_type != ID_LFE) { |
| for (ch = 0; ch < num_channels; ch++) { |
| iaace_block_switching(&psy_data[ch]->blk_switch_cntrl, |
| ptr_time_signal + pstr_elem_info->channel_index[ch], frame_len_long, |
| num_channels); |
| } |
| } else { |
| for (ch = 0; ch < num_channels; ch++) { |
| psy_data[ch]->blk_switch_cntrl.win_seq = LONG_WINDOW; |
| } |
| } |
| |
| /* synch left and right block type */ |
| if (num_channels == NUM_CHANS_MONO) { |
| iaace_sync_block_switching(&psy_data[0]->blk_switch_cntrl, NULL, num_channels); |
| } |
| else { |
| iaace_sync_block_switching(&psy_data[0]->blk_switch_cntrl, &psy_data[1]->blk_switch_cntrl, |
| num_channels); |
| } |
| } else if (aot == AOT_AAC_LD || aot == AOT_AAC_ELD) { |
| for (ch = 0; ch < num_channels; ch++) { |
| psy_data[ch]->blk_switch_cntrl.win_seq_ld = LONG_WINDOW; |
| psy_data[ch]->blk_switch_cntrl.next_win_seq_ld = LONG_WINDOW; |
| psy_data[ch]->blk_switch_cntrl.win_seq = LONG_WINDOW; |
| psy_data[ch]->blk_switch_cntrl.nxt_win_seq = LONG_WINDOW; |
| psy_data[ch]->blk_switch_cntrl.total_groups_cnt = 1; |
| } |
| } |
| /* transform */ |
| for (ch = 0; ch < num_channels; ch++) { |
| if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) { |
| ixheaace_transform_real_lc_ld( |
| psy_data[ch]->ptr_mdct_delay_buf, ptr_time_signal + pstr_elem_info->channel_index[ch], |
| time_sn_stride, psy_data[ch]->ptr_spec_coeffs, psy_data[ch]->blk_switch_cntrl.win_seq, |
| frame_len_long, ptr_shared_buffer5); |
| } else if (aot == AOT_AAC_LD) { |
| if (frame_len_long == FRAME_LEN_480) { |
| ia_enhaacplus_enc_transform_real( |
| psy_data[ch]->ptr_mdct_delay_buf, ptr_time_signal + pstr_elem_info->channel_index[ch], |
| time_sn_stride, psy_data[ch]->ptr_spec_coeffs, pstr_aac_tables->pstr_mdct_tab, |
| ptr_scratch_tns, ptr_shared_buffer5, frame_len_long); |
| } else { |
| ixheaace_transform_real_lc_ld( |
| psy_data[ch]->ptr_mdct_delay_buf, ptr_time_signal + pstr_elem_info->channel_index[ch], |
| time_sn_stride, psy_data[ch]->ptr_spec_coeffs, psy_data[ch]->blk_switch_cntrl.win_seq, |
| frame_len_long, ptr_shared_buffer5); |
| } |
| } else if (aot == AOT_AAC_ELD) { |
| if (frame_len_long == FRAME_LEN_480) { |
| ia_enhaacplus_enc_transform_real( |
| psy_data[ch]->ptr_mdct_delay_buf, ptr_time_signal + pstr_elem_info->channel_index[ch], |
| time_sn_stride, psy_data[ch]->ptr_spec_coeffs, pstr_aac_tables->pstr_mdct_tab, |
| ptr_scratch_tns, ptr_shared_buffer5, frame_len_long); |
| } else { |
| ia_enhaacplus_enc_transform_real_eld( |
| psy_data[ch]->ptr_mdct_delay_buf, ptr_time_signal + pstr_elem_info->channel_index[ch], |
| time_sn_stride, psy_data[ch]->ptr_spec_coeffs, ptr_shared_buffer5, frame_len_long); |
| } |
| } |
| } |
| |
| for (ch = 0; ch < num_channels; ch++) { |
| if (psy_data[ch]->blk_switch_cntrl.win_seq != SHORT_WINDOW) { |
| error_code = ia_enhaacplus_enc_advance_psy_long( |
| psy_data[ch], tns_data[ch], pstr_psy_conf_long, psy_out_ch[ch], ptr_scratch_tns, |
| tns_data[1 - ch], ch, aot, ptr_shared_buffer1, pstr_aac_tables, frame_len_long); |
| |
| if (error_code != IA_NO_ERROR) { |
| return error_code; |
| } |
| |
| for (sfb = pstr_psy_conf_long->sfb_cnt - 1; sfb >= 0; sfb--) { |
| for (line = pstr_psy_conf_long->sfb_offsets[sfb + 1] - 1; |
| line >= pstr_psy_conf_long->sfb_offsets[sfb]; line--) { |
| if (psy_data[ch]->ptr_spec_coeffs[line] != 0) { |
| break; |
| } |
| } |
| if (line >= pstr_psy_conf_long->sfb_offsets[sfb]) { |
| break; |
| } |
| } |
| |
| max_sfb_per_grp[ch] = sfb + 1; |
| |
| /* Calculate bandwise energies for mid and side channels - only if 2 channels exist */ |
| if (ch == 1) { |
| ia_enhaacplus_enc_advance_psy_long_ms(psy_data, pstr_psy_conf_long); |
| } |
| } else { |
| error_code = ia_enhaacplus_enc_advance_psy_short( |
| psy_data[ch], tns_data[ch], pstr_psy_conf_short, psy_out_ch[ch], ptr_scratch_tns, |
| tns_data[1 - ch], ch, aot, ptr_shared_buffer1, pstr_aac_tables, frame_len_long / 8); |
| |
| if (error_code != IA_NO_ERROR) { |
| return error_code; |
| } |
| |
| /* Calculate bandwise energies for mid and side channels - only if 2 channels exist */ |
| if (ch == 1) { |
| ia_enhaacplus_enc_advance_psy_short_ms(psy_data, pstr_psy_conf_short, frame_len_long); |
| } |
| } |
| } |
| |
| /* Group short data (max_sfb for short blocks is determined here) */ |
| if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) { |
| for (ch = 0; ch < num_channels; ch++) { |
| if (psy_data[ch]->blk_switch_cntrl.win_seq == SHORT_WINDOW) { |
| iaace_group_short_data(psy_data[ch]->ptr_spec_coeffs, ptr_scratch_tns, |
| &psy_data[ch]->sfb_threshold, &psy_data[ch]->sfb_energy, |
| &psy_data[ch]->sfb_energy_ms, &psy_data[ch]->sfb_sreaded_energy, |
| pstr_psy_conf_short->sfb_cnt, pstr_psy_conf_short->sfb_offsets, |
| pstr_psy_conf_short->sfb_min_snr, grouped_sfb_offset[ch], |
| &max_sfb_per_grp[ch], grouped_sfb_min_snr[ch], |
| psy_data[ch]->blk_switch_cntrl.total_groups_cnt, |
| psy_data[ch]->blk_switch_cntrl.group_len, frame_len_long); |
| } |
| } |
| } |
| |
| #if (IXHEAACE_MAX_CH_IN_BS_ELE > 1) |
| /* Stereo Processing */ |
| if (num_channels == 2) { |
| pstr_psy_out_element->tools_info.ms_digest = MS_NONE; |
| |
| max_sfb_per_grp[0] = max_sfb_per_grp[1] = MAX(max_sfb_per_grp[0], max_sfb_per_grp[1]); |
| |
| if (psy_data[0]->blk_switch_cntrl.win_seq != SHORT_WINDOW) { |
| iaace_ms_apply( |
| psy_data, psy_data[0]->ptr_spec_coeffs, psy_data[1]->ptr_spec_coeffs, |
| &pstr_psy_out_element->tools_info.ms_digest, pstr_psy_out_element->tools_info.ms_mask, |
| pstr_psy_conf_long->sfb_cnt, pstr_psy_conf_long->sfb_cnt, max_sfb_per_grp[0], |
| pstr_psy_conf_long->sfb_offsets, &pstr_psy_out_element->weight_ms_lr_pe_ratio); |
| } else { |
| iaace_ms_apply(psy_data, psy_data[0]->ptr_spec_coeffs, psy_data[1]->ptr_spec_coeffs, |
| &pstr_psy_out_element->tools_info.ms_digest, |
| pstr_psy_out_element->tools_info.ms_mask, |
| psy_data[0]->blk_switch_cntrl.total_groups_cnt * |
| pstr_psy_conf_short->sfb_cnt, |
| pstr_psy_conf_short->sfb_cnt, max_sfb_per_grp[0], grouped_sfb_offset[0], |
| &pstr_psy_out_element->weight_ms_lr_pe_ratio); |
| } |
| } |
| #endif |
| |
| /* Build output */ |
| if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) { |
| for (ch = 0; ch < num_channels; ch++) { |
| if (psy_data[ch]->blk_switch_cntrl.win_seq != SHORT_WINDOW) { |
| ia_enhaacplus_enc_build_interface( |
| psy_data[ch]->ptr_spec_coeffs, &psy_data[ch]->sfb_threshold, |
| &psy_data[ch]->sfb_energy, |
| &psy_data[ch]->sfb_sreaded_energy, psy_data[ch]->sfb_energy_sum, |
| psy_data[ch]->sfb_energy_sum_ms, psy_data[ch]->blk_switch_cntrl.win_seq, |
| ia_enhaacplus_enc_block_type_to_window_shape_lc[psy_data[ch] |
| ->blk_switch_cntrl.win_seq], |
| pstr_psy_conf_long->sfb_cnt, pstr_psy_conf_long->sfb_offsets, max_sfb_per_grp[ch], |
| pstr_psy_conf_long->sfb_min_snr, psy_data[ch]->blk_switch_cntrl.total_groups_cnt, |
| psy_data[ch]->blk_switch_cntrl.group_len, psy_out_ch[ch]); |
| } else { |
| ia_enhaacplus_enc_build_interface( |
| psy_data[ch]->ptr_spec_coeffs, &psy_data[ch]->sfb_threshold, |
| &psy_data[ch]->sfb_energy, |
| &psy_data[ch]->sfb_sreaded_energy, psy_data[ch]->sfb_energy_sum, |
| psy_data[ch]->sfb_energy_sum_ms, SHORT_WINDOW, SINE_WINDOW, |
| psy_data[ch]->blk_switch_cntrl.total_groups_cnt * pstr_psy_conf_short->sfb_cnt, |
| grouped_sfb_offset[ch], max_sfb_per_grp[ch], grouped_sfb_min_snr[ch], |
| psy_data[ch]->blk_switch_cntrl.total_groups_cnt, |
| psy_data[ch]->blk_switch_cntrl.group_len, psy_out_ch[ch]); |
| } |
| } |
| } else if (aot == AOT_AAC_LD || aot == AOT_AAC_ELD) { |
| for (ch = 0; ch < num_channels; ch++) { |
| ia_enhaacplus_enc_build_interface( |
| psy_data[ch]->ptr_spec_coeffs, &psy_data[ch]->sfb_threshold, &psy_data[ch]->sfb_energy, |
| &psy_data[ch]->sfb_sreaded_energy, psy_data[ch]->sfb_energy_sum, |
| psy_data[ch]->sfb_energy_sum_ms, LONG_WINDOW, |
| ia_enhaacplus_enc_block_type_to_window_shape_ld[psy_data[ch] |
| ->blk_switch_cntrl.win_seq_ld], |
| ((aot == AOT_AAC_ELD) ? pstr_psy_conf_long->sfb_active : pstr_psy_conf_long->sfb_cnt), |
| pstr_psy_conf_long->sfb_offsets, max_sfb_per_grp[ch], pstr_psy_conf_long->sfb_min_snr, |
| psy_data[ch]->blk_switch_cntrl.total_groups_cnt, |
| psy_data[ch]->blk_switch_cntrl.group_len, psy_out_ch[ch]); |
| } |
| } |
| return error_code; |
| } |
