| /****************************************************************************** |
| * * |
| * Copyright (C) 2023 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ***************************************************************************** |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore |
| */ |
| |
| #include <string.h> |
| #include <math.h> |
| |
| #include "ixheaac_type_def.h" |
| #include "ixheaac_constants.h" |
| #include "ixheaace_aac_constants.h" |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops16.h" |
| #include "ixheaac_basic_ops40.h" |
| #include "ixheaac_error_standards.h" |
| #include "ixheaace_error_codes.h" |
| |
| #include "ixheaace_bitbuffer.h" |
| #include "ixheaace_sbr_def.h" |
| #include "iusace_esbr_inter_tes.h" |
| #include "iusace_esbr_rom.h" |
| |
| VOID ixheaace_init_esbr_inter_tes(ixheaace_str_inter_tes_params *pstr_tes_enc, |
| WORD32 sbr_ratio_index) { |
| WORD32 ts; |
| WORD32 memset_sz = IXHEAACE_QMF_CHANNELS * sizeof(pstr_tes_enc->qmf_buf_real[0][0]); |
| |
| switch (sbr_ratio_index) { |
| case USAC_SBR_RATIO_INDEX_2_1: |
| pstr_tes_enc->op_delay = 6; |
| pstr_tes_enc->codec_delay = 32; |
| pstr_tes_enc->sbr_ratio_index = sbr_ratio_index; |
| break; |
| case USAC_SBR_RATIO_INDEX_4_1: |
| pstr_tes_enc->op_delay = 6 * 2; |
| pstr_tes_enc->codec_delay = 64; |
| pstr_tes_enc->sbr_ratio_index = sbr_ratio_index; |
| break; |
| } |
| |
| memset(&pstr_tes_enc->bw_array_prev[0], 0, |
| IXHEAACE_MAX_NUM_PATCHES * sizeof(pstr_tes_enc->bw_array_prev[0])); |
| memset(&pstr_tes_enc->inv_filt_mode_prev[0], 0, |
| IXHEAACE_MAX_NUM_NOISE_VALUES * sizeof(pstr_tes_enc->inv_filt_mode_prev[0])); |
| |
| for (ts = 0; |
| ts < pstr_tes_enc->op_delay + pstr_tes_enc->codec_delay + IXHEAACE_SBR_HF_ADJ_OFFSET; |
| ts++) { |
| memset(pstr_tes_enc->qmf_buf_real[ts], 0, memset_sz); |
| memset(pstr_tes_enc->qmf_buf_imag[ts], 0, memset_sz); |
| } |
| return; |
| } |
| |
| static VOID ixheaace_apply_inter_tes(FLOAT32 *qmf_real1, FLOAT32 *qmf_imag1, FLOAT32 *qmf_real, |
| FLOAT32 *qmf_imag, WORD32 num_sample, WORD32 sub_band_start, |
| WORD32 num_subband, WORD32 gamma_idx) { |
| WORD32 sub_band_end = sub_band_start + num_subband; |
| FLOAT32 subsample_power_high[IXHEAACE_TIMESLOT_BUFFER_SIZE], |
| subsample_power_low[IXHEAACE_TIMESLOT_BUFFER_SIZE]; |
| FLOAT32 total_power_high = 0.0f; |
| FLOAT32 total_power_low = 0.0f, total_power_high_after = 1.0e-6f; |
| FLOAT32 gain[IXHEAACE_TIMESLOT_BUFFER_SIZE]; |
| FLOAT32 gain_adj, gain_adj_2; |
| FLOAT32 gamma = ixheaace_gamma_tab[gamma_idx]; |
| WORD32 i, j; |
| WORD32 memcpy_sz = sub_band_start * sizeof(FLOAT32); |
| |
| if (gamma > 0) { |
| for (i = 0; i < num_sample; i++) { |
| memcpy(&qmf_real[IXHEAACE_QMF_CHANNELS * i], &qmf_real1[IXHEAACE_QMF_CHANNELS * i], |
| memcpy_sz); |
| memcpy(&qmf_imag[IXHEAACE_QMF_CHANNELS * i], &qmf_imag1[IXHEAACE_QMF_CHANNELS * i], |
| memcpy_sz); |
| } |
| |
| for (i = 0; i < num_sample; i++) { |
| j = 0; |
| subsample_power_low[i] = 0.0f; |
| while (j < sub_band_start) { |
| subsample_power_low[i] += |
| qmf_real[IXHEAACE_QMF_CHANNELS * i + j] * qmf_real[IXHEAACE_QMF_CHANNELS * i + j]; |
| subsample_power_low[i] += |
| qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] * qmf_imag[IXHEAACE_QMF_CHANNELS * i + j]; |
| j++; |
| } |
| subsample_power_high[i] = 0.0f; |
| while (j < sub_band_end) { |
| subsample_power_high[i] += |
| qmf_real[IXHEAACE_QMF_CHANNELS * i + j] * qmf_real[IXHEAACE_QMF_CHANNELS * i + j]; |
| subsample_power_high[i] += |
| qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] * qmf_imag[IXHEAACE_QMF_CHANNELS * i + j]; |
| j++; |
| } |
| total_power_low += subsample_power_low[i]; |
| total_power_high += subsample_power_high[i]; |
| } |
| |
| for (i = 0; i < num_sample; i++) { |
| gain[i] = |
| (FLOAT32)(sqrt(subsample_power_low[i] * num_sample / (total_power_low + 1.0e-6f))); |
| gain[i] = (FLOAT32)(1.0f + gamma * (gain[i] - 1.0f)); |
| |
| if (gain[i] < 0.2f) { |
| gain[i] = 0.2f; |
| } |
| |
| subsample_power_high[i] *= gain[i] * gain[i]; |
| total_power_high_after += subsample_power_high[i]; |
| } |
| |
| gain_adj_2 = total_power_high / total_power_high_after; |
| gain_adj = (FLOAT32)(sqrt(gain_adj_2)); |
| |
| for (i = 0; i < num_sample; i++) { |
| gain[i] *= gain_adj; |
| |
| j = sub_band_start; |
| while (j < sub_band_end) { |
| qmf_real[IXHEAACE_QMF_CHANNELS * i + j] *= gain[i]; |
| qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] *= gain[i]; |
| j++; |
| } |
| } |
| } |
| } |
| |
| static WORD32 ixheaace_inter_tes_sound_activity(FLOAT32 qmf_real[][IXHEAACE_QMF_CHANNELS], |
| FLOAT32 qmf_imag[][IXHEAACE_QMF_CHANNELS], |
| FLOAT32 energy[], WORD32 len, WORD32 start, |
| WORD32 stop, WORD32 *is_transient) { |
| WORD32 snd_act = 0, ts, idx; |
| FLOAT32 ene_min = MAX_FLT_VAL, ene_max = 0.0f; |
| |
| for (ts = 0; ts < len; ts++) { |
| idx = start; |
| while (idx < stop) { |
| energy[ts] += (qmf_real[ts][idx] * qmf_real[ts][idx]); |
| energy[ts] += (qmf_imag[ts][idx] * qmf_imag[ts][idx]); |
| idx++; |
| } |
| |
| if (energy[ts] > ene_max) { |
| ene_max = energy[ts]; |
| } |
| if (energy[ts] < ene_min) { |
| ene_min = energy[ts]; |
| } |
| } |
| |
| snd_act = (ene_max > IXHEAACE_ESBR_TES_ENERGY_MAX_THR) ? 1 : 0; |
| |
| if ((ene_max / (ene_min + 1.0e-6f)) > 20) { |
| *is_transient = 1; |
| } else { |
| *is_transient = 0; |
| } |
| return snd_act; |
| } |
| |
| static WORD16 ixheaace_find_closest_entry(WORD32 goal_sb, WORD16 *ptr_master_tab, |
| WORD16 num_mf_bands, WORD16 direction) { |
| WORD32 index; |
| |
| if (goal_sb <= ptr_master_tab[0]) return ptr_master_tab[0]; |
| |
| if (goal_sb >= ptr_master_tab[num_mf_bands]) return ptr_master_tab[num_mf_bands]; |
| |
| if (direction) { |
| index = 0; |
| while (ptr_master_tab[index] < goal_sb) { |
| index++; |
| } |
| } else { |
| index = num_mf_bands; |
| while (ptr_master_tab[index] > goal_sb) { |
| index--; |
| } |
| } |
| |
| return ptr_master_tab[index]; |
| } |
| |
| static VOID ixheaace_esbr_calc_co_variance(ixheaace_str_auto_corr_ele *pstr_auto_corr, |
| FLOAT32 ptr_vec_x_real[][IXHEAACE_QMF_CHANNELS], |
| FLOAT32 ptr_vec_x_imag[][IXHEAACE_QMF_CHANNELS], |
| WORD32 bd, WORD32 len) { |
| WORD32 j = 0; |
| |
| FLOAT32 xr_j; |
| FLOAT32 xr_j_minus_1 = ptr_vec_x_real[j - 1][bd]; |
| FLOAT32 xr_j_minus_2 = ptr_vec_x_real[j - 2][bd]; |
| |
| FLOAT32 xi_j; |
| FLOAT32 xi_j_minus_1 = ptr_vec_x_imag[j - 1][bd]; |
| FLOAT32 xi_j_minus_2 = ptr_vec_x_imag[j - 2][bd]; |
| |
| memset(pstr_auto_corr, 0, sizeof(ixheaace_str_auto_corr_ele)); |
| |
| for (j = 0; j < len; j++) { |
| xr_j = ptr_vec_x_real[j][bd]; |
| xi_j = ptr_vec_x_imag[j][bd]; |
| |
| pstr_auto_corr->phi_0_1_real += xr_j * xr_j_minus_1 + xi_j * xi_j_minus_1; |
| |
| pstr_auto_corr->phi_0_1_imag += xi_j * xr_j_minus_1 - xr_j * xi_j_minus_1; |
| |
| pstr_auto_corr->phi_0_2_real += xr_j * xr_j_minus_2 + xi_j * xi_j_minus_2; |
| |
| pstr_auto_corr->phi_0_2_imag += xi_j * xr_j_minus_2 - xr_j * xi_j_minus_2; |
| |
| pstr_auto_corr->phi_1_1 += xr_j_minus_1 * xr_j_minus_1 + xi_j_minus_1 * xi_j_minus_1; |
| |
| pstr_auto_corr->phi_1_2_real += xr_j_minus_1 * xr_j_minus_2 + xi_j_minus_1 * xi_j_minus_2; |
| |
| pstr_auto_corr->phi_1_2_imag += xi_j_minus_1 * xr_j_minus_2 - xr_j_minus_1 * xi_j_minus_2; |
| |
| pstr_auto_corr->phi_2_2 += xr_j_minus_2 * xr_j_minus_2 + xi_j_minus_2 * xi_j_minus_2; |
| |
| xr_j_minus_2 = xr_j_minus_1; |
| xr_j_minus_1 = xr_j; |
| |
| xi_j_minus_2 = xi_j_minus_1; |
| xi_j_minus_1 = xi_j; |
| } |
| |
| pstr_auto_corr->det = pstr_auto_corr->phi_1_1 * pstr_auto_corr->phi_2_2 - |
| (pstr_auto_corr->phi_1_2_real * pstr_auto_corr->phi_1_2_real + |
| pstr_auto_corr->phi_1_2_imag * pstr_auto_corr->phi_1_2_imag) * |
| IXHEAACE_SBR_HF_RELAXATION_PARAM; |
| } |
| |
| static VOID ixheaace_gausssolve(WORD32 n, FLOAT32 ptr_a[][IXHEAACE_MAXDEG + 1], FLOAT32 ptr_b[], |
| FLOAT32 ptr_y[]) { |
| WORD32 i, j, k, imax; |
| FLOAT32 v; |
| |
| for (i = 0; i < n; i++) { |
| imax = i; |
| k = i + 1; |
| while (k < n) { |
| if (fabs(ptr_a[k][i]) > fabs(ptr_a[imax][i])) { |
| imax = k; |
| } |
| k++; |
| } |
| if (imax != i) { |
| v = ptr_b[imax]; |
| ptr_b[imax] = ptr_b[i]; |
| ptr_b[i] = v; |
| j = i; |
| while (j < n) { |
| v = ptr_a[imax][j]; |
| ptr_a[imax][j] = ptr_a[i][j]; |
| ptr_a[i][j] = v; |
| j++; |
| } |
| } |
| |
| v = ptr_a[i][i]; |
| |
| ptr_b[i] /= v; |
| for (j = i; j < n; j++) { |
| ptr_a[i][j] /= v; |
| } |
| |
| for (k = i + 1; k < n; k++) { |
| v = ptr_a[k][i]; |
| ptr_b[k] -= v * ptr_b[i]; |
| for (j = i + 1; j < n; j++) { |
| ptr_a[k][j] -= v * ptr_a[i][j]; |
| } |
| } |
| } |
| |
| for (i = n - 1; i >= 0; i--) { |
| ptr_y[i] = ptr_b[i]; |
| for (j = i + 1; j < n; j++) { |
| ptr_y[i] -= ptr_a[i][j] * ptr_y[j]; |
| } |
| } |
| } |
| |
| static VOID ixheaace_polyfit(WORD32 n, FLOAT32 ptr_y[], FLOAT32 ptr_p[]) { |
| WORD32 i, j, k; |
| FLOAT32 ptr_a[IXHEAACE_MAXDEG + 1][IXHEAACE_MAXDEG + 1] = {{0}}; |
| FLOAT32 ptr_b[IXHEAACE_MAXDEG + 1] = {0}; |
| FLOAT32 v[2 * IXHEAACE_MAXDEG + 1]; |
| |
| for (k = 0; k < n; k++) { |
| v[0] = 1.0; |
| for (i = 1; i <= 2 * IXHEAACE_MAXDEG; i++) { |
| v[i] = k * v[i - 1]; |
| } |
| |
| for (i = 0; i <= IXHEAACE_MAXDEG; i++) { |
| ptr_b[i] += v[IXHEAACE_MAXDEG - i] * ptr_y[k]; |
| for (j = 0; j <= IXHEAACE_MAXDEG; j++) { |
| ptr_a[i][j] += v[2 * IXHEAACE_MAXDEG - i - j]; |
| } |
| } |
| } |
| |
| ixheaace_gausssolve(IXHEAACE_MAXDEG + 1, ptr_a, ptr_b, ptr_p); |
| } |
| |
| static VOID ixheaace_esbr_chirp_fac_calc(WORD32 *ptr_inv_filt_mode, |
| WORD32 *ptr_inv_filt_mode_prev, WORD32 num_if_bands, |
| FLOAT32 *ptr_bw_array, FLOAT32 *ptr_bw_array_prev) { |
| WORD32 i; |
| |
| for (i = 0; i < num_if_bands; i++) { |
| ptr_bw_array[i] = ixheaace_new_bw_tab[ptr_inv_filt_mode_prev[i]][ptr_inv_filt_mode[i]]; |
| |
| if (ptr_bw_array[i] < ptr_bw_array_prev[i]) { |
| ptr_bw_array[i] = 0.75000f * ptr_bw_array[i] + 0.25000f * ptr_bw_array_prev[i]; |
| } else { |
| ptr_bw_array[i] = 0.90625f * ptr_bw_array[i] + 0.09375f * ptr_bw_array_prev[i]; |
| } |
| |
| if (ptr_bw_array[i] < 0.015625) { |
| ptr_bw_array[i] = 0; |
| } |
| } |
| } |
| |
| static VOID ixheaace_pre_processing(FLOAT32 ptr_src_buf_real[][IXHEAACE_QMF_CHANNELS], |
| FLOAT32 ptr_src_buf_imag[][IXHEAACE_QMF_CHANNELS], |
| FLOAT32 ptr_gain_vector[], WORD32 num_bands, |
| WORD32 start_sample, WORD32 end_sample) { |
| WORD32 k, i; |
| FLOAT32 poly_coeff[4]; |
| FLOAT32 mean_enrg = 0; |
| FLOAT32 low_env_slope[IXHEAACE_QMF_CHANNELS]; |
| FLOAT32 low_env[IXHEAACE_QMF_CHANNELS]; |
| FLOAT32 a0; |
| FLOAT32 a1; |
| FLOAT32 a2; |
| FLOAT32 a3; |
| |
| for (k = 0; k < num_bands; k++) { |
| FLOAT32 temp = 0; |
| for (i = start_sample; i < end_sample; i++) { |
| temp += ptr_src_buf_real[i][k] * ptr_src_buf_real[i][k] + |
| ptr_src_buf_imag[i][k] * ptr_src_buf_imag[i][k]; |
| } |
| temp /= (end_sample - start_sample); |
| low_env[k] = (FLOAT32)(10 * log10(temp + 1)); |
| mean_enrg += low_env[k]; |
| } |
| mean_enrg /= num_bands; |
| |
| ixheaace_polyfit(num_bands, low_env, poly_coeff); |
| |
| a0 = poly_coeff[0]; |
| a1 = poly_coeff[1]; |
| a2 = poly_coeff[2]; |
| a3 = poly_coeff[3]; |
| for (k = 0; k < num_bands; k++) { |
| low_env_slope[k] = a3 + a2 * k + a1 * k * k + a0 * k * k * k; |
| } |
| |
| for (i = 0; i < num_bands; i++) { |
| ptr_gain_vector[i] = (FLOAT32)pow(10, (mean_enrg - low_env_slope[i]) / 20.0f); |
| } |
| } |
| |
| static IA_ERRORCODE ixheaace_generate_hf(FLOAT32 ptr_src_buf_real[][64], |
| FLOAT32 ptr_src_buf_imag[][64], |
| FLOAT32 ptr_ph_vocod_buf_real[][64], |
| FLOAT32 ptr_ph_vocod_buf_imag[][64], |
| FLOAT32 ptr_dst_buf_real[][64], |
| FLOAT32 ptr_dst_buf_imag[][64], |
| ixheaace_str_inter_tes_params *pstr_tes_enc) { |
| WORD32 bw_index, i, k, k2, patch = 0; |
| WORD32 co_var_len; |
| WORD32 start_sample, end_sample, goal_sb; |
| WORD32 sb, source_start_band, patch_stride, num_bands_in_patch; |
| WORD32 hbe_flag = 0; |
| FLOAT32 a0r, a0i, a1r, a1i; |
| FLOAT32 ptr_bw_array[IXHEAACE_MAX_NUM_PATCHES] = {0}; |
| |
| ixheaace_str_auto_corr_ele str_auto_corr; |
| |
| WORD16 *ptr_invf_band_tbl = &pstr_tes_enc->invf_band_tbl[1]; |
| WORD32 num_if_bands = pstr_tes_enc->num_if_bands; |
| WORD32 sub_band_start = pstr_tes_enc->sub_band_start; |
| WORD16 *ptr_master_tab = pstr_tes_enc->f_master_tbl; |
| WORD32 num_mf_bands = pstr_tes_enc->num_mf_bands; |
| WORD32 *ptr_inv_filt_mode = pstr_tes_enc->inv_filt_mode; |
| WORD32 *ptr_inv_filt_mode_prev = pstr_tes_enc->inv_filt_mode_prev; |
| WORD32 sbr_patching_mode = 1; |
| WORD32 pre_proc_flag = 0; |
| WORD32 fs = pstr_tes_enc->out_fs; |
| WORD32 cov_count; |
| WORD32 lsb = ptr_master_tab[0]; |
| WORD32 usb = ptr_master_tab[num_mf_bands]; |
| WORD32 memset_sz = (IXHEAACE_QMF_CHANNELS - usb) * sizeof(FLOAT32); |
| WORD32 xover_offset = sub_band_start - ptr_master_tab[0]; |
| FLOAT32 bw = 0.0f; |
| FLOAT32 fac = 0.0f; |
| FLOAT32 gain; |
| FLOAT32 ptr_gain_vector[64]; |
| WORD32 slope_length = 0; |
| WORD32 first_slot_offset = pstr_tes_enc->border_vec[0]; |
| WORD32 end_slot_offs = 0; |
| FLOAT32 *ptr_bw_array_prev = pstr_tes_enc->bw_array_prev; |
| |
| end_slot_offs = pstr_tes_enc->border_vec[pstr_tes_enc->num_env] - 16; |
| |
| switch (pstr_tes_enc->sbr_ratio_index) { |
| case USAC_SBR_RATIO_INDEX_2_1: |
| start_sample = first_slot_offset * 2; |
| end_sample = 32 + end_slot_offs * 2; |
| co_var_len = 38; |
| break; |
| case USAC_SBR_RATIO_INDEX_4_1: |
| start_sample = first_slot_offset * 4; |
| end_sample = 64 + end_slot_offs * 4; |
| co_var_len = 76; |
| break; |
| default: |
| start_sample = first_slot_offset * 2; |
| end_sample = 32 + end_slot_offs * 2; |
| co_var_len = 38; |
| break; |
| } |
| |
| if (pre_proc_flag) { |
| ixheaace_pre_processing(ptr_src_buf_real, ptr_src_buf_imag, ptr_gain_vector, |
| ptr_master_tab[0], start_sample, end_sample); |
| } |
| |
| ixheaace_esbr_chirp_fac_calc(ptr_inv_filt_mode, ptr_inv_filt_mode_prev, num_if_bands, |
| ptr_bw_array, ptr_bw_array_prev); |
| |
| for (i = start_sample; i < end_sample; i++) { |
| memset(ptr_dst_buf_real[i] + usb, 0, memset_sz); |
| memset(ptr_dst_buf_imag[i] + usb, 0, memset_sz); |
| } |
| |
| if (sbr_patching_mode || !hbe_flag) { |
| FLOAT32 alpha_real[IXHEAACE_QMF_CHANNELS][2] = {{0}}, |
| alpha_imag[IXHEAACE_QMF_CHANNELS][2] = {{0}}; |
| cov_count = ptr_master_tab[0]; |
| |
| for (k = 1; k < cov_count; k++) { |
| ixheaace_esbr_calc_co_variance(&str_auto_corr, &ptr_src_buf_real[0], &ptr_src_buf_imag[0], |
| k, co_var_len); |
| if (str_auto_corr.det == 0.0f) { |
| alpha_real[k][1] = alpha_imag[k][1] = 0; |
| } else { |
| fac = 1.0f / str_auto_corr.det; |
| alpha_real[k][1] = (str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_real - |
| str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_imag - |
| str_auto_corr.phi_0_2_real * str_auto_corr.phi_1_1) * |
| fac; |
| alpha_imag[k][1] = (str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_real + |
| str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_imag - |
| str_auto_corr.phi_0_2_imag * str_auto_corr.phi_1_1) * |
| fac; |
| } |
| |
| if (str_auto_corr.phi_1_1 == 0) { |
| alpha_real[k][0] = alpha_imag[k][0] = 0; |
| } else { |
| fac = 1.0f / str_auto_corr.phi_1_1; |
| alpha_real[k][0] = |
| -(str_auto_corr.phi_0_1_real + alpha_real[k][1] * str_auto_corr.phi_1_2_real + |
| alpha_imag[k][1] * str_auto_corr.phi_1_2_imag) * |
| fac; |
| alpha_imag[k][0] = |
| -(str_auto_corr.phi_0_1_imag + alpha_imag[k][1] * str_auto_corr.phi_1_2_real - |
| alpha_real[k][1] * str_auto_corr.phi_1_2_imag) * |
| fac; |
| } |
| |
| if ((alpha_real[k][0] * alpha_real[k][0] + alpha_imag[k][0] * alpha_imag[k][0] >= 16.0f) || |
| (alpha_real[k][1] * alpha_real[k][1] + alpha_imag[k][1] * alpha_imag[k][1] >= 16.0f)) { |
| alpha_real[k][0] = 0.0f; |
| alpha_imag[k][0] = 0.0f; |
| alpha_real[k][1] = 0.0f; |
| alpha_imag[k][1] = 0.0f; |
| } |
| } |
| |
| goal_sb = (WORD32)(2.048e6f / fs + 0.5f); |
| { |
| WORD32 index; |
| if (goal_sb < ptr_master_tab[num_mf_bands]) { |
| for (index = 0; (ptr_master_tab[index] < goal_sb); index++) |
| goal_sb = ptr_master_tab[index]; |
| } else { |
| goal_sb = ptr_master_tab[num_mf_bands]; |
| } |
| } |
| |
| source_start_band = xover_offset + 1; |
| |
| sb = lsb + xover_offset; |
| |
| patch = 0; |
| while (sb < usb) { |
| if (IXHEAACE_MAX_NUM_PATCHES <= patch) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_NUM_PATCH; |
| } |
| |
| num_bands_in_patch = goal_sb - sb; |
| |
| if (num_bands_in_patch + source_start_band >= lsb) { |
| patch_stride = sb - source_start_band; |
| patch_stride = patch_stride & ~1; |
| num_bands_in_patch = lsb - (sb - patch_stride); |
| num_bands_in_patch = ixheaace_find_closest_entry(sb + num_bands_in_patch, ptr_master_tab, |
| (WORD16)(num_mf_bands), 0) - |
| (WORD32)(sb); |
| } |
| |
| patch_stride = num_bands_in_patch + sb - lsb; |
| patch_stride = (patch_stride + 1) & ~1; |
| |
| source_start_band = 1; |
| |
| if (goal_sb - (sb + num_bands_in_patch) < 3) { |
| goal_sb = usb; |
| } |
| |
| if ((num_bands_in_patch < 3) && (patch > 0) && (sb + num_bands_in_patch == usb)) { |
| for (i = start_sample + slope_length; i < end_sample + slope_length; i++) { |
| for (k2 = sb; k2 < sb + num_bands_in_patch; k2++) { |
| if (k2 < 0 || k2 >= 64) { |
| break; |
| } |
| ptr_dst_buf_real[i][k2] = 0.0f; |
| ptr_dst_buf_imag[i][k2] = 0.0f; |
| } |
| } |
| break; |
| } |
| |
| if (num_bands_in_patch <= 0) { |
| continue; |
| } |
| |
| for (k2 = sb; k2 < sb + num_bands_in_patch; k2++) { |
| k = k2 - patch_stride; |
| bw_index = 0; |
| while (k2 >= ptr_invf_band_tbl[bw_index]) { |
| bw_index++; |
| if (bw_index >= IXHEAACE_MAX_NOISE_COEFFS) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX; |
| } |
| } |
| |
| if (bw_index >= IXHEAACE_MAX_NUM_PATCHES) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX; |
| } |
| bw = ptr_bw_array[bw_index]; |
| |
| a0r = bw * alpha_real[k][0]; |
| a0i = bw * alpha_imag[k][0]; |
| bw *= bw; |
| a1r = bw * alpha_real[k][1]; |
| a1i = bw * alpha_imag[k][1]; |
| |
| if (pre_proc_flag) { |
| gain = ptr_gain_vector[k]; |
| } else { |
| gain = 1.0f; |
| } |
| |
| for (i = start_sample + slope_length; i < end_sample + slope_length; i++) { |
| ptr_dst_buf_real[i][k2] = ptr_src_buf_real[i][k] * gain; |
| |
| ptr_dst_buf_imag[i][k2] = ptr_src_buf_imag[i][k] * gain; |
| |
| if (bw > 0.0f) { |
| ptr_dst_buf_real[i][k2] += |
| (a0r * ptr_src_buf_real[i - 1][k] - a0i * ptr_src_buf_imag[i - 1][k] + |
| a1r * ptr_src_buf_real[i - 2][k] - a1i * ptr_src_buf_imag[i - 2][k]) * |
| gain; |
| ptr_dst_buf_imag[i][k2] += |
| (a0i * ptr_src_buf_real[i - 1][k] + a0r * ptr_src_buf_imag[i - 1][k] + |
| a1i * ptr_src_buf_real[i - 2][k] + a1r * ptr_src_buf_imag[i - 2][k]) * |
| gain; |
| } |
| } |
| } |
| sb += num_bands_in_patch; |
| patch++; |
| } |
| } |
| |
| if (hbe_flag && !sbr_patching_mode) { |
| FLOAT32 alpha_real[2], alpha_imag[2]; |
| |
| bw_index = 0, patch = 1; |
| if (NULL == ptr_ph_vocod_buf_real || NULL == ptr_ph_vocod_buf_imag) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_VOCOD_BUF; |
| } |
| |
| for (k2 = sub_band_start; k2 < ptr_master_tab[num_mf_bands]; k2++) { |
| ixheaace_esbr_calc_co_variance(&str_auto_corr, &ptr_ph_vocod_buf_real[0], |
| &ptr_ph_vocod_buf_imag[0], k2, co_var_len); |
| |
| if (str_auto_corr.det == 0.0f) { |
| alpha_real[1] = alpha_imag[1] = 0; |
| } else { |
| fac = 1.0f / str_auto_corr.det; |
| alpha_real[1] = (str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_real - |
| str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_imag - |
| str_auto_corr.phi_0_2_real * str_auto_corr.phi_1_1) * |
| fac; |
| alpha_imag[1] = (str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_real + |
| str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_imag - |
| str_auto_corr.phi_0_2_imag * str_auto_corr.phi_1_1) * |
| fac; |
| } |
| |
| if (str_auto_corr.phi_1_1 == 0) { |
| alpha_real[0] = alpha_imag[0] = 0; |
| } else { |
| fac = 1.0f / str_auto_corr.phi_1_1; |
| alpha_real[0] = |
| -(str_auto_corr.phi_0_1_real + alpha_real[1] * str_auto_corr.phi_1_2_real + |
| alpha_imag[1] * str_auto_corr.phi_1_2_imag) * |
| fac; |
| alpha_imag[0] = |
| -(str_auto_corr.phi_0_1_imag + alpha_imag[1] * str_auto_corr.phi_1_2_real - |
| alpha_real[1] * str_auto_corr.phi_1_2_imag) * |
| fac; |
| } |
| |
| if (alpha_real[0] * alpha_real[0] + alpha_imag[0] * alpha_imag[0] >= 16.0f || |
| alpha_real[1] * alpha_real[1] + alpha_imag[1] * alpha_imag[1] >= 16.0f) { |
| alpha_real[0] = 0.0f; |
| alpha_imag[0] = 0.0f; |
| alpha_real[1] = 0.0f; |
| alpha_imag[1] = 0.0f; |
| } |
| |
| while (k2 >= ptr_invf_band_tbl[bw_index]) { |
| bw_index++; |
| if (bw_index >= IXHEAACE_MAX_NOISE_COEFFS) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX; |
| } |
| } |
| |
| if (bw_index >= IXHEAACE_MAX_NUM_PATCHES) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX; |
| } |
| bw = ptr_bw_array[bw_index]; |
| |
| a0r = bw * alpha_real[0]; |
| a0i = bw * alpha_imag[0]; |
| bw *= bw; |
| a1r = bw * alpha_real[1]; |
| a1i = bw * alpha_imag[1]; |
| |
| if (bw > 0.0f) { |
| for (i = start_sample; i < end_sample; i++) { |
| FLOAT32 real1, imag1, real2, imag2; |
| |
| real1 = ptr_ph_vocod_buf_real[i - 1][k2]; |
| imag1 = ptr_ph_vocod_buf_imag[i - 1][k2]; |
| real2 = ptr_ph_vocod_buf_real[i - 2][k2]; |
| imag2 = ptr_ph_vocod_buf_imag[i - 2][k2]; |
| ptr_dst_buf_real[i][k2] = ptr_ph_vocod_buf_real[i][k2] + |
| ((a0r * real1 - a0i * imag1) + (a1r * real2 - a1i * imag2)); |
| ptr_dst_buf_imag[i][k2] = ptr_ph_vocod_buf_imag[i][k2] + |
| ((a0i * real1 + a0r * imag1) + (a1i * real2 + a1r * imag2)); |
| } |
| } else { |
| for (i = start_sample; i < end_sample; i++) { |
| ptr_dst_buf_real[i][k2] = ptr_ph_vocod_buf_real[i][k2]; |
| ptr_dst_buf_imag[i][k2] = ptr_ph_vocod_buf_imag[i][k2]; |
| } |
| } |
| } |
| } |
| if (patch >= (IXHEAACE_MAX_NUM_PATCHES + 1)) { |
| return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_NUM_PATCH; |
| } |
| for (i = 0; i < num_if_bands; i++) { |
| ptr_bw_array_prev[i] = ptr_bw_array[i]; |
| } |
| return IA_NO_ERROR; |
| } |
| |
| IA_ERRORCODE ixheaace_process_inter_tes(ixheaace_str_inter_tes_params *pstr_tes_enc, |
| WORD8 *ptr_scr) { |
| WORD32 gi = 0, env, tes_enable = 0, ts, bd, start_ts, stop_ts; |
| WORD32 is_sound_activity[IXHEAACE_MAX_ENVELOPES] = {0}, |
| is_transient[IXHEAACE_MAX_ENVELOPES] = {0}; |
| WORD32 tes_shape_mode = 0; |
| WORD32 num_samples, num_bands; |
| WORD32 len; |
| IA_ERRORCODE status = IA_NO_ERROR; |
| FLOAT32 energy_high[64] = {0}; |
| FLOAT32 energy[64] = {0}; |
| FLOAT32 gamma[IXHEAACE_ESBR_NUM_GAMMA_IDXS] = {0}; |
| FLOAT32 gamma_min = MAX_FLT_VAL; |
| ixheaace_str_inter_tes_scr *tes_scr = (ixheaace_str_inter_tes_scr *)ptr_scr; |
| num_bands = pstr_tes_enc->sub_band_end - pstr_tes_enc->sub_band_start; |
| |
| for (env = 0; env < pstr_tes_enc->num_env; env++) { |
| tes_shape_mode = 0; |
| len = 2 * (pstr_tes_enc->border_vec[env + 1] - pstr_tes_enc->border_vec[env]); |
| is_sound_activity[env] = ixheaace_inter_tes_sound_activity( |
| &pstr_tes_enc |
| ->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]], |
| &pstr_tes_enc |
| ->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]], |
| &energy_high[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]], len, |
| pstr_tes_enc->sub_band_start, pstr_tes_enc->sub_band_end, &is_transient[env]); |
| if (1 == is_transient[env] && 1 == is_sound_activity[env]) { |
| tes_enable = 1; |
| } |
| } |
| |
| if (1 == tes_enable) { |
| status = ixheaace_generate_hf(&pstr_tes_enc->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET], |
| &pstr_tes_enc->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET], NULL, |
| NULL, &tes_scr->dst_qmf_r[IXHEAACE_SBR_HF_ADJ_OFFSET], |
| &tes_scr->dst_qmf_i[IXHEAACE_SBR_HF_ADJ_OFFSET], pstr_tes_enc); |
| |
| if (status) { |
| return status; |
| } |
| for (env = 0; env < pstr_tes_enc->num_env; env++) { |
| if ((1 == is_sound_activity[env]) && (1 == is_transient[env])) { |
| num_samples = (pstr_tes_enc->border_vec[env + 1] - pstr_tes_enc->border_vec[env]) * 2; |
| start_ts = IXHEAACE_SBR_HF_ADJ_OFFSET + pstr_tes_enc->border_vec[env] * 2; |
| stop_ts = start_ts + num_samples; |
| |
| for (gi = 0; gi < IXHEAACE_ESBR_NUM_GAMMA_IDXS; gi++) { |
| ixheaace_apply_inter_tes( |
| &tes_scr |
| ->dst_qmf_r[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]][0], |
| &tes_scr |
| ->dst_qmf_i[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]][0], |
| &pstr_tes_enc->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET + |
| 2 * pstr_tes_enc->border_vec[env]][0], |
| &pstr_tes_enc->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET + |
| 2 * pstr_tes_enc->border_vec[env]][0], |
| num_samples, pstr_tes_enc->sub_band_start, num_bands, gi); |
| for (ts = start_ts; ts < stop_ts; ts++) { |
| energy[ts] = 0.0f; |
| for (bd = pstr_tes_enc->sub_band_start; bd < pstr_tes_enc->sub_band_end; bd++) { |
| energy[ts] += tes_scr->dst_qmf_r[ts][bd] * tes_scr->dst_qmf_r[ts][bd]; |
| energy[ts] += tes_scr->dst_qmf_i[ts][bd] * tes_scr->dst_qmf_i[ts][bd]; |
| } |
| gamma[gi] += (FLOAT32)fabs(energy[ts] - energy_high[ts]) / |
| (FLOAT32)(pow((energy_high[ts] + 1e-6f), 0.9f)); |
| } |
| if (gamma[gi] < gamma_min) { |
| gamma_min = gamma[gi]; |
| tes_shape_mode = gi; |
| } |
| } |
| } |
| |
| if (tes_shape_mode > 0) { |
| pstr_tes_enc->bs_tes_shape[env] = 1; |
| pstr_tes_enc->bs_tes_shape_mode[env] = tes_shape_mode; |
| } else { |
| pstr_tes_enc->bs_tes_shape[env] = 0; |
| pstr_tes_enc->bs_tes_shape_mode[env] = 0; |
| } |
| } |
| } else { |
| for (env = 0; env < pstr_tes_enc->num_env; env++) { |
| pstr_tes_enc->bs_tes_shape[env] = 0; |
| pstr_tes_enc->bs_tes_shape_mode[env] = 0; |
| } |
| } |
| return status; |
| } |
