werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
unplugged-system/external/libxaac/decoder/ixheaacd_mps_reshape_bb_env.c

588 lines
21 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 "ixheaacd_type_def.h"
#include "ixheaacd_mps_struct_def.h"
#include "ixheaacd_mps_res_rom.h"
#include "ixheaacd_mps_aac_struct.h"
#include "ixheaacd_constants.h"
#include "ixheaacd_basic_ops32.h"
#include "ixheaacd_basic_ops40.h"
#include "ixheaacd_bitbuffer.h"
#include "ixheaacd_error_codes.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_hybrid.h"
#include "ixheaacd_ps_dec.h"
#include "ixheaacd_mps_polyphase.h"
#include "ixheaacd_config.h"
#include "ixheaacd_qmf_dec.h"
#include "ixheaacd_mps_dec.h"
#include "ixheaacd_mps_bitdec.h"
#include "ixheaacd_mps_macro_def.h"
#include "ixheaacd_mps_basic_op.h"
#include "ixheaacd_mps_reshape_bb_env.h"
#include "ixheaacd_error_standards.h"
#define ALIGN_SIZE64(x) ((((x) + 7) >> 3) << 3)
VOID ixheaacd_init_bb_env(ia_heaac_mps_state_struct *pstr_mps_state) {
WORD32 k, j;
ia_mps_dec_reshape_bb_env_state_struct *reshape_bb_env_state =
pstr_mps_state->mps_persistent_mem.reshape_bb_env_state;
for (k = 0; k < 2 * MAX_OUTPUT_CHANNELS_MPS + MAX_INPUT_CHANNELS_MPS; k++) {
reshape_bb_env_state->norm_nrg_prev[k] = ONE_IN_Q30;
reshape_bb_env_state->frame_nrg_prev[k] = 0;
reshape_bb_env_state->q_frame_nrg_prev[k] = 30;
reshape_bb_env_state->q_norm_nrg_prev[k] = 30;
for (j = 0; j < MAX_PARAMETER_BANDS; j++) {
reshape_bb_env_state->part_nrg_prev[k][j] = 0;
reshape_bb_env_state->q_part_nrg_prev[k][j] = 30;
}
}
}
static VOID ixheaacd_extract_bb_env(ia_heaac_mps_state_struct *pstr_mps_state, WORD32 inp,
WORD32 ch, WORD32 *env, VOID *scratch, WORD32 flag) {
ia_mps_dec_reshape_bb_env_state_struct *reshape_bb_env_state =
pstr_mps_state->mps_persistent_mem.reshape_bb_env_state;
WORD64 *slot_nrg_fix, *slot_nrg;
WORD16 *q_slot_nrg_fix, *q_slot_nrg;
WORD32 *part_nrg_fix;
WORD16 *q_part_nrg_fix;
WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im;
WORD32 ts, qs, pb;
WORD32 start_p = 10;
WORD32 end_p = 18;
WORD32 env_fix_l;
WORD16 q_env_fix_l;
WORD16 alpha_fix = ALPHA_Q15;
WORD16 beta_fix = BETA_Q15;
WORD16 one_min_alpha_fix = ONE_MINUS_ALPHA_Q16;
WORD16 one_min_beta_fix = ONE_MINUS_BETA_Q16;
WORD16 one_by_nine = ONE_BY_NINE_Q16;
WORD32 frame_nrg_fix = 0;
WORD32 *norm_nrg_fix;
WORD16 q_frame_nrg_fix = 0;
WORD16 *q_norm_nrg_fix;
WORD32 temp_1, temp4;
WORD16 qtemp1, q_env;
WORD32 prev_ch_offs;
WORD32 cnt = min(42, pstr_mps_state->hybrid_bands);
WORD32 time_slots = pstr_mps_state->time_slots;
const WORD32 *sqrt_tab = pstr_mps_state->ia_mps_dec_mps_table.common_table_ptr->sqrt_tab;
WORD32 *hyb_output_real_dry, *n_slot_nrg;
WORD32 *hyb_output_imag_dry;
const WORD32 *bb_env_kernels =
pstr_mps_state->ia_mps_dec_mps_table.bitdec_table_ptr->kernel_table.bb_env_kernels;
q_slot_nrg_fix = (WORD16 *)scratch;
n_slot_nrg = (WORD32 *)((WORD8 *)scratch + RESHAPE_OFFSET_1);
slot_nrg_fix = (WORD64 *)ALIGN_SIZE64((SIZE_T)((WORD8 *)scratch + RESHAPE_OFFSET_2));
switch (inp) {
WORD32 frame_nrg_prev;
WORD16 q_frame_nrg_prev;
WORD32 *p_hyb_out_dry_real, *p_hyb_out_dry_imag;
case INP_DRY_WET:
frame_nrg_prev = reshape_bb_env_state->frame_nrg_prev[ch];
q_frame_nrg_prev = reshape_bb_env_state->q_frame_nrg_prev[ch];
part_nrg_fix = &reshape_bb_env_state->part_nrg_prev[ch][0];
q_part_nrg_fix = &reshape_bb_env_state->q_part_nrg_prev[ch][0];
norm_nrg_fix = &reshape_bb_env_state->norm_nrg_prev[ch];
q_norm_nrg_fix = &reshape_bb_env_state->q_norm_nrg_prev[ch];
p_buffer_real = pstr_mps_state->array_struct->buf_real + ch * TSXHB + 12;
p_buffer_imag = pstr_mps_state->array_struct->buf_imag + ch * TSXHB + 12;
p_hyb_out_dry_real = pstr_mps_state->array_struct->hyb_output_real_dry + ch * TSXHB + 12;
p_hyb_out_dry_imag = pstr_mps_state->array_struct->hyb_output_imag_dry + ch * TSXHB + 12;
for (ts = 0; ts < time_slots; ts++) {
WORD32 prev_idx = 10;
slot_nrg = slot_nrg_fix + 4;
for (pb = 14; pb <= end_p; pb++) *slot_nrg++ = 0;
slot_nrg = slot_nrg_fix;
p_buffer_re = p_buffer_real;
p_buffer_im = p_buffer_imag;
hyb_output_real_dry = p_hyb_out_dry_real;
hyb_output_imag_dry = p_hyb_out_dry_imag;
for (qs = 12; qs < 16; qs++) {
temp_1 = (*hyb_output_real_dry + *p_buffer_re);
temp4 = (*hyb_output_imag_dry + *p_buffer_im);
*slot_nrg++ = (WORD64)temp_1 * (WORD64)temp_1 + (WORD64)temp4 * (WORD64)temp4;
p_buffer_re++;
p_buffer_im++;
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
prev_idx = 14;
for (; qs < 30; qs++) {
WORD32 idx = bb_env_kernels[qs];
if (prev_idx != idx) {
slot_nrg++;
prev_idx = idx;
}
temp_1 = (*hyb_output_real_dry + *p_buffer_re);
temp4 = (*hyb_output_imag_dry + *p_buffer_im);
*slot_nrg += (WORD64)temp_1 * (WORD64)temp_1 + (WORD64)temp4 * (WORD64)temp4;
p_buffer_re++;
p_buffer_im++;
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
slot_nrg++;
for (; qs < cnt; qs++) {
temp_1 = (*hyb_output_real_dry + *p_buffer_re);
temp4 = (*hyb_output_imag_dry + *p_buffer_im);
*slot_nrg += (WORD64)temp_1 * (WORD64)temp_1 + (WORD64)temp4 * (WORD64)temp4;
p_buffer_re++;
p_buffer_im++;
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
slot_nrg = slot_nrg_fix;
q_slot_nrg = q_slot_nrg_fix;
frame_nrg_fix = 0;
q_frame_nrg_fix = 30;
for (pb = start_p; pb <= end_p; pb++) {
*n_slot_nrg = ixheaacd_mps_narrow(*slot_nrg, q_slot_nrg);
slot_nrg++;
temp_1 = ixheaacd_mult32x16in32(*n_slot_nrg, one_min_alpha_fix);
temp4 = ixheaacd_mult32x16in32((part_nrg_fix[pb]) << 1, alpha_fix);
part_nrg_fix[pb] =
ixheaacd_mps_reshape_add32(temp4, temp_1, &q_part_nrg_fix[pb], *q_slot_nrg);
frame_nrg_fix = ixheaacd_mps_reshape_add32(frame_nrg_fix, *n_slot_nrg++,
&q_frame_nrg_fix, *q_slot_nrg++);
}
frame_nrg_fix = ixheaacd_mult32x16in32(frame_nrg_fix, one_by_nine);
temp_1 = ixheaacd_mult32x16in32(frame_nrg_fix, one_min_alpha_fix);
temp4 = ixheaacd_mult32x16in32((frame_nrg_prev) << 1, alpha_fix);
frame_nrg_fix =
ixheaacd_mps_reshape_add32(temp_1, temp4, &q_frame_nrg_fix, q_frame_nrg_prev);
frame_nrg_prev = frame_nrg_fix;
q_frame_nrg_prev = q_frame_nrg_fix;
env_fix_l = 0;
q_env_fix_l = 30;
q_slot_nrg = q_slot_nrg_fix;
n_slot_nrg -= PB_OFFSET;
for (pb = start_p; pb <= end_p; pb++) {
temp_1 = ixheaacd_mps_div_32(*n_slot_nrg++, part_nrg_fix[pb], &qtemp1);
qtemp1 = *q_slot_nrg++ + qtemp1 - q_part_nrg_fix[pb];
env_fix_l = ixheaacd_mps_reshape_add32(env_fix_l, temp_1, &q_env_fix_l, qtemp1);
}
n_slot_nrg -= PB_OFFSET;
env_fix_l =
ixheaacd_mps_mult32x32(env_fix_l, frame_nrg_fix, &q_env_fix_l, q_frame_nrg_fix);
temp_1 = ixheaacd_mult32x16in32(env_fix_l, one_min_beta_fix);
temp4 = ixheaacd_mult32x16in32((*norm_nrg_fix) << 1, beta_fix);
*norm_nrg_fix = ixheaacd_mps_reshape_add32(temp4, temp_1, q_norm_nrg_fix, q_env_fix_l);
if (flag) {
temp_1 = ixheaacd_mps_div_32(env_fix_l, *norm_nrg_fix, &qtemp1);
q_env = q_env_fix_l + qtemp1 - *q_norm_nrg_fix;
env[ts] = ixheaacd_mps_sqrt(temp_1, &(q_env), sqrt_tab);
env[ts] = ixheaacd_mps_convert_to_qn(env[ts], q_env, 15);
}
p_buffer_real += MAX_HYBRID_BANDS;
p_buffer_imag += MAX_HYBRID_BANDS;
p_hyb_out_dry_real += MAX_HYBRID_BANDS;
p_hyb_out_dry_imag += MAX_HYBRID_BANDS;
}
reshape_bb_env_state->frame_nrg_prev[ch] = frame_nrg_prev;
reshape_bb_env_state->q_frame_nrg_prev[ch] = q_frame_nrg_prev;
break;
case INP_DMX:
prev_ch_offs = ch + pstr_mps_state->num_output_channels;
frame_nrg_prev = reshape_bb_env_state->frame_nrg_prev[prev_ch_offs];
q_frame_nrg_prev = reshape_bb_env_state->q_frame_nrg_prev[prev_ch_offs];
part_nrg_fix = &reshape_bb_env_state->part_nrg_prev[prev_ch_offs][0];
q_part_nrg_fix = &reshape_bb_env_state->q_part_nrg_prev[prev_ch_offs][0];
norm_nrg_fix = &reshape_bb_env_state->norm_nrg_prev[prev_ch_offs];
q_norm_nrg_fix = &reshape_bb_env_state->q_norm_nrg_prev[prev_ch_offs];
p_buffer_real = pstr_mps_state->array_struct->x_real + ch * TSXHB + 12;
p_buffer_imag = pstr_mps_state->array_struct->x_imag + ch * TSXHB + 12;
for (ts = 0; ts < time_slots; ts++) {
WORD32 prev_idx;
slot_nrg = slot_nrg_fix + 4;
for (pb = 14; pb <= end_p; pb++) *slot_nrg++ = 0;
slot_nrg = slot_nrg_fix;
hyb_output_real_dry = p_buffer_real;
hyb_output_imag_dry = p_buffer_imag;
for (qs = 12; qs < 16; qs++) {
*slot_nrg++ = ((WORD64)(*hyb_output_real_dry) * (WORD64)(*hyb_output_real_dry)) +
((WORD64)(*hyb_output_imag_dry) * (WORD64)(*hyb_output_imag_dry));
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
prev_idx = 14;
for (; qs < 30; qs++) {
WORD32 idx = bb_env_kernels[qs];
if (prev_idx != idx) {
slot_nrg++;
prev_idx = idx;
}
*slot_nrg += ((WORD64)(*hyb_output_real_dry) * (WORD64)(*hyb_output_real_dry)) +
((WORD64)(*hyb_output_imag_dry) * (WORD64)(*hyb_output_imag_dry));
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
slot_nrg++;
for (; qs < cnt; qs++) {
*slot_nrg += ((WORD64)(*hyb_output_real_dry) * (WORD64)(*hyb_output_real_dry)) +
((WORD64)(*hyb_output_imag_dry) * (WORD64)(*hyb_output_imag_dry));
hyb_output_real_dry++;
hyb_output_imag_dry++;
}
slot_nrg = slot_nrg_fix;
q_slot_nrg = q_slot_nrg_fix;
frame_nrg_fix = 0;
q_frame_nrg_fix = 30;
for (pb = start_p; pb <= end_p; pb++) {
*n_slot_nrg = ixheaacd_mps_narrow(*slot_nrg, q_slot_nrg);
slot_nrg++;
temp_1 = ixheaacd_mult32x16in32(*n_slot_nrg, one_min_alpha_fix);
temp4 = ixheaacd_mult32x16in32((part_nrg_fix[pb]) << 1, alpha_fix);
part_nrg_fix[pb] =
ixheaacd_mps_reshape_add32(temp4, temp_1, &q_part_nrg_fix[pb], *q_slot_nrg);
frame_nrg_fix = ixheaacd_mps_reshape_add32(frame_nrg_fix, *n_slot_nrg++,
&q_frame_nrg_fix, *q_slot_nrg++);
}
frame_nrg_fix = ixheaacd_mult32x16in32(frame_nrg_fix, one_by_nine);
temp_1 = ixheaacd_mult32x16in32(frame_nrg_fix, one_min_alpha_fix);
temp4 = ixheaacd_mult32x16in32((frame_nrg_prev) << 1, alpha_fix);
frame_nrg_fix =
ixheaacd_mps_reshape_add32(temp_1, temp4, &q_frame_nrg_fix, q_frame_nrg_prev);
frame_nrg_prev = frame_nrg_fix;
q_frame_nrg_prev = q_frame_nrg_fix;
env_fix_l = 0;
q_env_fix_l = 30;
q_slot_nrg = q_slot_nrg_fix;
n_slot_nrg -= PB_OFFSET;
for (pb = start_p; pb <= end_p; pb++) {
temp_1 = ixheaacd_mps_div_32(*n_slot_nrg++, part_nrg_fix[pb], &qtemp1);
qtemp1 = *q_slot_nrg++ + qtemp1 - q_part_nrg_fix[pb];
env_fix_l = ixheaacd_mps_reshape_add32(env_fix_l, temp_1, &q_env_fix_l, qtemp1);
}
n_slot_nrg -= PB_OFFSET;
env_fix_l =
ixheaacd_mps_mult32x32(env_fix_l, frame_nrg_fix, &q_env_fix_l, q_frame_nrg_fix);
temp_1 = ixheaacd_mult32x16in32(env_fix_l, one_min_beta_fix);
temp4 = ixheaacd_mult32x16in32((*norm_nrg_fix) << 1, beta_fix);
*norm_nrg_fix = ixheaacd_mps_reshape_add32(temp4, temp_1, q_norm_nrg_fix, q_env_fix_l);
temp_1 = ixheaacd_mps_div_32(env_fix_l, *norm_nrg_fix, &qtemp1);
q_env = q_env_fix_l + qtemp1 - *q_norm_nrg_fix;
env[ts] = ixheaacd_mps_sqrt(temp_1, &(q_env), sqrt_tab);
env[ts] = ixheaacd_mps_convert_to_qn(env[ts], q_env, 15);
p_buffer_real += MAX_HYBRID_BANDS;
p_buffer_imag += MAX_HYBRID_BANDS;
}
reshape_bb_env_state->frame_nrg_prev[prev_ch_offs] = frame_nrg_prev;
reshape_bb_env_state->q_frame_nrg_prev[prev_ch_offs] = q_frame_nrg_prev;
break;
default:
break;
}
return;
}
VOID ixheaacd_reshape_bb_env(ia_heaac_mps_state_struct *pstr_mps_state) {
WORD32 *env_dry;
WORD32 *env_dmx_0, *env_dmx_1;
WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im;
WORD32 *hyb_output_real_wet, *hyb_output_imag_wet;
WORD32 temp_1, temp_2;
WORD16 qtemp1, qtemp2;
WORD32 tmp, dry_fac, slot_amp_dry, slot_amp_wet;
WORD16 q_dry_fac, q_slot_amp_dry, q_slot_amp_wet;
WORD32 slot_amp_ratio;
WORD16 q_slot_amp_ratio;
WORD32 ch, ch2, ts, qs;
WORD32 *hyb_output_real_dry, *hyb_out_dry_real;
WORD32 *hyb_output_imag_dry, *hyb_out_dry_imag;
WORD64 *inter;
VOID *free_scratch;
const WORD32 *sqrt_tab = pstr_mps_state->ia_mps_dec_mps_table.common_table_ptr->sqrt_tab;
ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;
WORD32 *temp_shape_enable_channel_ges = p_aux_struct->temp_shape_enable_channel_ges;
WORD32 start_hsb;
WORD32 time_slots = pstr_mps_state->time_slots;
WORD32 num_output_channels = pstr_mps_state->num_output_channels;
WORD32 tree_config = pstr_mps_state->tree_config;
WORD32 hybrid_bands = pstr_mps_state->hybrid_bands;
const WORD32 *ch_idx = &pstr_mps_state->ia_mps_dec_mps_table.m1_m2_table_ptr->idx_table
.row_2_channel_ges[tree_config][0];
WORD64 acc, acc2;
start_hsb = 6;
free_scratch = pstr_mps_state->mps_scratch_mem_v;
env_dry = free_scratch;
env_dmx_0 = pstr_mps_state->array_struct->env_dmx_0;
env_dmx_1 = pstr_mps_state->array_struct->env_dmx_1;
inter = (WORD64 *)((WORD8 *)free_scratch + MAX_TIME_SLOTSX12);
free_scratch = inter + MAX_TIME_SLOTS;
p_buffer_real = pstr_mps_state->array_struct->buf_real + start_hsb;
p_buffer_imag = pstr_mps_state->array_struct->buf_imag + start_hsb;
for (ch = 0; ch < num_output_channels; ch++) {
ch2 = ch_idx[ch];
if (ch2 == -1) continue;
p_buffer_re = p_buffer_real;
p_buffer_im = p_buffer_imag;
ixheaacd_extract_bb_env(pstr_mps_state, INP_DRY_WET, ch, env_dry, free_scratch,
temp_shape_enable_channel_ges[ch2]);
if (temp_shape_enable_channel_ges[ch2]) {
WORD32 *env = &p_aux_struct->env_shape_data[ch2][0];
switch (tree_config) {
case TREE_5151:
case TREE_5152:
for (ts = 0; ts < time_slots; ts++) {
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)env_dmx_0[ts]);
}
break;
case TREE_525:
case TREE_7271:
case TREE_7272:
switch (ch2) {
case 0:
case 3:
case 5:
for (ts = 0; ts < time_slots; ts++) {
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)env_dmx_0[ts]);
}
break;
case 1:
case 4:
case 6:
for (ts = 0; ts < time_slots; ts++) {
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)env_dmx_1[ts]);
}
break;
case 2:
for (ts = 0; ts < time_slots; ts++) {
temp_2 = (env_dmx_0[ts] + env_dmx_1[ts]) >> 1;
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)temp_2);
}
break;
default:
break;
}
break;
case TREE_7571:
case TREE_7572:
switch (ch2) {
case 0:
case 2:
for (ts = 0; ts < time_slots; ts++) {
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)env_dmx_0[ts]);
}
break;
case 1:
case 3:
for (ts = 0; ts < time_slots; ts++) {
inter[ts] = (WORD64)((WORD64)*env++ * (WORD64)env_dmx_1[ts]);
}
break;
default:
break;
}
default:
break;
}
hyb_out_dry_real =
pstr_mps_state->array_struct->hyb_output_real_dry + ch * TSXHB + start_hsb;
hyb_out_dry_imag =
pstr_mps_state->array_struct->hyb_output_imag_dry + ch * TSXHB + start_hsb;
for (ts = 0; ts < time_slots; ts++) {
tmp = ixheaacd_mps_narrow(inter[ts], &qtemp1);
if (env_dry[ts] == 0) {
q_dry_fac = 0;
dry_fac = MAX_32;
} else {
dry_fac = ixheaacd_mps_div_32(tmp, env_dry[ts], &q_dry_fac);
q_dry_fac += qtemp1 - 5;
}
hyb_output_real_wet = p_buffer_re;
hyb_output_imag_wet = p_buffer_im;
hyb_output_real_dry = hyb_out_dry_real;
hyb_output_imag_dry = hyb_out_dry_imag;
acc = 0;
acc2 = 0;
for (qs = start_hsb; qs < hybrid_bands; qs++) {
acc += (WORD64)(*hyb_output_real_dry) * (WORD64)(*hyb_output_real_dry);
hyb_output_real_dry++;
acc += (WORD64)(*hyb_output_imag_dry) * (WORD64)(*hyb_output_imag_dry);
hyb_output_imag_dry++;
acc2 += (WORD64)(*hyb_output_real_wet) * (WORD64)(*hyb_output_real_wet);
hyb_output_real_wet++;
acc2 += (WORD64)(*hyb_output_imag_wet) * (WORD64)(*hyb_output_imag_wet);
hyb_output_imag_wet++;
}
slot_amp_dry = ixheaacd_mps_narrow(acc, &q_slot_amp_dry);
slot_amp_wet = ixheaacd_mps_narrow(acc2, &q_slot_amp_wet);
qtemp1 = q_slot_amp_dry;
temp_1 = ixheaacd_mps_add32(slot_amp_dry, ABS_THR_FIX, &qtemp1, 15);
temp_2 = ixheaacd_mps_div_32(slot_amp_wet, temp_1, &qtemp2);
q_slot_amp_ratio = qtemp2 + q_slot_amp_wet - qtemp1;
slot_amp_ratio = ixheaacd_mps_sqrt(temp_2, &q_slot_amp_ratio, sqrt_tab);
temp_1 = ixheaacd_mps_convert_to_qn(dry_fac, q_dry_fac, 15);
temp_1 -= ONE_IN_Q15;
temp_1 = ixheaacd_mps_mult32_shr_16(temp_1, slot_amp_ratio);
q_slot_amp_ratio -= 1;
temp_1 = ixheaacd_mps_add32(temp_1, dry_fac, &q_slot_amp_ratio, q_dry_fac);
temp_1 = ixheaacd_mps_convert_to_qn(temp_1, q_slot_amp_ratio, 15);
temp_1 = max(ONE_IN_Q13, temp_1);
dry_fac = min(FOUR_IN_Q15, temp_1);
hyb_output_real_dry = hyb_out_dry_real;
hyb_output_imag_dry = hyb_out_dry_imag;
for (qs = start_hsb; qs < hybrid_bands; qs++) {
*hyb_output_real_dry = ixheaacd_mps_mult32_shr_15(*hyb_output_real_dry, dry_fac);
hyb_output_real_dry++;
*hyb_output_imag_dry = ixheaacd_mps_mult32_shr_15(*hyb_output_imag_dry, dry_fac);
hyb_output_imag_dry++;
}
p_buffer_re += MAX_HYBRID_BANDS;
p_buffer_im += MAX_HYBRID_BANDS;
hyb_out_dry_real += MAX_HYBRID_BANDS;
hyb_out_dry_imag += MAX_HYBRID_BANDS;
}
}
p_buffer_real += TSXHB;
p_buffer_imag += TSXHB;
}
return;
}
VOID ixheaacd_pre_reshape_bb_env(ia_heaac_mps_state_struct *pstr_mps_state) {
WORD32 *env_dmx_0, *env_dmx_1;
VOID *free_scratch;
WORD32 tree_config = pstr_mps_state->tree_config;
free_scratch = pstr_mps_state->mps_scratch_mem_v;
env_dmx_0 = pstr_mps_state->array_struct->env_dmx_0;
env_dmx_1 = pstr_mps_state->array_struct->env_dmx_1;
switch (tree_config) {
case TREE_7572:
ixheaacd_extract_bb_env(pstr_mps_state, INP_DMX, 0 + 4, env_dmx_0, free_scratch, 0);
ixheaacd_extract_bb_env(pstr_mps_state, INP_DMX, 1 + 4, env_dmx_1, free_scratch, 0);
break;
default:
ixheaacd_extract_bb_env(pstr_mps_state, INP_DMX, 0, env_dmx_0, free_scratch, 0);
if (min(pstr_mps_state->num_input_channels, 2) == 2) {
ixheaacd_extract_bb_env(pstr_mps_state, INP_DMX, 1, env_dmx_1, free_scratch, 0);
}
}
return;
}
Reference in New Issue View Git Blame Copy Permalink