| /****************************************************************************** |
| * * |
| * Copyright (C) 2018 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 "ixheaac_type_def.h" |
| #include "ixheaac_constants.h" |
| #include "ixheaacd_bitbuffer.h" |
| #include "ixheaacd_common_rom.h" |
| #include "ixheaacd_sbrdecsettings.h" |
| #include "ixheaacd_sbr_scale.h" |
| #include "ixheaacd_env_extr_part.h" |
| #include "ixheaacd_sbr_rom.h" |
| #include "ixheaacd_config.h" |
| #include "ixheaacd_hybrid.h" |
| #include "ixheaacd_ps_dec.h" |
| #include "ixheaacd_qmf_dec.h" |
| #include "ixheaacd_mps_polyphase.h" |
| #include "ixheaacd_mps_struct_def.h" |
| #include "ixheaacd_mps_res_rom.h" |
| #include "ixheaacd_mps_aac_struct.h" |
| #include "ixheaacd_mps_dec.h" |
| #include "ixheaacd_mps_process.h" |
| #include "ixheaacd_lpp_tran.h" |
| #include "ixheaacd_env_extr.h" |
| #include "ixheaacd_env_calc.h" |
| #include "ixheaac_sbr_const.h" |
| #include "ixheaacd_pvc_dec.h" |
| #include "ixheaacd_sbr_dec.h" |
| #include "ixheaacd_audioobjtypes.h" |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops40.h" |
| #include "ixheaacd_mps_bitdec.h" |
| #include "ixheaacd_mps_macro_def.h" |
| #include "ixheaacd_mps_get_index.h" |
| #include "ixheaacd_mps_basic_op.h" |
| #include "ixheaacd_mps_tp_process.h" |
| #include "ixheaacd_error_codes.h" |
| #define HP_SIZE (9) |
| |
| #define STP_LPF_COEFF1 (0.950f) |
| #define STP_LPF_COEFF2 (0.450f) |
| #define STP_UPDATE_ENERGY_RATE (32) |
| #define STP_SCALE_LIMIT (2.82f) |
| #define STP_DAMP (0.1f) |
| |
| static const FLOAT32 ixheaacd_bp[BP_SIZE] = { |
| 0.0000f, 0.0005f, 0.0092f, 0.0587f, 0.2580f, 0.7392f, 0.9791f, |
| 0.9993f, 1.0000f, 1.0000f, 1.0000f, 1.0000f, 0.9999f, 0.9984f, |
| 0.9908f, 0.9639f, 0.8952f, 0.7711f, 0.6127f, 0.4609f, 0.3391f, |
| 0.2493f, 0.1848f, 0.1387f, 0.1053f}; |
| |
| static const FLOAT32 ixheaacd_gf[BP_SIZE] = { |
| 0.f, 0.f, 0.f, 0.f, 0.f, |
| 0.f, 1e-008f, 8.1e-007f, 3.61e-006f, 8.41e-006f, |
| 1.6e-005f, 2.704e-005f, 3.969e-005f, 5.625e-005f, 7.396e-005f, |
| 9.801e-005f, 0.00012321f, 0.00015625f, 0.00019881f, 0.00024964f, |
| 0.00032041f, 0.00041209f, 0.00053824f, 0.00070756f, 0.00094249f}; |
| |
| extern const WORD32 ixheaacd_mps_gain_set_indx[29]; |
| |
| static VOID ixheaacd_mps_temp_process_scale_calc(ia_mps_dec_state_struct* self, |
| WORD32 ts, FLOAT32* scale) { |
| FLOAT32 dir_energy; |
| FLOAT32 diff_energy[2]; |
| FLOAT32 temp; |
| |
| WORD32 ch, n; |
| WORD32 left_ch = 0, right_ch = 1; |
| |
| if (self->subband_var.init_flag == 0) { |
| for (ch = 0; ch < 2; ch++) { |
| self->subband_var.tp_scale_last[ch] = 1.0f; |
| self->subband_var.nrg_diff_prev[ch] = 32768 * 32768; |
| } |
| |
| self->subband_var.nrg_dir_prev = 32768 * 32768; |
| self->subband_var.init_flag = 1; |
| } |
| |
| if (self->subband_var.update_old_ener == STP_UPDATE_ENERGY_RATE) { |
| self->subband_var.update_old_ener = 1; |
| self->subband_var.nrg_dir_prev = self->subband_var.nrg_dir; |
| for (ch = 0; ch < self->out_ch_count; ch++) |
| self->subband_var.nrg_diff_prev[ch] = self->subband_var.nrg_diff[ch]; |
| } else |
| self->subband_var.update_old_ener++; |
| |
| dir_energy = 0; |
| |
| for (n = 6; n < BP_SIZE; n++) { |
| FLOAT32 dir_left_re = self->hyb_dir_out[left_ch][ts][n + 7].re; |
| FLOAT32 dir_right_re = self->hyb_dir_out[right_ch][ts][n + 7].re; |
| FLOAT32 dir_left_im = self->hyb_dir_out[left_ch][ts][n + 7].im; |
| FLOAT32 dir_right_im = self->hyb_dir_out[right_ch][ts][n + 7].im; |
| |
| temp = ((dir_left_re + dir_right_re) * (dir_left_re + dir_right_re)) + |
| ((dir_left_im + dir_right_im) * (dir_left_im + dir_right_im)); |
| dir_energy += temp * ixheaacd_bp[n] * ixheaacd_bp[n] * ixheaacd_gf[n] * |
| ixheaacd_gf[n]; |
| } |
| |
| self->subband_var.nrg_dir = |
| (FLOAT32)(STP_LPF_COEFF1 * self->subband_var.nrg_dir + |
| (1.0 - STP_LPF_COEFF1) * dir_energy); |
| |
| dir_energy /= (self->subband_var.nrg_dir_prev + ABS_THR); |
| |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| diff_energy[ch] = 0; |
| for (n = 6; n < BP_SIZE; n++) { |
| FLOAT32 diff_re = self->hyb_diff_out[ch][ts][n + 7].re; |
| FLOAT32 diff_im = self->hyb_diff_out[ch][ts][n + 7].im; |
| |
| temp = (diff_re * diff_re) + (diff_im * diff_im); |
| diff_energy[ch] += temp * ixheaacd_bp[n] * ixheaacd_bp[n] * |
| ixheaacd_gf[n] * ixheaacd_gf[n]; |
| } |
| |
| self->subband_var.nrg_diff[ch] = |
| (FLOAT32)(STP_LPF_COEFF1 * self->subband_var.nrg_diff[ch] + |
| (1.0 - STP_LPF_COEFF1) * diff_energy[ch]); |
| diff_energy[ch] /= (self->subband_var.nrg_diff_prev[ch] + ABS_THR); |
| } |
| |
| scale[left_ch] = (FLOAT32)sqrt((dir_energy) / (diff_energy[left_ch] + 1e-9)); |
| scale[right_ch] = |
| (FLOAT32)sqrt((dir_energy) / (diff_energy[right_ch] + 1e-9)); |
| |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| scale[ch] = STP_DAMP + (1 - STP_DAMP) * scale[ch]; |
| } |
| |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| scale[ch] = |
| min(max(scale[ch], (FLOAT32)(1.0 / STP_SCALE_LIMIT)), STP_SCALE_LIMIT); |
| } |
| |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| scale[ch] = |
| (FLOAT32)(STP_LPF_COEFF2 * scale[ch] + |
| (1.0 - STP_LPF_COEFF2) * self->subband_var.tp_scale_last[ch]); |
| self->subband_var.tp_scale_last[ch] = scale[ch]; |
| } |
| } |
| |
| static VOID ixheaacd_mps_subbandtp(ia_mps_dec_state_struct* self, WORD32 ts) { |
| FLOAT32 scale[2]; |
| WORD32 ch, n; |
| WORD32 no_scaling; |
| FLOAT32 temp; |
| const WORD32 ixheaacd_hybrid_to_qmf_map[] = {0, 0, 0, 0, 0, 0, 1, 1, 2, 2}; |
| const WORD32 ixheaacd_hybrid_to_qmf_map_ldmps[] = {0, 1, 2}; |
| const WORD32* ptr_ixheaacd_hybrid_to_qmf_map; |
| WORD32 loop_counter = 0; |
| |
| if (self->ldmps_config.ldmps_present_flag) { |
| ptr_ixheaacd_hybrid_to_qmf_map = ixheaacd_hybrid_to_qmf_map_ldmps; |
| loop_counter = 3; |
| } else { |
| ptr_ixheaacd_hybrid_to_qmf_map = ixheaacd_hybrid_to_qmf_map; |
| loop_counter = 10; |
| } |
| |
| ixheaacd_mps_temp_process_scale_calc(self, ts, scale); |
| |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| no_scaling = 1; |
| |
| if ((self->config->bs_temp_shape_config == 1) || |
| (self->config->bs_temp_shape_config == 2)) |
| no_scaling = !self->temp_shape_enable_ch_stp[ch]; |
| |
| if (no_scaling == 1) { |
| for (n = 0; n < self->hyb_band_count_max; n++) { |
| self->hyb_dir_out[ch][ts][n].re += self->hyb_diff_out[ch][ts][n].re; |
| self->hyb_dir_out[ch][ts][n].im += self->hyb_diff_out[ch][ts][n].im; |
| } |
| } else { |
| if (self->ldmps_config.ldmps_present_flag) { |
| for (n = 0; n < 3; n++) { |
| temp = (FLOAT32)(scale[ch] * |
| ixheaacd_bp[ptr_ixheaacd_hybrid_to_qmf_map[n]]); |
| self->hyb_dir_out[ch][ts][n].re += |
| (self->hyb_diff_out[ch][ts][n].re * temp); |
| self->hyb_dir_out[ch][ts][n].im += |
| (self->hyb_diff_out[ch][ts][n].im * temp); |
| } |
| } else { |
| for (n = 0; n < loop_counter; n++) { |
| temp = (FLOAT32)(scale[ch] * |
| ixheaacd_bp[ptr_ixheaacd_hybrid_to_qmf_map[n]]); |
| self->hyb_dir_out[ch][ts][n].re += |
| (self->hyb_diff_out[ch][ts][n].re * temp); |
| self->hyb_dir_out[ch][ts][n].im += |
| (self->hyb_diff_out[ch][ts][n].im * temp); |
| } |
| } |
| for (n = 7; n < HP_SIZE - 3 + 10; n++) { |
| temp = (FLOAT32)(scale[ch] * ixheaacd_bp[n + 3 - 10]); |
| self->hyb_dir_out[ch][ts][n].re += |
| (self->hyb_diff_out[ch][ts][n].re * temp); |
| self->hyb_dir_out[ch][ts][n].im += |
| (self->hyb_diff_out[ch][ts][n].im * temp); |
| } |
| for (; n < self->hyb_band_count_max; n++) { |
| temp = (FLOAT32)(scale[ch]); |
| self->hyb_dir_out[ch][ts][n].re += |
| (self->hyb_diff_out[ch][ts][n].re * temp); |
| self->hyb_dir_out[ch][ts][n].im += |
| (self->hyb_diff_out[ch][ts][n].im * temp); |
| } |
| } |
| } |
| } |
| |
| WORD32 ixheaacd_mps_temp_process(ia_mps_dec_state_struct* self) { |
| WORD32 ch, ts, hyb; |
| WORD32 err = 0; |
| ia_sbr_frame_info_data_struct* ptr_frame_data = |
| (ia_sbr_frame_info_data_struct*)self->p_sbr_frame[0]; |
| if (self->res_bands != 28) { |
| if (self->config->bs_temp_shape_config == 1) { |
| WORD32 dif_s = ((self->res_bands == 0) |
| ? 0 |
| : ixheaacd_mps_gain_set_indx[self->res_bands]); |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| for (ts = 0; ts < self->time_slots; ts++) { |
| for (hyb = dif_s; hyb < HYBRID_BAND_BORDER; hyb++) { |
| self->hyb_dir_out[ch][ts][hyb].re += |
| self->hyb_diff_out[ch][ts][hyb].re; |
| self->hyb_dir_out[ch][ts][hyb].im += |
| self->hyb_diff_out[ch][ts][hyb].im; |
| self->hyb_diff_out[ch][ts][hyb].re = 0; |
| self->hyb_diff_out[ch][ts][hyb].im = 0; |
| } |
| } |
| } |
| |
| for (ts = 0; ts < self->time_slots; ts++) |
| ixheaacd_mps_subbandtp(self, ts); |
| |
| } else { |
| WORD32 dif_s = ((self->res_bands == 0) |
| ? 0 |
| : ixheaacd_mps_gain_set_indx[self->res_bands]); |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| for (ts = 0; ts < self->time_slots; ts++) { |
| for (hyb = dif_s; hyb < self->hyb_band_count_max; hyb++) { |
| self->hyb_dir_out[ch][ts][hyb].re += |
| self->hyb_diff_out[ch][ts][hyb].re; |
| self->hyb_dir_out[ch][ts][hyb].im += |
| self->hyb_diff_out[ch][ts][hyb].im; |
| } |
| } |
| } |
| } |
| } |
| |
| ixheaacd_mps_qmf_hyb_synthesis(self); |
| |
| if (self->ldmps_config.ldmps_present_flag != 1) { |
| for (ch = 0; ch < self->out_ch_count; ch++) { |
| err = |
| ixheaacd_sbr_dec_from_mps(&self->qmf_out_dir[ch][0][0].re, self->p_sbr_dec[ch], |
| self->p_sbr_frame[ch], self->p_sbr_header[ch], self->ec_flag); |
| if (err) return err; |
| } |
| } |
| |
| if (self->object_type == AOT_ER_AAC_ELD || self->object_type == AOT_ER_AAC_LD) |
| self->synth_count = self->hyb_band_count[0]; |
| else |
| { |
| if (ptr_frame_data->mps_sbr_flag) { |
| self->synth_count = |
| ptr_frame_data->pstr_sbr_header->pstr_freq_band_data->sub_band_end; |
| } |
| else { |
| self->synth_count = self->band_count[0]; |
| } |
| } |
| |
| ixheaacd_mps_synt_calc(self); |
| return err; |
| } |
| |
| static VOID ixheaacd_subband_tp(ia_heaac_mps_state_struct *pstr_mps_state, WORD32 ts) { |
| ia_mps_dec_tp_process_tables_struct *tp_process_table_ptr = |
| pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr; |
| const WORD32 *sqrt_tab = |
| pstr_mps_state->ia_mps_dec_mps_table.common_table_ptr->sqrt_tab; |
| ia_mps_dec_subband_tp_params_struct *sub_band_tp = |
| pstr_mps_state->mps_persistent_mem.sub_band_params; |
| ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct; |
| |
| WORD32 temp_1, temp_2; |
| WORD16 qtemp1, qtemp2; |
| WORD32 *qmf_output_real_dry; |
| WORD32 *qmf_output_imag_dry; |
| WORD32 *qmf_output_real_wet; |
| WORD32 *qmf_output_imag_wet; |
| |
| WORD32 *dmx_real; |
| WORD32 *dmx_imag; |
| WORD32 *dry_ener; |
| WORD32 *wet_ener; |
| WORD16 *q_dry_ener; |
| WORD16 *q_wet_ener; |
| |
| WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im; |
| WORD32 *p_buf_real, *p_buf_imag, *p_buf_re, *p_buf_im; |
| WORD32 *scale; |
| WORD16 *q_scale; |
| WORD32 damp, one_minus_damp; |
| WORD32 temp; |
| |
| WORD32 *prev_tp_scale = sub_band_tp->prev_tp_scale; |
| |
| WORD32 *old_wet_ener = sub_band_tp->old_wet_ener; |
| WORD16 *q_old_wet_ener = sub_band_tp->q_old_wet_ener; |
| |
| WORD32 *run_wet_ener = sub_band_tp->run_wet_ener; |
| WORD16 *q_run_wet_ener = sub_band_tp->q_run_wet_ener; |
| |
| WORD32 *old_dry_ener = sub_band_tp->old_dry_ener; |
| WORD16 *q_old_dry_ener = sub_band_tp->q_old_dry_ener; |
| |
| WORD32 *run_dry_ener = sub_band_tp->run_dry_ener; |
| WORD16 *q_run_dry_ener = sub_band_tp->q_run_dry_ener; |
| |
| WORD32 *hyb_output_real_dry, *hyb_output_imag_dry; |
| |
| WORD32 *p_hyb_out_dry_real, *p_hyb_out_dry_imag; |
| |
| WORD32 ch, n, no_scaling, i, k = 0, offset; |
| WORD32 i_lf = 0, i_rf = 0, i_c = 0, i_lfe = 0, i_ls = 0, i_rs = 0, i_al = 0, i_ar = 0; |
| |
| WORD32 loop_counter = 0; |
| |
| WORD32 num_input_channels = pstr_mps_state->num_input_channels; |
| WORD32 num_output_channels = pstr_mps_state->num_output_channels; |
| WORD32 hybrid_bands = pstr_mps_state->hybrid_bands; |
| |
| WORD32 tree_config = pstr_mps_state->tree_config; |
| |
| dry_ener = pstr_mps_state->mps_scratch_mem_v; |
| q_dry_ener = (WORD16 *)pstr_mps_state->mps_scratch_mem_v + |
| IXHEAAC_GET_SIZE_ALIGNED_TYPE(INPUT_CHX2, sizeof(*q_dry_ener), BYTE_ALIGN_8); |
| |
| wet_ener = |
| dry_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(INPUT_CHX1_5, sizeof(*wet_ener), BYTE_ALIGN_8); |
| q_wet_ener = q_dry_ener + |
| IXHEAAC_GET_SIZE_ALIGNED_TYPE(IN_CH_2XOUT_CH, sizeof(*q_wet_ener), BYTE_ALIGN_8); |
| |
| scale = wet_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX1_5, sizeof(*scale), BYTE_ALIGN_8); |
| q_scale = |
| q_wet_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX3, sizeof(*q_scale), BYTE_ALIGN_8); |
| |
| dmx_real = |
| scale + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX1_5, sizeof(*dmx_real), BYTE_ALIGN_8); |
| dmx_imag = |
| dmx_real + IXHEAAC_GET_SIZE_ALIGNED_TYPE(IN_CHXBP_SIZE, sizeof(*dmx_imag), BYTE_ALIGN_8); |
| |
| qmf_output_real_dry = dmx_imag + IXHEAAC_GET_SIZE_ALIGNED_TYPE( |
| IN_CHXBP_SIZE, sizeof(*qmf_output_real_dry), BYTE_ALIGN_8); |
| |
| qmf_output_imag_dry = |
| qmf_output_real_dry + |
| IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_imag_dry), BYTE_ALIGN_8); |
| |
| qmf_output_real_wet = |
| qmf_output_imag_dry + |
| IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_real_wet), BYTE_ALIGN_8); |
| |
| qmf_output_imag_wet = |
| qmf_output_real_wet + |
| IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_imag_wet), BYTE_ALIGN_8); |
| |
| if (sub_band_tp->update_old_ener == STP_UPDATE_ENERGY_RATE) { |
| sub_band_tp->update_old_ener = 1; |
| for (ch = 0; ch < num_input_channels; ch++) { |
| old_dry_ener[ch] = run_dry_ener[ch]; |
| q_old_dry_ener[ch] = q_run_dry_ener[ch]; |
| } |
| for (ch = 0; ch < num_output_channels; ch++) { |
| old_wet_ener[ch] = run_wet_ener[ch]; |
| q_old_wet_ener[ch] = q_run_wet_ener[ch]; |
| } |
| } else |
| sub_band_tp->update_old_ener++; |
| |
| for (ch = 0; ch < MAX_OUTPUT_CHANNELS_MPS; ch++) { |
| scale[ch] = ONE_IN_Q15; |
| q_scale[ch] = 15; |
| } |
| |
| switch (tree_config) { |
| case TREE_5151: |
| i_lf = 0; |
| i_rf = 1; |
| i_c = 2; |
| i_lfe = 3; |
| i_ls = 4; |
| i_rs = 5; |
| loop_counter = 6; |
| break; |
| case TREE_5152: |
| i_lf = 0; |
| i_rf = 2; |
| i_c = 4; |
| i_lfe = 5; |
| i_ls = 1; |
| i_rs = 3; |
| loop_counter = 5; |
| break; |
| case TREE_525: |
| i_lf = 0; |
| i_rf = 2; |
| i_c = 4; |
| i_lfe = 5; |
| i_ls = 1; |
| i_rs = 3; |
| loop_counter = 4; |
| break; |
| case TREE_7271: |
| case TREE_7272: |
| case TREE_7572: |
| i_lf = 0; |
| i_rf = 3; |
| i_c = 6; |
| i_lfe = 7; |
| i_ls = 2; |
| i_rs = 5; |
| i_al = 1; |
| i_ar = 4; |
| loop_counter = 6; |
| break; |
| case TREE_7571: |
| i_lf = 0; |
| i_rf = 3; |
| i_c = 6; |
| i_lfe = 7; |
| i_ls = 2; |
| i_rs = 5; |
| i_al = 1; |
| i_ar = 4; |
| loop_counter = 5; |
| break; |
| default: |
| break; |
| } |
| |
| offset = ts * MAX_HYBRID_BANDS; |
| p_buffer_real = p_array_struct->buf_real + offset + HYBRID_BAND_BORDER; |
| p_buffer_imag = p_array_struct->buf_imag + offset + HYBRID_BAND_BORDER; |
| |
| for (ch = 0; ch < num_output_channels; ch++) { |
| p_buffer_re = p_buffer_real; |
| p_buffer_im = p_buffer_imag; |
| |
| for (i = QMF_OUT_START_IDX; i < BP_SIZE; i++) { |
| *qmf_output_real_wet++ = *p_buffer_re++; |
| *qmf_output_imag_wet++ = *p_buffer_im++; |
| } |
| p_buffer_real += TSXHB; |
| p_buffer_imag += TSXHB; |
| } |
| i = QMF_OUT_OFFSET * num_output_channels; |
| qmf_output_real_wet -= i; |
| qmf_output_imag_wet -= i; |
| |
| p_buffer_re = qmf_output_real_dry; |
| p_buffer_im = qmf_output_imag_dry; |
| |
| hyb_output_real_dry = |
| p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 6; |
| hyb_output_imag_dry = |
| p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 6; |
| |
| for (ch = 0; ch < loop_counter; ch++) { |
| *p_buffer_re++ = hyb_output_real_dry[0] + hyb_output_real_dry[1]; |
| *p_buffer_im++ = hyb_output_imag_dry[0] + hyb_output_imag_dry[1]; |
| |
| hyb_output_real_dry += TSXHB; |
| hyb_output_imag_dry += TSXHB; |
| } |
| |
| hyb_output_real_dry = |
| p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 8; |
| hyb_output_imag_dry = |
| p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 8; |
| |
| for (ch = 0; ch < loop_counter; ch++) { |
| *p_buffer_re++ = hyb_output_real_dry[0] + hyb_output_real_dry[1]; |
| *p_buffer_im++ = hyb_output_imag_dry[0] + hyb_output_imag_dry[1]; |
| |
| hyb_output_real_dry += TSXHB; |
| hyb_output_imag_dry += TSXHB; |
| } |
| |
| p_hyb_out_dry_real = |
| p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 10; |
| p_hyb_out_dry_imag = |
| p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 10; |
| |
| for (i = 3; i < BP_SIZE; i++) { |
| hyb_output_real_dry = p_hyb_out_dry_real; |
| hyb_output_imag_dry = p_hyb_out_dry_imag; |
| |
| for (ch = 0; ch < loop_counter; ch++) { |
| *p_buffer_re++ = *hyb_output_real_dry; |
| *p_buffer_im++ = *hyb_output_imag_dry; |
| |
| hyb_output_real_dry += TSXHB; |
| hyb_output_imag_dry += TSXHB; |
| } |
| p_hyb_out_dry_real++; |
| p_hyb_out_dry_imag++; |
| } |
| |
| for (n = 1; n < BP_SIZE; n++) { |
| switch (tree_config) { |
| case TREE_5151: |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| dmx_real++; |
| |
| break; |
| case TREE_5152: |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| dmx_real++; |
| |
| break; |
| case TREE_525: |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| break; |
| case TREE_7271: |
| case TREE_7272: |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| break; |
| case TREE_7571: |
| |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| break; |
| case TREE_7572: |
| qmf_output_real_dry++; |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| qmf_output_real_dry++; |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| *dmx_real = *qmf_output_real_dry++; |
| *dmx_real += *qmf_output_real_dry++; |
| |
| *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_real++; |
| |
| break; |
| default: |
| break; |
| } |
| } |
| dmx_real -= DMX_OFFSET; |
| |
| for (n = 1; n < BP_SIZE; n++) { |
| switch (tree_config) { |
| case TREE_5151: |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| |
| qmf_output_imag_dry++; |
| |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag++ += *qmf_output_imag_dry++; |
| |
| dmx_imag++; |
| |
| dmx_imag[0] = ixheaacd_mps_mult32_shr_30( |
| dmx_imag[0], tp_process_table_ptr->bpxgf[n]); |
| break; |
| case TREE_5152: |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag++ += *qmf_output_imag_dry++; |
| |
| dmx_imag++; |
| |
| dmx_imag[0] = ixheaacd_mps_mult32_shr_30( |
| dmx_imag[0], tp_process_table_ptr->bpxgf[n]); |
| break; |
| case TREE_525: |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(dmx_imag[0], |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| break; |
| case TREE_7271: |
| case TREE_7272: |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| break; |
| case TREE_7571: |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| break; |
| case TREE_7572: |
| qmf_output_imag_dry++; |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| |
| qmf_output_imag_dry++; |
| |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| *dmx_imag = *qmf_output_imag_dry++; |
| *dmx_imag += *qmf_output_imag_dry++; |
| *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag, |
| tp_process_table_ptr->bpxgf[n]); |
| dmx_imag++; |
| |
| break; |
| default: |
| break; |
| } |
| } |
| dmx_imag -= DMX_OFFSET; |
| |
| for (ch = 0; ch < min(2, num_input_channels); ch++) { |
| dry_ener[ch] = 0; |
| q_dry_ener[ch] = 15; |
| |
| for (n = 1; n < BP_SIZE; n++) { |
| qtemp1 = 10; |
| temp_1 = ixheaacd_mps_mult32(*dmx_real, *dmx_real, &qtemp1, qtemp1); |
| dmx_real += 2; |
| dry_ener[ch] = |
| ixheaacd_mps_add32(dry_ener[ch], temp_1, &q_dry_ener[ch], qtemp1); |
| |
| qtemp1 = 10; |
| temp_1 = ixheaacd_mps_mult32(*dmx_imag, *dmx_imag, &qtemp1, qtemp1); |
| dmx_imag += 2; |
| dry_ener[ch] = |
| ixheaacd_mps_add32(dry_ener[ch], temp_1, &q_dry_ener[ch], qtemp1); |
| } |
| dmx_real -= DMX_OFFSET_MINUS_ONE; |
| dmx_imag -= DMX_OFFSET_MINUS_ONE; |
| |
| temp_1 = ixheaacd_mps_mult32_shr_15(run_dry_ener[ch], STP_LPF_COEFF1_FIX); |
| |
| temp_2 = ONE_IN_Q15 - STP_LPF_COEFF1_FIX; |
| temp_2 = ixheaacd_mps_mult32_shr_15(temp_2, dry_ener[ch]); |
| |
| run_dry_ener[ch] = ixheaacd_mps_add32(temp_1, temp_2, &(q_run_dry_ener[ch]), |
| q_dry_ener[ch]); |
| |
| qtemp1 = q_old_dry_ener[ch]; |
| temp_1 = ixheaacd_mps_add32(old_dry_ener[ch], ABS_THR_FIX, &qtemp1, 15); |
| ; |
| |
| dry_ener[ch] = ixheaacd_mps_div_32(dry_ener[ch], temp_1, &qtemp2); |
| q_dry_ener[ch] = qtemp2 + q_dry_ener[ch] - qtemp1; |
| } |
| |
| for (ch = 0; ch < num_output_channels; ch++) { |
| if (ch == i_lfe) continue; |
| if ((tree_config >= TREE_525) && (ch == i_c)) continue; |
| if ((tree_config == TREE_7571) && ((ch == i_ls) || (ch == i_rs))) continue; |
| if ((tree_config == TREE_7572) && ((ch == i_lf) || (ch == i_rf))) continue; |
| |
| wet_ener[ch] = 0; |
| q_wet_ener[ch] = 15; |
| |
| wet_ener[ch] = 0; |
| q_wet_ener[ch] = 15; |
| for (n = FIVE; n < BP_SIZE; n++) { |
| qtemp1 = 10; |
| temp_1 = ixheaacd_mps_mult32(*qmf_output_real_wet, *qmf_output_real_wet, |
| &qtemp1, qtemp1); |
| qmf_output_real_wet++; |
| |
| qtemp2 = 10; |
| temp_2 = ixheaacd_mps_mult32(*qmf_output_imag_wet, *qmf_output_imag_wet, |
| &qtemp2, qtemp2); |
| qmf_output_imag_wet++; |
| |
| temp_1 = ixheaacd_mps_add32(temp_1, temp_2, &qtemp1, qtemp2); |
| |
| temp_1 = ixheaacd_mps_mult32(temp_1, tp_process_table_ptr->bp2xgf2[n], |
| &qtemp1, 57); |
| |
| wet_ener[ch] = |
| ixheaacd_mps_add32(wet_ener[ch], temp_1, &q_wet_ener[ch], qtemp1); |
| } |
| temp_1 = ixheaacd_mps_mult32_shr_15(run_wet_ener[ch], STP_LPF_COEFF1_FIX); |
| |
| temp_2 = ONE_IN_Q15 - STP_LPF_COEFF1_FIX; |
| |
| temp_2 = ixheaacd_mps_mult32_shr_15(temp_2, wet_ener[ch]); |
| |
| run_wet_ener[ch] = |
| ixheaacd_mps_add32(temp_1, temp_2, &q_run_wet_ener[ch], q_wet_ener[ch]); |
| |
| qtemp1 = q_old_wet_ener[ch]; |
| temp_1 = ixheaacd_mps_add32(old_wet_ener[ch], ABS_THR_FIX, &qtemp1, 15); |
| |
| wet_ener[ch] = ixheaacd_mps_div_32(wet_ener[ch], temp_1, &qtemp2); |
| q_wet_ener[ch] = qtemp2 + q_wet_ener[ch] - qtemp1; |
| } |
| |
| damp = POINT_ONE_Q15; |
| one_minus_damp = POINT_NINE_Q15; |
| switch (tree_config) { |
| case TREE_5151: |
| case TREE_5152: |
| if (wet_ener[i_lf] != 0) { |
| scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2); |
| q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_lf] = dry_ener[0] << temp_1; |
| q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab); |
| |
| if (wet_ener[i_rf] != 0) { |
| scale[i_rf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_rf], &qtemp2); |
| q_scale[i_rf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_rf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_rf] = dry_ener[0] << temp_1; |
| q_scale[i_rf] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab); |
| |
| if (wet_ener[i_c] != 0) { |
| scale[i_c] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_c], &qtemp2); |
| q_scale[i_c] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_c]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_c] = dry_ener[0] << temp_1; |
| q_scale[i_c] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_c] = ixheaacd_mps_sqrt(scale[i_c], &(q_scale[i_c]), sqrt_tab); |
| |
| if (wet_ener[i_ls] != 0) { |
| scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2); |
| q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_ls] = dry_ener[0] << temp_1; |
| q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab); |
| |
| if (wet_ener[i_rs] != 0) { |
| scale[i_rs] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_rs], &qtemp2); |
| q_scale[i_rs] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_rs]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_rs] = dry_ener[0] << temp_1; |
| q_scale[i_rs] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab); |
| |
| for (ch = 0; ch < 6; ch++) { |
| if (ch == 3 && tree_config == 0) continue; |
| temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp); |
| scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15); |
| scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15); |
| if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX; |
| if (scale[ch] < ONE_BY_STP_SCALE_LIMIT) |
| scale[ch] = ONE_BY_STP_SCALE_LIMIT; |
| } |
| |
| break; |
| case TREE_525: |
| if (wet_ener[i_lf] != 0) { |
| scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2); |
| q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_lf] = dry_ener[0] << temp_1; |
| q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab); |
| |
| if (wet_ener[i_rf] != 0) { |
| scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2); |
| q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rf] = dry_ener[1] << temp_1; |
| q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab); |
| |
| if (wet_ener[i_ls] != 0) { |
| scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2); |
| q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_ls] = dry_ener[0] << temp_1; |
| q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab); |
| |
| if (wet_ener[i_rs] != 0) { |
| scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2); |
| q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rs] = dry_ener[1] << temp_1; |
| q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab); |
| |
| for (ch = 0; ch < 4; ch++) { |
| temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp); |
| scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15); |
| scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15); |
| if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX; |
| if (scale[ch] < ONE_BY_STP_SCALE_LIMIT) |
| scale[ch] = ONE_BY_STP_SCALE_LIMIT; |
| } |
| break; |
| case TREE_7271: |
| case TREE_7272: |
| if (wet_ener[i_lf] != 0) { |
| scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2); |
| q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_lf] = dry_ener[0] << temp_1; |
| q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab); |
| |
| if (wet_ener[i_rf] != 0) { |
| scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2); |
| q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rf] = dry_ener[1] << temp_1; |
| q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab); |
| |
| if (wet_ener[i_ls] != 0) { |
| scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2); |
| q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_ls] = dry_ener[0] << temp_1; |
| q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab); |
| |
| if (wet_ener[i_rs] != 0) { |
| scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2); |
| q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rs] = dry_ener[1] << temp_1; |
| q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab); |
| |
| if (wet_ener[i_al] != 0) { |
| scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2); |
| q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_al] = dry_ener[0] << temp_1; |
| q_scale[i_al] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab); |
| |
| if (wet_ener[i_ar] != 0) { |
| scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2); |
| q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_ar] = dry_ener[1] << temp_1; |
| q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab); |
| |
| for (ch = 0; ch < 6; ch++) { |
| temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp); |
| scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15); |
| scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15); |
| if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX; |
| if (scale[ch] < ONE_BY_STP_SCALE_LIMIT) |
| scale[ch] = ONE_BY_STP_SCALE_LIMIT; |
| } |
| |
| break; |
| case TREE_7571: |
| if (wet_ener[i_lf] != 0) { |
| scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2); |
| q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_lf] = dry_ener[0] << temp_1; |
| q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab); |
| |
| if (wet_ener[i_rf] != 0) { |
| scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2); |
| q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rf] = dry_ener[1] << temp_1; |
| q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab); |
| |
| if (wet_ener[i_al] != 0) { |
| scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2); |
| q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_al] = dry_ener[0] << temp_1; |
| q_scale[i_al] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab); |
| |
| if (wet_ener[i_ar] != 0) { |
| scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2); |
| q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_ar] = dry_ener[1] << temp_1; |
| q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab); |
| for (ch = 0; ch < FIVE; ch++) { |
| if (ch == 2) continue; |
| temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp); |
| scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15); |
| scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15); |
| if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX; |
| if (scale[ch] < ONE_BY_STP_SCALE_LIMIT) |
| scale[ch] = ONE_BY_STP_SCALE_LIMIT; |
| } |
| |
| break; |
| case TREE_7572: |
| if (wet_ener[i_ls] != 0) { |
| scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2); |
| q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_ls] = dry_ener[0] << temp_1; |
| q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab); |
| |
| if (wet_ener[i_rs] != 0) { |
| scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2); |
| q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_rs] = dry_ener[1] << temp_1; |
| q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab); |
| |
| if (wet_ener[i_al] != 0) { |
| scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2); |
| q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[0]); |
| scale[i_al] = dry_ener[0] << temp_1; |
| q_scale[i_al] = q_dry_ener[0] + temp_1 - 30; |
| } |
| scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab); |
| |
| if (wet_ener[i_ar] != 0) { |
| scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2); |
| q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar]; |
| } else { |
| temp_1 = ixheaac_norm32(dry_ener[1]); |
| scale[i_ar] = dry_ener[1] << temp_1; |
| q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30; |
| } |
| scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab); |
| for (ch = 0; ch < 6; ch++) { |
| if (ch == 3 || ch == 0) continue; |
| temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp); |
| scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15); |
| scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15); |
| if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX; |
| if (scale[ch] < ONE_BY_STP_SCALE_LIMIT) |
| scale[ch] = ONE_BY_STP_SCALE_LIMIT; |
| } |
| |
| break; |
| default: |
| break; |
| } |
| |
| for (ch = 0; ch < num_output_channels; ch++) { |
| temp_1 = ixheaacd_mps_mult32_shr_15(STP_LPF_COEFF2_FIX, scale[ch]); |
| temp_2 = |
| ixheaacd_mps_mult32_shr_15(ONE_MINUS_STP_LPF_COEFF2, prev_tp_scale[ch]); |
| scale[ch] = temp_1 + temp_2; |
| prev_tp_scale[ch] = scale[ch]; |
| } |
| |
| offset = ts * MAX_HYBRID_BANDS; |
| p_buffer_real = p_array_struct->buf_real + offset + HYBRID_BAND_BORDER; |
| p_buffer_imag = p_array_struct->buf_imag + offset + HYBRID_BAND_BORDER; |
| |
| p_buf_real = p_array_struct->buffer_real + offset + FIVE; |
| p_buf_imag = p_array_struct->buffer_imag + offset + FIVE; |
| |
| p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry + |
| ts * MAX_HYBRID_BANDS + HYBRID_BAND_BORDER; |
| p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry + |
| ts * MAX_HYBRID_BANDS + HYBRID_BAND_BORDER; |
| |
| for (ch = 0; ch < num_output_channels; ch++) { |
| no_scaling = 1; |
| |
| ixheaacd_get_ch_idx(pstr_mps_state, ch, &i); |
| if (i != -1) { |
| no_scaling = !pstr_mps_state->aux_struct->temp_shape_enable_channel_stp[i]; |
| } |
| p_buffer_re = p_buffer_real; |
| p_buffer_im = p_buffer_imag; |
| |
| p_buf_re = p_buf_real; |
| p_buf_im = p_buf_imag; |
| |
| hyb_output_real_dry = p_hyb_out_dry_real; |
| hyb_output_imag_dry = p_hyb_out_dry_imag; |
| |
| if (no_scaling == 1) { |
| for (n = HYBRID_BAND_BORDER; n < (HP_SIZE + QMF_TO_HYB_OFFSET); n++) { |
| *p_buf_re++ = *hyb_output_real_dry++ + *p_buffer_re++; |
| |
| *p_buf_im++ = *hyb_output_imag_dry++ + *p_buffer_im++; |
| } |
| |
| for (; n < hybrid_bands; n++, k++) { |
| temp = (no_scaling ? ONE_IN_Q15 : scale[ch]); |
| |
| *p_buf_re++ = *hyb_output_real_dry++ + *p_buffer_re++; |
| |
| *p_buf_im++ = *hyb_output_imag_dry++ + *p_buffer_im++; |
| } |
| } else { |
| for (n = HYBRID_BAND_BORDER; n < (HP_SIZE + QMF_TO_HYB_OFFSET); n++) { |
| temp = ixheaacd_mps_mult32_shr_30( |
| scale[ch], tp_process_table_ptr->bp[n - QMF_TO_HYB_OFFSET]); |
| |
| *p_buf_re++ = *hyb_output_real_dry++ + |
| ixheaacd_mps_mult32_shr_15(temp, *p_buffer_re); |
| p_buffer_re++; |
| |
| *p_buf_im++ = *hyb_output_imag_dry++ + |
| ixheaacd_mps_mult32_shr_15(temp, *p_buffer_im); |
| p_buffer_im++; |
| } |
| |
| for (; n < hybrid_bands; n++, k++) { |
| temp = (no_scaling ? ONE_IN_Q15 : scale[ch]); |
| |
| *p_buf_re++ = *hyb_output_real_dry++ + |
| ixheaacd_mps_mult32_shr_15(temp, *p_buffer_re); |
| p_buffer_re++; |
| |
| *p_buf_im++ = *hyb_output_imag_dry++ + |
| ixheaacd_mps_mult32_shr_15(temp, *p_buffer_im); |
| p_buffer_im++; |
| } |
| } |
| |
| p_buffer_real += TSXHB; |
| p_buffer_imag += TSXHB; |
| |
| p_buf_real += TSXHB; |
| p_buf_imag += TSXHB; |
| |
| p_hyb_out_dry_real += TSXHB; |
| p_hyb_out_dry_imag += TSXHB; |
| } |
| |
| return; |
| } |
| |
| VOID ixheaacd_tp_process(ia_heaac_mps_state_struct *pstr_mps_state) { |
| WORD32 ch, ts, hyb, n; |
| WORD32 temp, temp_1, temp_2; |
| ia_mps_dec_synthesis_interface *syn = pstr_mps_state->syn; |
| WORD32 *hyb_output_real_wet, *hyb_output_imag_wet; |
| WORD32 *hyb_output_real_dry, *hyb_output_imag_dry; |
| |
| WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im; |
| WORD32 *p_buf_real, *p_buf_imag, *p_buf_re, *p_buf_im; |
| WORD32 *buf_real, *buf_imag; |
| |
| WORD32 num_output_channels = pstr_mps_state->num_output_channels; |
| WORD32 time_slots = pstr_mps_state->time_slots; |
| WORD32 qmf_bands = pstr_mps_state->qmf_bands; |
| WORD32 num_output_channels_at = pstr_mps_state->num_output_channels_at; |
| WORD32 tree_config = pstr_mps_state->tree_config; |
| WORD32 up_mix_type = pstr_mps_state->up_mix_type; |
| WORD32 tp_hyb_band_border = pstr_mps_state->tp_hyb_band_border; |
| |
| ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct; |
| WORD32 *p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry; |
| WORD32 *p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry; |
| WORD32 *p_hyb_out_dry_re, *p_hyb_out_dry_im; |
| |
| WORD32 *p_time_out; |
| |
| p_buffer_real = p_array_struct->buf_real; |
| p_buffer_imag = p_array_struct->buf_imag; |
| |
| p_buf_real = p_array_struct->buffer_real; |
| p_buf_imag = p_array_struct->buffer_imag; |
| |
| if (!pstr_mps_state->scaling_enable) { |
| for (ch = 0; ch < num_output_channels; ch++) { |
| p_buffer_re = p_buffer_real; |
| p_buffer_im = p_buffer_imag; |
| |
| p_buf_re = p_buf_real; |
| p_buf_im = p_buf_imag; |
| |
| p_hyb_out_dry_re = p_hyb_out_dry_real; |
| p_hyb_out_dry_im = p_hyb_out_dry_imag; |
| |
| for (ts = 0; ts < time_slots; ts++) { |
| hyb_output_real_wet = p_buffer_re; |
| hyb_output_imag_wet = p_buffer_im; |
| hyb_output_real_dry = p_hyb_out_dry_re; |
| hyb_output_imag_dry = p_hyb_out_dry_im; |
| |
| buf_real = p_buf_re; |
| buf_imag = p_buf_im; |
| |
| temp_1 = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp_2 = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| for (n = 1; n < 6; n++) { |
| temp_1 += *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp_2 += *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| } |
| |
| *buf_real++ = temp_1; |
| *buf_imag++ = temp_2; |
| |
| temp = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_real = temp + *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| *buf_imag = temp + *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| |
| buf_real++; |
| buf_imag++; |
| |
| temp = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_real = temp + *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| *buf_imag = temp + *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| |
| buf_real++; |
| buf_imag++; |
| |
| for (n = 0; n < qmf_bands; n++) { |
| *buf_real++ = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_imag++ = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| } |
| |
| p_buffer_re += MAX_HYBRID_BANDS; |
| p_buffer_im += MAX_HYBRID_BANDS; |
| |
| p_buf_re += MAX_HYBRID_BANDS; |
| p_buf_im += MAX_HYBRID_BANDS; |
| |
| p_hyb_out_dry_re += MAX_HYBRID_BANDS; |
| p_hyb_out_dry_im += MAX_HYBRID_BANDS; |
| } |
| p_buffer_real += TSXHB; |
| p_buffer_imag += TSXHB; |
| |
| p_buf_real += TSXHB; |
| p_buf_imag += TSXHB; |
| |
| p_hyb_out_dry_real += TSXHB; |
| p_hyb_out_dry_imag += TSXHB; |
| } |
| } else { |
| for (ch = 0; ch < num_output_channels; ch++) { |
| p_buffer_re = p_buffer_real; |
| p_buffer_im = p_buffer_imag; |
| |
| p_buf_re = p_buf_real; |
| p_buf_im = p_buf_imag; |
| |
| p_hyb_out_dry_re = p_hyb_out_dry_real; |
| p_hyb_out_dry_im = p_hyb_out_dry_imag; |
| |
| for (ts = 0; ts < time_slots; ts++) { |
| hyb_output_real_wet = p_buffer_re; |
| hyb_output_imag_wet = p_buffer_im; |
| hyb_output_real_dry = p_hyb_out_dry_re; |
| hyb_output_imag_dry = p_hyb_out_dry_im; |
| |
| buf_real = p_buf_re; |
| buf_imag = p_buf_im; |
| |
| temp_1 = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp_2 = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| for (n = 1; n < 6; n++) { |
| temp_1 += *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| temp_2 += *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| } |
| |
| *buf_real++ = temp_1; |
| *buf_imag++ = temp_2; |
| |
| *buf_real = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_real += *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| |
| *buf_imag = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| *buf_imag += *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| |
| buf_real++; |
| buf_imag++; |
| |
| *buf_real = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_real += *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_imag = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| *buf_imag += *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| |
| buf_real++; |
| buf_imag++; |
| |
| for (hyb = 3; hyb < tp_hyb_band_border - QMF_TO_HYB_OFFSET; hyb++) { |
| *buf_real++ = *hyb_output_real_dry++ + *hyb_output_real_wet++; |
| *buf_imag++ = *hyb_output_imag_dry++ + *hyb_output_imag_wet++; |
| } |
| p_buffer_re += MAX_HYBRID_BANDS; |
| p_buffer_im += MAX_HYBRID_BANDS; |
| |
| p_buf_re += MAX_HYBRID_BANDS; |
| p_buf_im += MAX_HYBRID_BANDS; |
| |
| p_hyb_out_dry_re += MAX_HYBRID_BANDS; |
| p_hyb_out_dry_im += MAX_HYBRID_BANDS; |
| } |
| p_buffer_real += TSXHB; |
| p_buffer_imag += TSXHB; |
| |
| p_buf_real += TSXHB; |
| p_buf_imag += TSXHB; |
| |
| p_hyb_out_dry_real += TSXHB; |
| p_hyb_out_dry_imag += TSXHB; |
| } |
| |
| for (ts = 0; ts < time_slots; ts++) { |
| ixheaacd_subband_tp(pstr_mps_state, ts); |
| } |
| } |
| |
| if ((!pstr_mps_state->bs_config.arbitrary_tree) && |
| ((up_mix_type != 2) && (up_mix_type != 3))) { |
| WORD32 *time_out_5xxx = |
| pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr->time_out_idx_5xxx; |
| WORD32 *time_out_7xxx = |
| pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr->time_out_idx_7xxx; |
| |
| p_buf_real = p_array_struct->buffer_real; |
| p_buf_imag = p_array_struct->buffer_imag; |
| |
| for (ch = 0; ch < num_output_channels_at; ch++) { |
| WORD32 tempch = 0; |
| switch (tree_config) { |
| case TREE_5151: |
| tempch = ch; |
| break; |
| case TREE_5152: |
| case TREE_525: |
| tempch = time_out_5xxx[ch]; |
| break; |
| case TREE_7271: |
| case TREE_7272: |
| case TREE_7571: |
| case TREE_7572: |
| tempch = time_out_7xxx[ch]; |
| break; |
| default: |
| break; |
| } |
| p_time_out = p_array_struct->time_out + tempch * QBXTS; |
| syn->syn_filter_bank(&pstr_mps_state->syn_qmf_bank, p_buf_real, p_buf_imag, |
| p_time_out, ch, qmf_bands, time_slots, |
| pstr_mps_state->ia_mps_dec_mps_table.qmf_table_ptr); |
| |
| p_buf_real += TSXHB; |
| p_buf_imag += TSXHB; |
| } |
| } else { |
| p_time_out = p_array_struct->time_out; |
| for (ch = 0; ch < num_output_channels_at; ch++) { |
| syn->syn_filter_bank(&pstr_mps_state->syn_qmf_bank, p_buf_real, p_buf_imag, |
| p_time_out, ch, qmf_bands, time_slots, |
| pstr_mps_state->ia_mps_dec_mps_table.qmf_table_ptr); |
| |
| p_buf_real += TSXHB; |
| p_buf_imag += TSXHB; |
| p_time_out += QBXTS; |
| } |
| } |
| |
| return; |
| } |
