wrapper/libxaac
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libxaac/encoder/ixheaace_cplx_pred.c
Akshay Ragir 56716426e2 Fix for the Global-buffer-overflow READ 4 in iusace_quantize_lines 
These changes handle the global-buffer-overflow runtime error
reported when the tonal difference in the SBR module becomes
zero.

Bug: ossFuzz: 62261
Test: poc in bug
2023-10-03 19:14:29 +05:30

523 lines
23 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 <math.h>
#include <string.h>
#include <float.h>
#include "iusace_type_def.h"
#include "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_mps_common_define.h"
#include "iusace_cnst.h"
#include "iusace_fd_quant.h"
#include "iusace_bitbuffer.h"
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_api.h"
#include "impd_drc_uni_drc_eq.h"
#include "impd_drc_uni_drc_filter_bank.h"
#include "impd_drc_gain_enc.h"
#include "impd_drc_struct_def.h"
#include "ixheaace_memory_standards.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_config.h"
#include "iusace_block_switch_const.h"
#include "iusace_block_switch_struct_def.h"
#include "iusace_signal_classifier.h"
#include "iusace_ms.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_fd_qc_util.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"
#include "ixheaace_asc_write.h"
#include "iusace_main.h"
#include "iusace_rom.h"
#include "ixheaace_common_utils.h"
static VOID iusace_compute_pred_coef(WORD32 num_lines, WORD32 complex_coef,
FLOAT64 *ptr_spec_mdct_dmx, FLOAT64 *ptr_spec_mdst_dmx,
FLOAT64 *ptr_spec_mdct_mid_side, FLOAT32 *pred_coef_re,
FLOAT32 *pred_coef_im, FLOAT32 *pred_coef_q_re,
FLOAT32 *pred_coef_q_im, WORD32 *pred_coef_q_int_re,
WORD32 *pred_coef_q_int_im) {
LOOPIDX bin_idx;
FLOAT32 iprod_re = 0.0f, iprod_im = 0.0f;
FLOAT32 eps = 1.0e-6f;
const FLOAT32 k_delta = 0.1f;
const FLOAT32 k_max = 3.0f;
WORD32 pred_coef_sign_re, pred_coef_sign_im;
FLOAT32 pred_coef_abs_re, pred_coef_abs_im;
FLOAT32 abs_dmx = 0.0f;
for (bin_idx = 0; bin_idx < num_lines; bin_idx++) {
/* D = Dr + jDi */
/* D*S = (Dr + jDi)*S = Dr*S + j(Di*S) */
/* alpha = alpha_r - jalpha_i */
if (complex_coef == 1) {
iprod_re += (FLOAT32)(ptr_spec_mdct_dmx[bin_idx] * ptr_spec_mdct_mid_side[bin_idx]);
iprod_im += (FLOAT32)(ptr_spec_mdst_dmx[bin_idx] * ptr_spec_mdct_mid_side[bin_idx]);
abs_dmx += (FLOAT32)(ptr_spec_mdct_dmx[bin_idx] * ptr_spec_mdct_dmx[bin_idx] +
ptr_spec_mdst_dmx[bin_idx] * ptr_spec_mdst_dmx[bin_idx]);
} else {
iprod_re += (FLOAT32)(ptr_spec_mdct_dmx[bin_idx] * ptr_spec_mdct_mid_side[bin_idx]);
abs_dmx += (FLOAT32)(ptr_spec_mdct_dmx[bin_idx] * ptr_spec_mdct_dmx[bin_idx]);
}
}
/* Compute real and imaginary parts of prediction coefficient */
*pred_coef_re = iprod_re / (abs_dmx + eps);
pred_coef_sign_re = *pred_coef_re > 0 ? 1 : -1;
pred_coef_abs_re = (FLOAT32)MIN(fabs(*pred_coef_re), k_max);
*pred_coef_q_int_re = pred_coef_sign_re * (WORD32)(pred_coef_abs_re / k_delta + 0.5f);
*pred_coef_q_re = *pred_coef_q_int_re * k_delta;
if (complex_coef == 1) {
*pred_coef_im = iprod_im / (abs_dmx + eps);
pred_coef_sign_im = *pred_coef_im > 0 ? 1 : -1;
pred_coef_abs_im = (FLOAT32)MIN(fabs(*pred_coef_im), k_max);
*pred_coef_q_int_im = pred_coef_sign_im * (WORD32)(pred_coef_abs_im / k_delta + 0.5f);
*pred_coef_q_im = *pred_coef_q_int_im * k_delta;
}
}
static VOID iusace_compute_res(WORD32 num_lines, WORD32 complex_coef, FLOAT32 pred_coef_q_re,
FLOAT32 pred_coef_q_im, FLOAT64 *ptr_spec_mdct_dmx,
FLOAT64 *ptr_spec_mdst_dmx, FLOAT64 *ptr_spec_mdct_mid_side,
FLOAT64 *ptr_spec_mdct_res) {
LOOPIDX i;
for (i = 0; i < num_lines; i++) {
/* DMX = M; E = S - alpha*DMX if pred_dir = 0 */
/* DMX = S; E = M - alpha*DMX if pred_dir = 1 */
if (complex_coef == 1) {
ptr_spec_mdct_res[i] =
(FLOAT32)(ptr_spec_mdct_mid_side[i] - pred_coef_q_re * ptr_spec_mdct_dmx[i] -
pred_coef_q_im * ptr_spec_mdst_dmx[i]);
} else {
ptr_spec_mdct_res[i] =
(FLOAT32)(ptr_spec_mdct_mid_side[i] - pred_coef_q_re * ptr_spec_mdct_dmx[i]);
}
}
}
static VOID iusace_filter_and_add(const FLOAT64 *ptr_in, const WORD32 length,
const FLOAT64 *ptr_filter, FLOAT64 *ptr_out,
const WORD32 factor_even) {
LOOPIDX i;
FLOAT64 s;
i = 0;
s = ptr_filter[6] * ptr_in[2] + ptr_filter[5] * ptr_in[1] + ptr_filter[4] * ptr_in[0] +
ptr_filter[3] * ptr_in[0] + ptr_filter[2] * ptr_in[1] + ptr_filter[1] * ptr_in[2] +
ptr_filter[0] * ptr_in[3];
ptr_out[i] += s * factor_even;
i = 1;
s = ptr_filter[6] * ptr_in[1] + ptr_filter[5] * ptr_in[0] + ptr_filter[4] * ptr_in[0] +
ptr_filter[3] * ptr_in[1] + ptr_filter[2] * ptr_in[2] + ptr_filter[1] * ptr_in[3] +
ptr_filter[0] * ptr_in[4];
ptr_out[i] += s;
i = 2;
s = ptr_filter[6] * ptr_in[0] + ptr_filter[5] * ptr_in[0] + ptr_filter[4] * ptr_in[1] +
ptr_filter[3] * ptr_in[2] + ptr_filter[2] * ptr_in[3] + ptr_filter[1] * ptr_in[4] +
ptr_filter[0] * ptr_in[5];
ptr_out[i] += s * factor_even;
for (i = 3; i < length - 4; i += 2) {
s = ptr_filter[6] * ptr_in[i - 3] + ptr_filter[5] * ptr_in[i - 2] +
ptr_filter[4] * ptr_in[i - 1] + ptr_filter[3] * ptr_in[i] +
ptr_filter[2] * ptr_in[i + 1] + ptr_filter[1] * ptr_in[i + 2] +
ptr_filter[0] * ptr_in[i + 3];
ptr_out[i] += s;
s = ptr_filter[6] * ptr_in[i - 2] + ptr_filter[5] * ptr_in[i - 1] +
ptr_filter[4] * ptr_in[i] + ptr_filter[3] * ptr_in[i + 1] +
ptr_filter[2] * ptr_in[i + 2] + ptr_filter[1] * ptr_in[i + 3] +
ptr_filter[0] * ptr_in[i + 4];
ptr_out[i + 1] += s * factor_even;
}
i = length - 3;
s = ptr_filter[6] * ptr_in[i - 3] + ptr_filter[5] * ptr_in[i - 2] +
ptr_filter[4] * ptr_in[i - 1] + ptr_filter[3] * ptr_in[i] + ptr_filter[2] * ptr_in[i + 1] +
ptr_filter[1] * ptr_in[i + 2] + ptr_filter[0] * ptr_in[i + 2];
ptr_out[i] += s;
i = length - 2;
s = ptr_filter[6] * ptr_in[i - 3] + ptr_filter[5] * ptr_in[i - 2] +
ptr_filter[4] * ptr_in[i - 1] + ptr_filter[3] * ptr_in[i] + ptr_filter[2] * ptr_in[i + 1] +
ptr_filter[1] * ptr_in[i + 1] + ptr_filter[0] * ptr_in[i];
ptr_out[i] += s * factor_even;
i = length - 1;
s = ptr_filter[6] * ptr_in[i - 3] + ptr_filter[5] * ptr_in[i - 2] +
ptr_filter[4] * ptr_in[i - 1] + ptr_filter[3] * ptr_in[i] + ptr_filter[2] * ptr_in[i] +
ptr_filter[1] * ptr_in[i - 1] + ptr_filter[0] * ptr_in[i - 2];
ptr_out[i] += s;
}
static VOID iusace_estimate_dmx_im(const FLOAT64 *ptr_dmx_re, const FLOAT64 *ptr_dmx_re_prev,
FLOAT64 *ptr_dmx_im, WORD32 window, const WORD32 w_shape,
const WORD32 prev_w_shape, WORD32 num_sbk,
WORD32 bins_per_sbk) {
LOOPIDX i;
const FLOAT64 *ptr_mdst_fcoeff_curr, *ptr_mdst_fcoeff_prev;
switch (window) {
case ONLY_LONG_SEQUENCE:
case EIGHT_SHORT_SEQUENCE:
ptr_mdst_fcoeff_curr = iusace_mdst_fcoeff_longshort_curr[prev_w_shape][w_shape];
ptr_mdst_fcoeff_prev = iusace_mdst_fcoeff_l_s_start_left_prev[prev_w_shape];
break;
case LONG_START_SEQUENCE:
ptr_mdst_fcoeff_curr = iusace_mdst_fcoeff_start_curr[prev_w_shape][w_shape];
ptr_mdst_fcoeff_prev = iusace_mdst_fcoeff_l_s_start_left_prev[prev_w_shape];
break;
case LONG_STOP_SEQUENCE:
ptr_mdst_fcoeff_curr = iusace_mdst_fcoeff_stop_cur[prev_w_shape][w_shape];
ptr_mdst_fcoeff_prev = iusace_mdst_fcoeff_stop_stopstart_left_prev[prev_w_shape];
break;
case STOP_START_SEQUENCE:
ptr_mdst_fcoeff_curr = iusace_mdst_fcoeff_stopstart_cur[prev_w_shape][w_shape];
ptr_mdst_fcoeff_prev = iusace_mdst_fcoeff_stop_stopstart_left_prev[prev_w_shape];
break;
default:
ptr_mdst_fcoeff_curr = iusace_mdst_fcoeff_stopstart_cur[prev_w_shape][w_shape];
ptr_mdst_fcoeff_prev = iusace_mdst_fcoeff_stop_stopstart_left_prev[prev_w_shape];
break;
}
for (i = 0; i < num_sbk; i++) {
iusace_filter_and_add(ptr_dmx_re, bins_per_sbk, ptr_mdst_fcoeff_curr, ptr_dmx_im, 1);
if (ptr_dmx_re_prev) {
iusace_filter_and_add(ptr_dmx_re_prev, bins_per_sbk, ptr_mdst_fcoeff_prev, ptr_dmx_im, -1);
}
ptr_dmx_re_prev = ptr_dmx_re;
ptr_dmx_re += bins_per_sbk;
ptr_dmx_im += bins_per_sbk;
}
return;
}
static VOID iusace_usac_cplx_save_prev(FLOAT64 *ptr_mdct_spec, FLOAT64 *ptr_mdct_spec_prev,
WORD32 save_zeros, WORD32 condition_2, WORD32 samp_per_bk,
WORD32 bins_per_sbk) {
WORD32 offset;
offset = samp_per_bk - bins_per_sbk;
if (save_zeros || condition_2) {
memset(ptr_mdct_spec_prev + offset, 0, sizeof(FLOAT64) * bins_per_sbk);
} else {
memcpy(ptr_mdct_spec_prev + offset, ptr_mdct_spec + offset, sizeof(FLOAT64) * bins_per_sbk);
}
return;
}
static FLOAT64 iusace_compute_ipd(FLOAT64 *ptr_spec_real1, FLOAT64 *ptr_spec_imag1,
FLOAT64 *ptr_spec_real2, FLOAT64 *ptr_spec_imag2,
WORD32 num_lines) {
LOOPIDX i;
FLOAT64 ipd = 0.0f;
FLOAT64 cross_corr_real = 0.0f, cross_corr_imag = 0.0f;
for (i = 0; i < num_lines; i++) {
cross_corr_real +=
ptr_spec_real1[i] * ptr_spec_real2[i] + ptr_spec_imag1[i] * ptr_spec_imag2[i];
cross_corr_imag +=
-ptr_spec_imag2[i] * ptr_spec_real1[i] + ptr_spec_imag1[i] * ptr_spec_real2[i];
}
ipd = (FLOAT64)atan2(cross_corr_imag, cross_corr_real);
ipd = ipd > 0 ? ipd : 2. * PI + ipd;
return ipd;
}
static IA_ERRORCODE iusace_cplx_pred_main(
WORD32 num_sfb, WORD32 num_window_groups, FLOAT64 *ptr_spec_mdct_mid,
FLOAT64 *ptr_spec_mdct_side, WORD32 pred_coef_q_int_re[MAX_SHORT_WINDOWS][MAX_SFB_LONG],
WORD32 pred_coef_q_int_im[MAX_SHORT_WINDOWS][MAX_SFB_LONG], WORD32 *pred_dir,
ia_usac_data_struct *pstr_usac_data, ia_sfb_params_struct *pstr_sfb_prms,
WORD32 usac_independancy_flag, ia_usac_encoder_config_struct *pstr_usac_config,
FLOAT64 *ptr_scratch_cmpx_mdct_buf, WORD32 cplx_pred_used[MAX_SHORT_WINDOWS][MAX_SFB_LONG],
WORD32 chn, const WORD32 *ptr_sfb_offsets, FLOAT32 nrg_mid, FLOAT32 nrg_side,
WORD32 *ms_mask_flag) {
LOOPIDX group, sfb, i;
FLOAT32 pred_coef_re, pred_coef_im, pred_coef_q_re, pred_coef_q_im = 0.0f;
const WORD32 sfb_per_pred_band = 2;
WORD32 left = 0, right = 0, save_zeros = 0, condition_2 = 0, samp_per_bk = 0, bins_per_sbk = 0,
num_sbk = 0;
FLOAT64 *ptr_dmx_re_prev;
FLOAT64 *ptr_spec_mdct_res = &ptr_scratch_cmpx_mdct_buf[0];
const WORD32 sfb_count = num_window_groups * num_sfb;
const WORD32 sfb_per_group = num_sfb;
WORD32 sfb_offsets = 0, zero_flag, spec_start, spec_end;
left = chn, right = chn + 1;
/* Number of sub-blocks */
if (pstr_usac_config->window_sequence[left] == EIGHT_SHORT_SEQUENCE) {
num_sbk = MAX_SHORT_WINDOWS;
}
if (pstr_usac_config->window_sequence[left] == ONLY_LONG_SEQUENCE ||
pstr_usac_config->window_sequence[left] == LONG_START_SEQUENCE ||
pstr_usac_config->window_sequence[left] == LONG_STOP_SEQUENCE ||
pstr_usac_config->window_sequence[left] == STOP_START_SEQUENCE) {
num_sbk = 1;
}
if (num_sbk == 0) {
return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_NUM_SBK;
}
samp_per_bk = pstr_usac_config->ccfl;
bins_per_sbk = samp_per_bk / num_sbk;
/* Compute prediction direction */
if (nrg_mid >= nrg_side) {
*pred_dir = 0;
} else {
*pred_dir = 1;
}
if (pstr_usac_data->complex_coef[chn] == 1) {
save_zeros = ((pstr_usac_config->window_sequence[left] == EIGHT_SHORT_SEQUENCE &&
pstr_usac_config->window_sequence[right] != EIGHT_SHORT_SEQUENCE) ||
(pstr_usac_config->window_sequence[left] != EIGHT_SHORT_SEQUENCE &&
pstr_usac_config->window_sequence[right] == EIGHT_SHORT_SEQUENCE));
condition_2 = (usac_independancy_flag || pstr_usac_data->core_mode_prev[left] ||
pstr_usac_data->core_mode_prev[right]);
/* Compute current frame's MDST down-mix*/
ptr_dmx_re_prev = !(usac_independancy_flag) ? pstr_usac_data->ptr_dmx_re_save[chn] : NULL;
memset(pstr_usac_data->ptr_dmx_im[chn], 0, sizeof(FLOAT64) * FRAME_LEN_LONG);
iusace_estimate_dmx_im(*pred_dir == 0 ? ptr_spec_mdct_mid : ptr_spec_mdct_side,
ptr_dmx_re_prev, pstr_usac_data->ptr_dmx_im[chn],
pstr_usac_config->window_sequence[left],
pstr_sfb_prms->window_shape[left],
pstr_usac_config->window_shape_prev[left], num_sbk, bins_per_sbk);
/* MCLT of downmix = dmx_re + j*dmx_im */
/* Save MDCT down-mix for use as previous frame MDCT down-mix in the next frame */
iusace_usac_cplx_save_prev(*pred_dir == 0 ? &ptr_spec_mdct_mid[0] : &ptr_spec_mdct_side[0],
pstr_usac_data->ptr_dmx_re_save[chn], save_zeros, condition_2,
samp_per_bk, bins_per_sbk);
}
/* Reset buffer to zero */
for (group = 0; group < MAX_SHORT_WINDOWS; group++) {
memset(pred_coef_q_int_re, 0, MAX_SFB_LONG * sizeof(WORD32));
memset(pred_coef_q_int_im, 0, MAX_SFB_LONG * sizeof(WORD32));
}
group = 0;
for (sfb = 0; sfb < sfb_count; sfb += sfb_per_group, group++) {
for (sfb_offsets = 0; sfb_offsets < sfb_per_group; sfb_offsets += sfb_per_pred_band) {
if (cplx_pred_used[group][sfb_offsets] == 1) {
zero_flag = (ptr_sfb_offsets[sfb + sfb_offsets + 1] != FRAME_LEN_LONG);
spec_start = ptr_sfb_offsets[sfb + sfb_offsets];
spec_end = (zero_flag ? ptr_sfb_offsets[sfb + sfb_offsets + 2]
: ptr_sfb_offsets[sfb + sfb_offsets + 1]);
/* Calculate prediction coefficients */
iusace_compute_pred_coef(
spec_end - spec_start, pstr_usac_data->complex_coef[chn],
*pred_dir == 0 ? &ptr_spec_mdct_mid[spec_start] : &ptr_spec_mdct_side[spec_start],
pstr_usac_data->complex_coef[chn] == 1 ? &pstr_usac_data->ptr_dmx_im[chn][spec_start]
: NULL,
*pred_dir == 0 ? &ptr_spec_mdct_side[spec_start] : &ptr_spec_mdct_mid[spec_start],
&pred_coef_re, pstr_usac_data->complex_coef[chn] == 1 ? &pred_coef_im : NULL,
&pred_coef_q_re, pstr_usac_data->complex_coef[chn] == 1 ? &pred_coef_q_im : NULL,
&pred_coef_q_int_re[group][sfb_offsets],
pstr_usac_data->complex_coef[chn] == 1 ? &pred_coef_q_int_im[group][sfb_offsets]
: NULL);
/* Calculate residual */
iusace_compute_res(
spec_end - spec_start, pstr_usac_data->complex_coef[chn], pred_coef_q_re,
pstr_usac_data->complex_coef[chn] == 1 ? pred_coef_q_im : 0,
*pred_dir == 0 ? &ptr_spec_mdct_mid[spec_start] : &ptr_spec_mdct_side[spec_start],
pstr_usac_data->complex_coef[chn] == 1 ? &pstr_usac_data->ptr_dmx_im[chn][spec_start]
: NULL,
*pred_dir == 0 ? &ptr_spec_mdct_side[spec_start] : &ptr_spec_mdct_mid[spec_start],
&ptr_spec_mdct_res[spec_start]);
}
}
}
/* Compute the prediction gain */
FLOAT32 pred_gain = 0.f, nrg_res = 0.f;
for (i = 0; i < pstr_usac_config->ccfl; i++) {
nrg_res += (FLOAT32)(ptr_spec_mdct_res[i] * ptr_spec_mdct_res[i]);
}
pred_gain = 10.f * log10f(ixheaace_div32((*pred_dir == 0 ? nrg_side : nrg_mid), nrg_res));
/* Prediction gain in dB */
if (pred_gain > 20.f) /* Retain complex prediction */
{
if (*pred_dir == 1) {
for (i = 0; i < pstr_usac_config->ccfl; i++) {
ptr_spec_mdct_mid[i] = ptr_spec_mdct_side[i];
ptr_spec_mdct_side[i] = ptr_spec_mdct_res[i];
}
} else {
for (i = 0; i < pstr_usac_config->ccfl; i++) {
ptr_spec_mdct_side[i] = ptr_spec_mdct_res[i];
}
}
} else /* Use M/S */
{
*ms_mask_flag = 0;
/* Revert spectra to L and R */
for (i = 0; i < pstr_usac_config->ccfl; i++) {
ptr_spec_mdct_mid[i] = pstr_usac_data->left_chan_save[chn][i];
ptr_spec_mdct_side[i] = pstr_usac_data->right_chan_save[chn][i];
}
}
return IA_NO_ERROR;
}
IA_ERRORCODE iusace_cplx_pred_proc(
ia_usac_data_struct *pstr_usac_data, ia_usac_encoder_config_struct *pstr_usac_config,
WORD32 usac_independancy_flag, ia_sfb_params_struct *pstr_sfb_prms, WORD32 chn,
ia_psy_mod_data_struct *pstr_psy_data, const WORD32 *ptr_sfb_offsets,
FLOAT64 *ptr_scratch_cmpx_mdct_buf, FLOAT64 *ptr_ms_spec, FLOAT32 nrg_mid, FLOAT32 nrg_side) {
IA_ERRORCODE err_code;
FLOAT32 *ptr_sfb_enegry_left = pstr_psy_data[chn].ptr_sfb_energy_long;
FLOAT32 *ptr_sfb_energy_right = pstr_psy_data[chn + 1].ptr_sfb_energy_long;
const FLOAT32 *ptr_sfb_energy_mid = pstr_psy_data[chn].ptr_sfb_energy_long_ms;
const FLOAT32 *ptr_sfb_energy_side = pstr_psy_data[chn + 1].ptr_sfb_energy_long_ms;
FLOAT32 *ptr_sfb_thr_left = pstr_psy_data[chn].ptr_sfb_thr_long;
FLOAT32 *ptr_sfb_thr_right = pstr_psy_data[chn + 1].ptr_sfb_thr_long;
FLOAT32 *ptr_sfb_spread_energy_left = pstr_psy_data[chn].ptr_sfb_spreaded_energy_long;
FLOAT32 *ptr_sfb_spread_energy_right = pstr_psy_data[chn + 1].ptr_sfb_spreaded_energy_long;
WORD32 sfb, sfb_offsets;
WORD32 *ptr_num_sfb = pstr_sfb_prms->num_sfb;
WORD32 *ptr_num_window_groups = pstr_sfb_prms->num_window_groups;
const WORD32 sfb_count = ptr_num_window_groups[chn] * ptr_num_sfb[chn];
const WORD32 sfb_per_group = ptr_num_sfb[chn];
WORD32 grp = 0, i, zero_flag;
const WORD32 sfb_per_pred_band = 2;
FLOAT32 min_thr_1, min_thr_2 = 0.0f;
FLOAT32 temp_1 = 0, temp_2 = 0;
ia_ms_info_struct *pstr_ms_info = &pstr_usac_data->str_ms_info[chn];
FLOAT64 ipd;
/* Compute IPD between L and R channels */
ipd = iusace_compute_ipd(&pstr_usac_data->spectral_line_vector[chn][0],
&pstr_usac_data->mdst_spectrum[chn][0],
&pstr_usac_data->spectral_line_vector[chn + 1][0],
&pstr_usac_data->mdst_spectrum[chn + 1][0], pstr_usac_config->ccfl);
/* Decide value of complex_coef based on IPD */
if ((ipd > (PI / 2 - 5 * PI / 180) && ipd < (PI / 2 + 5 * PI / 180)) ||
(ipd > (3 * PI / 2 - 5 * PI / 180) && ipd < (3 * PI / 2 + 5 * PI / 180))) {
pstr_usac_data->complex_coef[chn] = 1;
} else {
pstr_usac_data->complex_coef[chn] = 0;
}
/* Compute M and S spectra */
for (i = 0; i < pstr_usac_config->ccfl; i++) {
pstr_usac_data->spectral_line_vector[chn][i] = ptr_ms_spec[i];
pstr_usac_data->spectral_line_vector[chn + 1][i] = ptr_ms_spec[pstr_usac_config->ccfl + i];
}
err_code = iusace_cplx_pred_main(
pstr_sfb_prms->num_sfb[chn], pstr_sfb_prms->num_window_groups[chn],
pstr_usac_data->spectral_line_vector[chn], pstr_usac_data->spectral_line_vector[chn + 1],
pstr_usac_data->pred_coef_re[chn], pstr_usac_data->pred_coef_im[chn],
&pstr_usac_data->pred_dir_idx[chn], pstr_usac_data, pstr_sfb_prms, usac_independancy_flag,
pstr_usac_config, ptr_scratch_cmpx_mdct_buf, pstr_usac_data->cplx_pred_used[chn], chn,
ptr_sfb_offsets, nrg_mid, nrg_side, &pstr_ms_info->ms_mask);
if (err_code != IA_NO_ERROR) {
return err_code;
}
if (pstr_ms_info->ms_mask == 3) {
/* Compute thresholds required for quantization (similar to that in MS coding) */
for (sfb = 0; sfb < sfb_count; sfb += sfb_per_group, grp++) {
for (sfb_offsets = 0; sfb_offsets < sfb_per_group; sfb_offsets += sfb_per_pred_band) {
if (pstr_usac_data->cplx_pred_used[chn][grp][sfb_offsets] == 1) {
zero_flag = (ptr_sfb_offsets[sfb + sfb_offsets + 1] != pstr_usac_config->ccfl);
min_thr_1 =
MIN(ptr_sfb_thr_left[sfb + sfb_offsets], ptr_sfb_thr_right[sfb + sfb_offsets]);
if (zero_flag) {
min_thr_2 = MIN(ptr_sfb_thr_left[sfb + sfb_offsets + 1],
ptr_sfb_thr_right[sfb + sfb_offsets + 1]);
}
ptr_sfb_thr_left[sfb + sfb_offsets] = ptr_sfb_thr_right[sfb + sfb_offsets] = min_thr_1;
ptr_sfb_enegry_left[sfb + sfb_offsets] = ptr_sfb_energy_mid[sfb + sfb_offsets];
ptr_sfb_energy_right[sfb + sfb_offsets] = ptr_sfb_energy_side[sfb + sfb_offsets];
if (zero_flag) {
ptr_sfb_thr_left[sfb + sfb_offsets + 1] = ptr_sfb_thr_right[sfb + sfb_offsets + 1] =
min_thr_2;
ptr_sfb_enegry_left[sfb + sfb_offsets + 1] =
ptr_sfb_energy_mid[sfb + sfb_offsets + 1];
ptr_sfb_energy_right[sfb + sfb_offsets + 1] =
ptr_sfb_energy_side[sfb + sfb_offsets + 1];
}
ptr_sfb_spread_energy_left[sfb + sfb_offsets] =
ptr_sfb_spread_energy_right[sfb + sfb_offsets] =
MIN(ptr_sfb_spread_energy_left[sfb + sfb_offsets],
ptr_sfb_spread_energy_right[sfb + sfb_offsets]) *
0.5f;
if (zero_flag) {
ptr_sfb_spread_energy_left[sfb + sfb_offsets + 1] =
ptr_sfb_spread_energy_right[sfb + sfb_offsets + 1] =
MIN(ptr_sfb_spread_energy_left[sfb + sfb_offsets + 1],
ptr_sfb_spread_energy_right[sfb + sfb_offsets + 1]) *
0.5f;
}
}
}
}
if (pstr_usac_data->pred_dir_idx[chn] == 1) {
grp = 0;
for (sfb = 0; sfb < sfb_count; sfb += sfb_per_group, grp++) {
for (sfb_offsets = 0; sfb_offsets < sfb_per_group; sfb_offsets += sfb_per_pred_band) {
zero_flag = (ptr_sfb_offsets[sfb + sfb_offsets + 1] != pstr_usac_config->ccfl);
if (pstr_usac_data->cplx_pred_used[chn][grp][sfb_offsets] == 1) {
temp_1 = ptr_sfb_enegry_left[sfb + sfb_offsets];
ptr_sfb_enegry_left[sfb + sfb_offsets] = ptr_sfb_energy_right[sfb + sfb_offsets];
ptr_sfb_energy_right[sfb + sfb_offsets] = temp_1;
if (zero_flag) {
temp_2 = ptr_sfb_enegry_left[sfb + sfb_offsets + 1];
ptr_sfb_enegry_left[sfb + sfb_offsets + 1] =
ptr_sfb_energy_right[sfb + sfb_offsets + 1];
ptr_sfb_energy_right[sfb + sfb_offsets + 1] = temp_2;
}
}
}
}
}
}
return IA_NO_ERROR;
}
Reference in a new issue View git blame Copy permalink