wrapper/libxaac
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libxaac/encoder/ixheaace_psy_mod.c
akshayragir833 1ce177ea0e
Encoder enhancements and minor bug fixes (#73) 
Test done: Smoke test
2023-12-28 17:47:33 +05:30

671 lines
29 KiB
C
Raw Permalink Blame History

/******************************************************************************
* *
* 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;
}
Reference in a new issue View git blame Copy permalink