1 /******************************************************************************
2 * *
3 * Copyright (C) 2018 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 #include <math.h>
21 #include "ixheaac_type_def.h"
22 #include "ixheaac_constants.h"
23 #include "ixheaacd_bitbuffer.h"
24 #include "ixheaacd_common_rom.h"
25 #include "ixheaacd_sbrdecsettings.h"
26 #include "ixheaacd_sbr_scale.h"
27 #include "ixheaacd_env_extr_part.h"
28 #include "ixheaacd_sbr_rom.h"
29 #include "ixheaacd_config.h"
30 #include "ixheaacd_hybrid.h"
31 #include "ixheaacd_ps_dec.h"
32 #include "ixheaacd_qmf_dec.h"
33 #include "ixheaacd_mps_polyphase.h"
34 #include "ixheaacd_mps_struct_def.h"
35 #include "ixheaacd_mps_res_rom.h"
36 #include "ixheaacd_mps_aac_struct.h"
37 #include "ixheaacd_mps_dec.h"
38 #include "ixheaacd_mps_process.h"
39 #include "ixheaacd_lpp_tran.h"
40 #include "ixheaacd_env_extr.h"
41 #include "ixheaacd_env_calc.h"
42 #include "ixheaac_sbr_const.h"
43 #include "ixheaacd_pvc_dec.h"
44 #include "ixheaacd_sbr_dec.h"
45 #include "ixheaacd_audioobjtypes.h"
46 #include "ixheaac_basic_ops32.h"
47 #include "ixheaac_basic_ops40.h"
48 #include "ixheaacd_mps_bitdec.h"
49 #include "ixheaacd_mps_macro_def.h"
50 #include "ixheaacd_mps_get_index.h"
51 #include "ixheaacd_mps_basic_op.h"
52 #include "ixheaacd_mps_tp_process.h"
53 #include "ixheaacd_error_codes.h"
54 #define HP_SIZE (9)
55
56 #define STP_LPF_COEFF1 (0.950f)
57 #define STP_LPF_COEFF2 (0.450f)
58 #define STP_UPDATE_ENERGY_RATE (32)
59 #define STP_SCALE_LIMIT (2.82f)
60 #define STP_DAMP (0.1f)
61
62 static const FLOAT32 ixheaacd_bp[BP_SIZE] = {
63 0.0000f, 0.0005f, 0.0092f, 0.0587f, 0.2580f, 0.7392f, 0.9791f,
64 0.9993f, 1.0000f, 1.0000f, 1.0000f, 1.0000f, 0.9999f, 0.9984f,
65 0.9908f, 0.9639f, 0.8952f, 0.7711f, 0.6127f, 0.4609f, 0.3391f,
66 0.2493f, 0.1848f, 0.1387f, 0.1053f};
67
68 static const FLOAT32 ixheaacd_gf[BP_SIZE] = {
69 0.f, 0.f, 0.f, 0.f, 0.f,
70 0.f, 1e-008f, 8.1e-007f, 3.61e-006f, 8.41e-006f,
71 1.6e-005f, 2.704e-005f, 3.969e-005f, 5.625e-005f, 7.396e-005f,
72 9.801e-005f, 0.00012321f, 0.00015625f, 0.00019881f, 0.00024964f,
73 0.00032041f, 0.00041209f, 0.00053824f, 0.00070756f, 0.00094249f};
74
75 extern const WORD32 ixheaacd_mps_gain_set_indx[29];
76
ixheaacd_mps_temp_process_scale_calc(ia_mps_dec_state_struct * self,WORD32 ts,FLOAT32 * scale)77 static VOID ixheaacd_mps_temp_process_scale_calc(ia_mps_dec_state_struct* self,
78 WORD32 ts, FLOAT32* scale) {
79 FLOAT32 dir_energy;
80 FLOAT32 diff_energy[2];
81 FLOAT32 temp;
82
83 WORD32 ch, n;
84 WORD32 left_ch = 0, right_ch = 1;
85
86 if (self->subband_var.init_flag == 0) {
87 for (ch = 0; ch < 2; ch++) {
88 self->subband_var.tp_scale_last[ch] = 1.0f;
89 self->subband_var.nrg_diff_prev[ch] = 32768 * 32768;
90 }
91
92 self->subband_var.nrg_dir_prev = 32768 * 32768;
93 self->subband_var.init_flag = 1;
94 }
95
96 if (self->subband_var.update_old_ener == STP_UPDATE_ENERGY_RATE) {
97 self->subband_var.update_old_ener = 1;
98 self->subband_var.nrg_dir_prev = self->subband_var.nrg_dir;
99 for (ch = 0; ch < self->out_ch_count; ch++)
100 self->subband_var.nrg_diff_prev[ch] = self->subband_var.nrg_diff[ch];
101 } else
102 self->subband_var.update_old_ener++;
103
104 dir_energy = 0;
105
106 for (n = 6; n < BP_SIZE; n++) {
107 FLOAT32 dir_left_re = self->hyb_dir_out[left_ch][ts][n + 7].re;
108 FLOAT32 dir_right_re = self->hyb_dir_out[right_ch][ts][n + 7].re;
109 FLOAT32 dir_left_im = self->hyb_dir_out[left_ch][ts][n + 7].im;
110 FLOAT32 dir_right_im = self->hyb_dir_out[right_ch][ts][n + 7].im;
111
112 temp = ((dir_left_re + dir_right_re) * (dir_left_re + dir_right_re)) +
113 ((dir_left_im + dir_right_im) * (dir_left_im + dir_right_im));
114 dir_energy += temp * ixheaacd_bp[n] * ixheaacd_bp[n] * ixheaacd_gf[n] *
115 ixheaacd_gf[n];
116 }
117
118 self->subband_var.nrg_dir =
119 (FLOAT32)(STP_LPF_COEFF1 * self->subband_var.nrg_dir +
120 (1.0 - STP_LPF_COEFF1) * dir_energy);
121
122 dir_energy /= (self->subband_var.nrg_dir_prev + ABS_THR);
123
124 for (ch = 0; ch < self->out_ch_count; ch++) {
125 diff_energy[ch] = 0;
126 for (n = 6; n < BP_SIZE; n++) {
127 FLOAT32 diff_re = self->hyb_diff_out[ch][ts][n + 7].re;
128 FLOAT32 diff_im = self->hyb_diff_out[ch][ts][n + 7].im;
129
130 temp = (diff_re * diff_re) + (diff_im * diff_im);
131 diff_energy[ch] += temp * ixheaacd_bp[n] * ixheaacd_bp[n] *
132 ixheaacd_gf[n] * ixheaacd_gf[n];
133 }
134
135 self->subband_var.nrg_diff[ch] =
136 (FLOAT32)(STP_LPF_COEFF1 * self->subband_var.nrg_diff[ch] +
137 (1.0 - STP_LPF_COEFF1) * diff_energy[ch]);
138 diff_energy[ch] /= (self->subband_var.nrg_diff_prev[ch] + ABS_THR);
139 }
140
141 scale[left_ch] = (FLOAT32)sqrt((dir_energy) / (diff_energy[left_ch] + 1e-9));
142 scale[right_ch] =
143 (FLOAT32)sqrt((dir_energy) / (diff_energy[right_ch] + 1e-9));
144
145 for (ch = 0; ch < self->out_ch_count; ch++) {
146 scale[ch] = STP_DAMP + (1 - STP_DAMP) * scale[ch];
147 }
148
149 for (ch = 0; ch < self->out_ch_count; ch++) {
150 scale[ch] =
151 min(max(scale[ch], (FLOAT32)(1.0 / STP_SCALE_LIMIT)), STP_SCALE_LIMIT);
152 }
153
154 for (ch = 0; ch < self->out_ch_count; ch++) {
155 scale[ch] =
156 (FLOAT32)(STP_LPF_COEFF2 * scale[ch] +
157 (1.0 - STP_LPF_COEFF2) * self->subband_var.tp_scale_last[ch]);
158 self->subband_var.tp_scale_last[ch] = scale[ch];
159 }
160 }
161
ixheaacd_mps_subbandtp(ia_mps_dec_state_struct * self,WORD32 ts)162 static VOID ixheaacd_mps_subbandtp(ia_mps_dec_state_struct* self, WORD32 ts) {
163 FLOAT32 scale[2];
164 WORD32 ch, n;
165 WORD32 no_scaling;
166 FLOAT32 temp;
167 const WORD32 ixheaacd_hybrid_to_qmf_map[] = {0, 0, 0, 0, 0, 0, 1, 1, 2, 2};
168 const WORD32 ixheaacd_hybrid_to_qmf_map_ldmps[] = {0, 1, 2};
169 const WORD32* ptr_ixheaacd_hybrid_to_qmf_map;
170 WORD32 loop_counter = 0;
171
172 if (self->ldmps_config.ldmps_present_flag) {
173 ptr_ixheaacd_hybrid_to_qmf_map = ixheaacd_hybrid_to_qmf_map_ldmps;
174 loop_counter = 3;
175 } else {
176 ptr_ixheaacd_hybrid_to_qmf_map = ixheaacd_hybrid_to_qmf_map;
177 loop_counter = 10;
178 }
179
180 ixheaacd_mps_temp_process_scale_calc(self, ts, scale);
181
182 for (ch = 0; ch < self->out_ch_count; ch++) {
183 no_scaling = 1;
184
185 if ((self->config->bs_temp_shape_config == 1) ||
186 (self->config->bs_temp_shape_config == 2))
187 no_scaling = !self->temp_shape_enable_ch_stp[ch];
188
189 if (no_scaling == 1) {
190 for (n = 0; n < self->hyb_band_count_max; n++) {
191 self->hyb_dir_out[ch][ts][n].re += self->hyb_diff_out[ch][ts][n].re;
192 self->hyb_dir_out[ch][ts][n].im += self->hyb_diff_out[ch][ts][n].im;
193 }
194 } else {
195 if (self->ldmps_config.ldmps_present_flag) {
196 for (n = 0; n < 3; n++) {
197 temp = (FLOAT32)(scale[ch] *
198 ixheaacd_bp[ptr_ixheaacd_hybrid_to_qmf_map[n]]);
199 self->hyb_dir_out[ch][ts][n].re +=
200 (self->hyb_diff_out[ch][ts][n].re * temp);
201 self->hyb_dir_out[ch][ts][n].im +=
202 (self->hyb_diff_out[ch][ts][n].im * temp);
203 }
204 } else {
205 for (n = 0; n < loop_counter; n++) {
206 temp = (FLOAT32)(scale[ch] *
207 ixheaacd_bp[ptr_ixheaacd_hybrid_to_qmf_map[n]]);
208 self->hyb_dir_out[ch][ts][n].re +=
209 (self->hyb_diff_out[ch][ts][n].re * temp);
210 self->hyb_dir_out[ch][ts][n].im +=
211 (self->hyb_diff_out[ch][ts][n].im * temp);
212 }
213 }
214 for (n = 7; n < HP_SIZE - 3 + 10; n++) {
215 temp = (FLOAT32)(scale[ch] * ixheaacd_bp[n + 3 - 10]);
216 self->hyb_dir_out[ch][ts][n].re +=
217 (self->hyb_diff_out[ch][ts][n].re * temp);
218 self->hyb_dir_out[ch][ts][n].im +=
219 (self->hyb_diff_out[ch][ts][n].im * temp);
220 }
221 for (; n < self->hyb_band_count_max; n++) {
222 temp = (FLOAT32)(scale[ch]);
223 self->hyb_dir_out[ch][ts][n].re +=
224 (self->hyb_diff_out[ch][ts][n].re * temp);
225 self->hyb_dir_out[ch][ts][n].im +=
226 (self->hyb_diff_out[ch][ts][n].im * temp);
227 }
228 }
229 }
230 }
231
ixheaacd_mps_temp_process(ia_mps_dec_state_struct * self)232 WORD32 ixheaacd_mps_temp_process(ia_mps_dec_state_struct* self) {
233 WORD32 ch, ts, hyb;
234 WORD32 err = 0;
235 ia_sbr_frame_info_data_struct* ptr_frame_data =
236 (ia_sbr_frame_info_data_struct*)self->p_sbr_frame[0];
237 if (self->res_bands != 28) {
238 if (self->config->bs_temp_shape_config == 1) {
239 WORD32 dif_s = ((self->res_bands == 0)
240 ? 0
241 : ixheaacd_mps_gain_set_indx[self->res_bands]);
242 for (ch = 0; ch < self->out_ch_count; ch++) {
243 for (ts = 0; ts < self->time_slots; ts++) {
244 for (hyb = dif_s; hyb < HYBRID_BAND_BORDER; hyb++) {
245 self->hyb_dir_out[ch][ts][hyb].re +=
246 self->hyb_diff_out[ch][ts][hyb].re;
247 self->hyb_dir_out[ch][ts][hyb].im +=
248 self->hyb_diff_out[ch][ts][hyb].im;
249 self->hyb_diff_out[ch][ts][hyb].re = 0;
250 self->hyb_diff_out[ch][ts][hyb].im = 0;
251 }
252 }
253 }
254
255 for (ts = 0; ts < self->time_slots; ts++)
256 ixheaacd_mps_subbandtp(self, ts);
257
258 } else {
259 WORD32 dif_s = ((self->res_bands == 0)
260 ? 0
261 : ixheaacd_mps_gain_set_indx[self->res_bands]);
262 for (ch = 0; ch < self->out_ch_count; ch++) {
263 for (ts = 0; ts < self->time_slots; ts++) {
264 for (hyb = dif_s; hyb < self->hyb_band_count_max; hyb++) {
265 self->hyb_dir_out[ch][ts][hyb].re +=
266 self->hyb_diff_out[ch][ts][hyb].re;
267 self->hyb_dir_out[ch][ts][hyb].im +=
268 self->hyb_diff_out[ch][ts][hyb].im;
269 }
270 }
271 }
272 }
273 }
274
275 ixheaacd_mps_qmf_hyb_synthesis(self);
276
277 if (self->ldmps_config.ldmps_present_flag != 1) {
278 for (ch = 0; ch < self->out_ch_count; ch++) {
279 err =
280 ixheaacd_sbr_dec_from_mps(&self->qmf_out_dir[ch][0][0].re, self->p_sbr_dec[ch],
281 self->p_sbr_frame[ch], self->p_sbr_header[ch], self->ec_flag);
282 if (err) return err;
283 }
284 }
285
286 if (self->object_type == AOT_ER_AAC_ELD || self->object_type == AOT_ER_AAC_LD)
287 self->synth_count = self->hyb_band_count[0];
288 else
289 {
290 if (ptr_frame_data->mps_sbr_flag) {
291 self->synth_count =
292 ptr_frame_data->pstr_sbr_header->pstr_freq_band_data->sub_band_end;
293 }
294 else {
295 self->synth_count = self->band_count[0];
296 }
297 }
298
299 ixheaacd_mps_synt_calc(self);
300 return err;
301 }
302
ixheaacd_subband_tp(ia_heaac_mps_state_struct * pstr_mps_state,WORD32 ts)303 static VOID ixheaacd_subband_tp(ia_heaac_mps_state_struct *pstr_mps_state, WORD32 ts) {
304 ia_mps_dec_tp_process_tables_struct *tp_process_table_ptr =
305 pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr;
306 const WORD32 *sqrt_tab =
307 pstr_mps_state->ia_mps_dec_mps_table.common_table_ptr->sqrt_tab;
308 ia_mps_dec_subband_tp_params_struct *sub_band_tp =
309 pstr_mps_state->mps_persistent_mem.sub_band_params;
310 ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct;
311
312 WORD32 temp_1, temp_2;
313 WORD16 qtemp1, qtemp2;
314 WORD32 *qmf_output_real_dry;
315 WORD32 *qmf_output_imag_dry;
316 WORD32 *qmf_output_real_wet;
317 WORD32 *qmf_output_imag_wet;
318
319 WORD32 *dmx_real;
320 WORD32 *dmx_imag;
321 WORD32 *dry_ener;
322 WORD32 *wet_ener;
323 WORD16 *q_dry_ener;
324 WORD16 *q_wet_ener;
325
326 WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im;
327 WORD32 *p_buf_real, *p_buf_imag, *p_buf_re, *p_buf_im;
328 WORD32 *scale;
329 WORD16 *q_scale;
330 WORD32 damp, one_minus_damp;
331 WORD32 temp;
332
333 WORD32 *prev_tp_scale = sub_band_tp->prev_tp_scale;
334
335 WORD32 *old_wet_ener = sub_band_tp->old_wet_ener;
336 WORD16 *q_old_wet_ener = sub_band_tp->q_old_wet_ener;
337
338 WORD32 *run_wet_ener = sub_band_tp->run_wet_ener;
339 WORD16 *q_run_wet_ener = sub_band_tp->q_run_wet_ener;
340
341 WORD32 *old_dry_ener = sub_band_tp->old_dry_ener;
342 WORD16 *q_old_dry_ener = sub_band_tp->q_old_dry_ener;
343
344 WORD32 *run_dry_ener = sub_band_tp->run_dry_ener;
345 WORD16 *q_run_dry_ener = sub_band_tp->q_run_dry_ener;
346
347 WORD32 *hyb_output_real_dry, *hyb_output_imag_dry;
348
349 WORD32 *p_hyb_out_dry_real, *p_hyb_out_dry_imag;
350
351 WORD32 ch, n, no_scaling, i, k = 0, offset;
352 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;
353
354 WORD32 loop_counter = 0;
355
356 WORD32 num_input_channels = pstr_mps_state->num_input_channels;
357 WORD32 num_output_channels = pstr_mps_state->num_output_channels;
358 WORD32 hybrid_bands = pstr_mps_state->hybrid_bands;
359
360 WORD32 tree_config = pstr_mps_state->tree_config;
361
362 dry_ener = pstr_mps_state->mps_scratch_mem_v;
363 q_dry_ener = (WORD16 *)pstr_mps_state->mps_scratch_mem_v +
364 IXHEAAC_GET_SIZE_ALIGNED_TYPE(INPUT_CHX2, sizeof(*q_dry_ener), BYTE_ALIGN_8);
365
366 wet_ener =
367 dry_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(INPUT_CHX1_5, sizeof(*wet_ener), BYTE_ALIGN_8);
368 q_wet_ener = q_dry_ener +
369 IXHEAAC_GET_SIZE_ALIGNED_TYPE(IN_CH_2XOUT_CH, sizeof(*q_wet_ener), BYTE_ALIGN_8);
370
371 scale = wet_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX1_5, sizeof(*scale), BYTE_ALIGN_8);
372 q_scale =
373 q_wet_ener + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX3, sizeof(*q_scale), BYTE_ALIGN_8);
374
375 dmx_real =
376 scale + IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUTPUT_CHX1_5, sizeof(*dmx_real), BYTE_ALIGN_8);
377 dmx_imag =
378 dmx_real + IXHEAAC_GET_SIZE_ALIGNED_TYPE(IN_CHXBP_SIZE, sizeof(*dmx_imag), BYTE_ALIGN_8);
379
380 qmf_output_real_dry = dmx_imag + IXHEAAC_GET_SIZE_ALIGNED_TYPE(
381 IN_CHXBP_SIZE, sizeof(*qmf_output_real_dry), BYTE_ALIGN_8);
382
383 qmf_output_imag_dry =
384 qmf_output_real_dry +
385 IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_imag_dry), BYTE_ALIGN_8);
386
387 qmf_output_real_wet =
388 qmf_output_imag_dry +
389 IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_real_wet), BYTE_ALIGN_8);
390
391 qmf_output_imag_wet =
392 qmf_output_real_wet +
393 IXHEAAC_GET_SIZE_ALIGNED_TYPE(OUT_CHXQB, sizeof(*qmf_output_imag_wet), BYTE_ALIGN_8);
394
395 if (sub_band_tp->update_old_ener == STP_UPDATE_ENERGY_RATE) {
396 sub_band_tp->update_old_ener = 1;
397 for (ch = 0; ch < num_input_channels; ch++) {
398 old_dry_ener[ch] = run_dry_ener[ch];
399 q_old_dry_ener[ch] = q_run_dry_ener[ch];
400 }
401 for (ch = 0; ch < num_output_channels; ch++) {
402 old_wet_ener[ch] = run_wet_ener[ch];
403 q_old_wet_ener[ch] = q_run_wet_ener[ch];
404 }
405 } else
406 sub_band_tp->update_old_ener++;
407
408 for (ch = 0; ch < MAX_OUTPUT_CHANNELS_MPS; ch++) {
409 scale[ch] = ONE_IN_Q15;
410 q_scale[ch] = 15;
411 }
412
413 switch (tree_config) {
414 case TREE_5151:
415 i_lf = 0;
416 i_rf = 1;
417 i_c = 2;
418 i_lfe = 3;
419 i_ls = 4;
420 i_rs = 5;
421 loop_counter = 6;
422 break;
423 case TREE_5152:
424 i_lf = 0;
425 i_rf = 2;
426 i_c = 4;
427 i_lfe = 5;
428 i_ls = 1;
429 i_rs = 3;
430 loop_counter = 5;
431 break;
432 case TREE_525:
433 i_lf = 0;
434 i_rf = 2;
435 i_c = 4;
436 i_lfe = 5;
437 i_ls = 1;
438 i_rs = 3;
439 loop_counter = 4;
440 break;
441 case TREE_7271:
442 case TREE_7272:
443 case TREE_7572:
444 i_lf = 0;
445 i_rf = 3;
446 i_c = 6;
447 i_lfe = 7;
448 i_ls = 2;
449 i_rs = 5;
450 i_al = 1;
451 i_ar = 4;
452 loop_counter = 6;
453 break;
454 case TREE_7571:
455 i_lf = 0;
456 i_rf = 3;
457 i_c = 6;
458 i_lfe = 7;
459 i_ls = 2;
460 i_rs = 5;
461 i_al = 1;
462 i_ar = 4;
463 loop_counter = 5;
464 break;
465 default:
466 break;
467 }
468
469 offset = ts * MAX_HYBRID_BANDS;
470 p_buffer_real = p_array_struct->buf_real + offset + HYBRID_BAND_BORDER;
471 p_buffer_imag = p_array_struct->buf_imag + offset + HYBRID_BAND_BORDER;
472
473 for (ch = 0; ch < num_output_channels; ch++) {
474 p_buffer_re = p_buffer_real;
475 p_buffer_im = p_buffer_imag;
476
477 for (i = QMF_OUT_START_IDX; i < BP_SIZE; i++) {
478 *qmf_output_real_wet++ = *p_buffer_re++;
479 *qmf_output_imag_wet++ = *p_buffer_im++;
480 }
481 p_buffer_real += TSXHB;
482 p_buffer_imag += TSXHB;
483 }
484 i = QMF_OUT_OFFSET * num_output_channels;
485 qmf_output_real_wet -= i;
486 qmf_output_imag_wet -= i;
487
488 p_buffer_re = qmf_output_real_dry;
489 p_buffer_im = qmf_output_imag_dry;
490
491 hyb_output_real_dry =
492 p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 6;
493 hyb_output_imag_dry =
494 p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 6;
495
496 for (ch = 0; ch < loop_counter; ch++) {
497 *p_buffer_re++ = hyb_output_real_dry[0] + hyb_output_real_dry[1];
498 *p_buffer_im++ = hyb_output_imag_dry[0] + hyb_output_imag_dry[1];
499
500 hyb_output_real_dry += TSXHB;
501 hyb_output_imag_dry += TSXHB;
502 }
503
504 hyb_output_real_dry =
505 p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 8;
506 hyb_output_imag_dry =
507 p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 8;
508
509 for (ch = 0; ch < loop_counter; ch++) {
510 *p_buffer_re++ = hyb_output_real_dry[0] + hyb_output_real_dry[1];
511 *p_buffer_im++ = hyb_output_imag_dry[0] + hyb_output_imag_dry[1];
512
513 hyb_output_real_dry += TSXHB;
514 hyb_output_imag_dry += TSXHB;
515 }
516
517 p_hyb_out_dry_real =
518 p_array_struct->hyb_output_real_dry + ts * MAX_HYBRID_BANDS + 10;
519 p_hyb_out_dry_imag =
520 p_array_struct->hyb_output_imag_dry + ts * MAX_HYBRID_BANDS + 10;
521
522 for (i = 3; i < BP_SIZE; i++) {
523 hyb_output_real_dry = p_hyb_out_dry_real;
524 hyb_output_imag_dry = p_hyb_out_dry_imag;
525
526 for (ch = 0; ch < loop_counter; ch++) {
527 *p_buffer_re++ = *hyb_output_real_dry;
528 *p_buffer_im++ = *hyb_output_imag_dry;
529
530 hyb_output_real_dry += TSXHB;
531 hyb_output_imag_dry += TSXHB;
532 }
533 p_hyb_out_dry_real++;
534 p_hyb_out_dry_imag++;
535 }
536
537 for (n = 1; n < BP_SIZE; n++) {
538 switch (tree_config) {
539 case TREE_5151:
540 *dmx_real = *qmf_output_real_dry++;
541 *dmx_real += *qmf_output_real_dry++;
542 *dmx_real += *qmf_output_real_dry++;
543 qmf_output_real_dry++;
544 *dmx_real += *qmf_output_real_dry++;
545 *dmx_real += *qmf_output_real_dry++;
546
547 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
548 tp_process_table_ptr->bpxgf[n]);
549 dmx_real++;
550 dmx_real++;
551
552 break;
553 case TREE_5152:
554 *dmx_real = *qmf_output_real_dry++;
555 *dmx_real += *qmf_output_real_dry++;
556 *dmx_real += *qmf_output_real_dry++;
557 *dmx_real += *qmf_output_real_dry++;
558 *dmx_real += *qmf_output_real_dry++;
559
560 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
561 tp_process_table_ptr->bpxgf[n]);
562 dmx_real++;
563 dmx_real++;
564
565 break;
566 case TREE_525:
567 *dmx_real = *qmf_output_real_dry++;
568 *dmx_real += *qmf_output_real_dry++;
569 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
570 tp_process_table_ptr->bpxgf[n]);
571 dmx_real++;
572
573 *dmx_real = *qmf_output_real_dry++;
574 *dmx_real += *qmf_output_real_dry++;
575 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
576 tp_process_table_ptr->bpxgf[n]);
577 dmx_real++;
578
579 break;
580 case TREE_7271:
581 case TREE_7272:
582 *dmx_real = *qmf_output_real_dry++;
583 *dmx_real += *qmf_output_real_dry++;
584 *dmx_real += *qmf_output_real_dry++;
585
586 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
587 tp_process_table_ptr->bpxgf[n]);
588 dmx_real++;
589
590 *dmx_real = *qmf_output_real_dry++;
591 *dmx_real += *qmf_output_real_dry++;
592 *dmx_real += *qmf_output_real_dry++;
593
594 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
595 tp_process_table_ptr->bpxgf[n]);
596 dmx_real++;
597
598 break;
599 case TREE_7571:
600
601 *dmx_real = *qmf_output_real_dry++;
602 *dmx_real += *qmf_output_real_dry++;
603
604 qmf_output_real_dry++;
605
606 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
607 tp_process_table_ptr->bpxgf[n]);
608 dmx_real++;
609
610 *dmx_real = *qmf_output_real_dry++;
611 *dmx_real += *qmf_output_real_dry++;
612
613 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
614 tp_process_table_ptr->bpxgf[n]);
615 dmx_real++;
616
617 break;
618 case TREE_7572:
619 qmf_output_real_dry++;
620 *dmx_real = *qmf_output_real_dry++;
621 *dmx_real += *qmf_output_real_dry++;
622
623 qmf_output_real_dry++;
624 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
625 tp_process_table_ptr->bpxgf[n]);
626 dmx_real++;
627
628 *dmx_real = *qmf_output_real_dry++;
629 *dmx_real += *qmf_output_real_dry++;
630
631 *dmx_real = ixheaacd_mps_mult32_shr_30(*dmx_real,
632 tp_process_table_ptr->bpxgf[n]);
633 dmx_real++;
634
635 break;
636 default:
637 break;
638 }
639 }
640 dmx_real -= DMX_OFFSET;
641
642 for (n = 1; n < BP_SIZE; n++) {
643 switch (tree_config) {
644 case TREE_5151:
645 *dmx_imag = *qmf_output_imag_dry++;
646 *dmx_imag += *qmf_output_imag_dry++;
647 *dmx_imag += *qmf_output_imag_dry++;
648
649 qmf_output_imag_dry++;
650
651 *dmx_imag += *qmf_output_imag_dry++;
652 *dmx_imag++ += *qmf_output_imag_dry++;
653
654 dmx_imag++;
655
656 dmx_imag[0] = ixheaacd_mps_mult32_shr_30(
657 dmx_imag[0], tp_process_table_ptr->bpxgf[n]);
658 break;
659 case TREE_5152:
660
661 *dmx_imag = *qmf_output_imag_dry++;
662 *dmx_imag += *qmf_output_imag_dry++;
663 *dmx_imag += *qmf_output_imag_dry++;
664
665 *dmx_imag += *qmf_output_imag_dry++;
666 *dmx_imag++ += *qmf_output_imag_dry++;
667
668 dmx_imag++;
669
670 dmx_imag[0] = ixheaacd_mps_mult32_shr_30(
671 dmx_imag[0], tp_process_table_ptr->bpxgf[n]);
672 break;
673 case TREE_525:
674 *dmx_imag = *qmf_output_imag_dry++;
675 *dmx_imag += *qmf_output_imag_dry++;
676 *dmx_imag = ixheaacd_mps_mult32_shr_30(dmx_imag[0],
677 tp_process_table_ptr->bpxgf[n]);
678 dmx_imag++;
679
680 *dmx_imag = *qmf_output_imag_dry++;
681 *dmx_imag += *qmf_output_imag_dry++;
682 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
683 tp_process_table_ptr->bpxgf[n]);
684 dmx_imag++;
685 break;
686 case TREE_7271:
687 case TREE_7272:
688 *dmx_imag = *qmf_output_imag_dry++;
689 *dmx_imag += *qmf_output_imag_dry++;
690 *dmx_imag += *qmf_output_imag_dry++;
691 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
692 tp_process_table_ptr->bpxgf[n]);
693 dmx_imag++;
694
695 *dmx_imag = *qmf_output_imag_dry++;
696 *dmx_imag += *qmf_output_imag_dry++;
697 *dmx_imag += *qmf_output_imag_dry++;
698
699 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
700 tp_process_table_ptr->bpxgf[n]);
701 dmx_imag++;
702
703 break;
704 case TREE_7571:
705 *dmx_imag = *qmf_output_imag_dry++;
706 *dmx_imag += *qmf_output_imag_dry++;
707 qmf_output_imag_dry++;
708 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
709 tp_process_table_ptr->bpxgf[n]);
710 dmx_imag++;
711
712 *dmx_imag = *qmf_output_imag_dry++;
713 *dmx_imag += *qmf_output_imag_dry++;
714 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
715 tp_process_table_ptr->bpxgf[n]);
716 dmx_imag++;
717
718 break;
719 case TREE_7572:
720 qmf_output_imag_dry++;
721
722 *dmx_imag = *qmf_output_imag_dry++;
723 *dmx_imag += *qmf_output_imag_dry++;
724
725 qmf_output_imag_dry++;
726
727 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
728 tp_process_table_ptr->bpxgf[n]);
729 dmx_imag++;
730
731 *dmx_imag = *qmf_output_imag_dry++;
732 *dmx_imag += *qmf_output_imag_dry++;
733 *dmx_imag = ixheaacd_mps_mult32_shr_30(*dmx_imag,
734 tp_process_table_ptr->bpxgf[n]);
735 dmx_imag++;
736
737 break;
738 default:
739 break;
740 }
741 }
742 dmx_imag -= DMX_OFFSET;
743
744 for (ch = 0; ch < min(2, num_input_channels); ch++) {
745 dry_ener[ch] = 0;
746 q_dry_ener[ch] = 15;
747
748 for (n = 1; n < BP_SIZE; n++) {
749 qtemp1 = 10;
750 temp_1 = ixheaacd_mps_mult32(*dmx_real, *dmx_real, &qtemp1, qtemp1);
751 dmx_real += 2;
752 dry_ener[ch] =
753 ixheaacd_mps_add32(dry_ener[ch], temp_1, &q_dry_ener[ch], qtemp1);
754
755 qtemp1 = 10;
756 temp_1 = ixheaacd_mps_mult32(*dmx_imag, *dmx_imag, &qtemp1, qtemp1);
757 dmx_imag += 2;
758 dry_ener[ch] =
759 ixheaacd_mps_add32(dry_ener[ch], temp_1, &q_dry_ener[ch], qtemp1);
760 }
761 dmx_real -= DMX_OFFSET_MINUS_ONE;
762 dmx_imag -= DMX_OFFSET_MINUS_ONE;
763
764 temp_1 = ixheaacd_mps_mult32_shr_15(run_dry_ener[ch], STP_LPF_COEFF1_FIX);
765
766 temp_2 = ONE_IN_Q15 - STP_LPF_COEFF1_FIX;
767 temp_2 = ixheaacd_mps_mult32_shr_15(temp_2, dry_ener[ch]);
768
769 run_dry_ener[ch] = ixheaacd_mps_add32(temp_1, temp_2, &(q_run_dry_ener[ch]),
770 q_dry_ener[ch]);
771
772 qtemp1 = q_old_dry_ener[ch];
773 temp_1 = ixheaacd_mps_add32(old_dry_ener[ch], ABS_THR_FIX, &qtemp1, 15);
774 ;
775
776 dry_ener[ch] = ixheaacd_mps_div_32(dry_ener[ch], temp_1, &qtemp2);
777 q_dry_ener[ch] = qtemp2 + q_dry_ener[ch] - qtemp1;
778 }
779
780 for (ch = 0; ch < num_output_channels; ch++) {
781 if (ch == i_lfe) continue;
782 if ((tree_config >= TREE_525) && (ch == i_c)) continue;
783 if ((tree_config == TREE_7571) && ((ch == i_ls) || (ch == i_rs))) continue;
784 if ((tree_config == TREE_7572) && ((ch == i_lf) || (ch == i_rf))) continue;
785
786 wet_ener[ch] = 0;
787 q_wet_ener[ch] = 15;
788
789 wet_ener[ch] = 0;
790 q_wet_ener[ch] = 15;
791 for (n = FIVE; n < BP_SIZE; n++) {
792 qtemp1 = 10;
793 temp_1 = ixheaacd_mps_mult32(*qmf_output_real_wet, *qmf_output_real_wet,
794 &qtemp1, qtemp1);
795 qmf_output_real_wet++;
796
797 qtemp2 = 10;
798 temp_2 = ixheaacd_mps_mult32(*qmf_output_imag_wet, *qmf_output_imag_wet,
799 &qtemp2, qtemp2);
800 qmf_output_imag_wet++;
801
802 temp_1 = ixheaacd_mps_add32(temp_1, temp_2, &qtemp1, qtemp2);
803
804 temp_1 = ixheaacd_mps_mult32(temp_1, tp_process_table_ptr->bp2xgf2[n],
805 &qtemp1, 57);
806
807 wet_ener[ch] =
808 ixheaacd_mps_add32(wet_ener[ch], temp_1, &q_wet_ener[ch], qtemp1);
809 }
810 temp_1 = ixheaacd_mps_mult32_shr_15(run_wet_ener[ch], STP_LPF_COEFF1_FIX);
811
812 temp_2 = ONE_IN_Q15 - STP_LPF_COEFF1_FIX;
813
814 temp_2 = ixheaacd_mps_mult32_shr_15(temp_2, wet_ener[ch]);
815
816 run_wet_ener[ch] =
817 ixheaacd_mps_add32(temp_1, temp_2, &q_run_wet_ener[ch], q_wet_ener[ch]);
818
819 qtemp1 = q_old_wet_ener[ch];
820 temp_1 = ixheaacd_mps_add32(old_wet_ener[ch], ABS_THR_FIX, &qtemp1, 15);
821
822 wet_ener[ch] = ixheaacd_mps_div_32(wet_ener[ch], temp_1, &qtemp2);
823 q_wet_ener[ch] = qtemp2 + q_wet_ener[ch] - qtemp1;
824 }
825
826 damp = POINT_ONE_Q15;
827 one_minus_damp = POINT_NINE_Q15;
828 switch (tree_config) {
829 case TREE_5151:
830 case TREE_5152:
831 if (wet_ener[i_lf] != 0) {
832 scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2);
833 q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf];
834 } else {
835 temp_1 = ixheaac_norm32(dry_ener[0]);
836 scale[i_lf] = dry_ener[0] << temp_1;
837 q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30;
838 }
839 scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab);
840
841 if (wet_ener[i_rf] != 0) {
842 scale[i_rf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_rf], &qtemp2);
843 q_scale[i_rf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_rf];
844 } else {
845 temp_1 = ixheaac_norm32(dry_ener[0]);
846 scale[i_rf] = dry_ener[0] << temp_1;
847 q_scale[i_rf] = q_dry_ener[0] + temp_1 - 30;
848 }
849 scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab);
850
851 if (wet_ener[i_c] != 0) {
852 scale[i_c] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_c], &qtemp2);
853 q_scale[i_c] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_c];
854 } else {
855 temp_1 = ixheaac_norm32(dry_ener[0]);
856 scale[i_c] = dry_ener[0] << temp_1;
857 q_scale[i_c] = q_dry_ener[0] + temp_1 - 30;
858 }
859 scale[i_c] = ixheaacd_mps_sqrt(scale[i_c], &(q_scale[i_c]), sqrt_tab);
860
861 if (wet_ener[i_ls] != 0) {
862 scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2);
863 q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls];
864 } else {
865 temp_1 = ixheaac_norm32(dry_ener[0]);
866 scale[i_ls] = dry_ener[0] << temp_1;
867 q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30;
868 }
869 scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab);
870
871 if (wet_ener[i_rs] != 0) {
872 scale[i_rs] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_rs], &qtemp2);
873 q_scale[i_rs] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_rs];
874 } else {
875 temp_1 = ixheaac_norm32(dry_ener[0]);
876 scale[i_rs] = dry_ener[0] << temp_1;
877 q_scale[i_rs] = q_dry_ener[0] + temp_1 - 30;
878 }
879 scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab);
880
881 for (ch = 0; ch < 6; ch++) {
882 if (ch == 3 && tree_config == 0) continue;
883 temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp);
884 scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15);
885 scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15);
886 if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX;
887 if (scale[ch] < ONE_BY_STP_SCALE_LIMIT)
888 scale[ch] = ONE_BY_STP_SCALE_LIMIT;
889 }
890
891 break;
892 case TREE_525:
893 if (wet_ener[i_lf] != 0) {
894 scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2);
895 q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf];
896 } else {
897 temp_1 = ixheaac_norm32(dry_ener[0]);
898 scale[i_lf] = dry_ener[0] << temp_1;
899 q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30;
900 }
901 scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab);
902
903 if (wet_ener[i_rf] != 0) {
904 scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2);
905 q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf];
906 } else {
907 temp_1 = ixheaac_norm32(dry_ener[1]);
908 scale[i_rf] = dry_ener[1] << temp_1;
909 q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30;
910 }
911 scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab);
912
913 if (wet_ener[i_ls] != 0) {
914 scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2);
915 q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls];
916 } else {
917 temp_1 = ixheaac_norm32(dry_ener[0]);
918 scale[i_ls] = dry_ener[0] << temp_1;
919 q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30;
920 }
921 scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab);
922
923 if (wet_ener[i_rs] != 0) {
924 scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2);
925 q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs];
926 } else {
927 temp_1 = ixheaac_norm32(dry_ener[1]);
928 scale[i_rs] = dry_ener[1] << temp_1;
929 q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30;
930 }
931 scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab);
932
933 for (ch = 0; ch < 4; ch++) {
934 temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp);
935 scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15);
936 scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15);
937 if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX;
938 if (scale[ch] < ONE_BY_STP_SCALE_LIMIT)
939 scale[ch] = ONE_BY_STP_SCALE_LIMIT;
940 }
941 break;
942 case TREE_7271:
943 case TREE_7272:
944 if (wet_ener[i_lf] != 0) {
945 scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2);
946 q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf];
947 } else {
948 temp_1 = ixheaac_norm32(dry_ener[0]);
949 scale[i_lf] = dry_ener[0] << temp_1;
950 q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30;
951 }
952 scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab);
953
954 if (wet_ener[i_rf] != 0) {
955 scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2);
956 q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf];
957 } else {
958 temp_1 = ixheaac_norm32(dry_ener[1]);
959 scale[i_rf] = dry_ener[1] << temp_1;
960 q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30;
961 }
962 scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab);
963
964 if (wet_ener[i_ls] != 0) {
965 scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2);
966 q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls];
967 } else {
968 temp_1 = ixheaac_norm32(dry_ener[0]);
969 scale[i_ls] = dry_ener[0] << temp_1;
970 q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30;
971 }
972 scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab);
973
974 if (wet_ener[i_rs] != 0) {
975 scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2);
976 q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs];
977 } else {
978 temp_1 = ixheaac_norm32(dry_ener[1]);
979 scale[i_rs] = dry_ener[1] << temp_1;
980 q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30;
981 }
982 scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab);
983
984 if (wet_ener[i_al] != 0) {
985 scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2);
986 q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al];
987 } else {
988 temp_1 = ixheaac_norm32(dry_ener[0]);
989 scale[i_al] = dry_ener[0] << temp_1;
990 q_scale[i_al] = q_dry_ener[0] + temp_1 - 30;
991 }
992 scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab);
993
994 if (wet_ener[i_ar] != 0) {
995 scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2);
996 q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar];
997 } else {
998 temp_1 = ixheaac_norm32(dry_ener[1]);
999 scale[i_ar] = dry_ener[1] << temp_1;
1000 q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30;
1001 }
1002 scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab);
1003
1004 for (ch = 0; ch < 6; ch++) {
1005 temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp);
1006 scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15);
1007 scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15);
1008 if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX;
1009 if (scale[ch] < ONE_BY_STP_SCALE_LIMIT)
1010 scale[ch] = ONE_BY_STP_SCALE_LIMIT;
1011 }
1012
1013 break;
1014 case TREE_7571:
1015 if (wet_ener[i_lf] != 0) {
1016 scale[i_lf] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_lf], &qtemp2);
1017 q_scale[i_lf] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_lf];
1018 } else {
1019 temp_1 = ixheaac_norm32(dry_ener[0]);
1020 scale[i_lf] = dry_ener[0] << temp_1;
1021 q_scale[i_lf] = q_dry_ener[0] + temp_1 - 30;
1022 }
1023 scale[i_lf] = ixheaacd_mps_sqrt(scale[i_lf], &(q_scale[i_lf]), sqrt_tab);
1024
1025 if (wet_ener[i_rf] != 0) {
1026 scale[i_rf] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rf], &qtemp2);
1027 q_scale[i_rf] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rf];
1028 } else {
1029 temp_1 = ixheaac_norm32(dry_ener[1]);
1030 scale[i_rf] = dry_ener[1] << temp_1;
1031 q_scale[i_rf] = q_dry_ener[1] + temp_1 - 30;
1032 }
1033 scale[i_rf] = ixheaacd_mps_sqrt(scale[i_rf], &(q_scale[i_rf]), sqrt_tab);
1034
1035 if (wet_ener[i_al] != 0) {
1036 scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2);
1037 q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al];
1038 } else {
1039 temp_1 = ixheaac_norm32(dry_ener[0]);
1040 scale[i_al] = dry_ener[0] << temp_1;
1041 q_scale[i_al] = q_dry_ener[0] + temp_1 - 30;
1042 }
1043 scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab);
1044
1045 if (wet_ener[i_ar] != 0) {
1046 scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2);
1047 q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar];
1048 } else {
1049 temp_1 = ixheaac_norm32(dry_ener[1]);
1050 scale[i_ar] = dry_ener[1] << temp_1;
1051 q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30;
1052 }
1053 scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab);
1054 for (ch = 0; ch < FIVE; ch++) {
1055 if (ch == 2) continue;
1056 temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp);
1057 scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15);
1058 scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15);
1059 if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX;
1060 if (scale[ch] < ONE_BY_STP_SCALE_LIMIT)
1061 scale[ch] = ONE_BY_STP_SCALE_LIMIT;
1062 }
1063
1064 break;
1065 case TREE_7572:
1066 if (wet_ener[i_ls] != 0) {
1067 scale[i_ls] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_ls], &qtemp2);
1068 q_scale[i_ls] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_ls];
1069 } else {
1070 temp_1 = ixheaac_norm32(dry_ener[0]);
1071 scale[i_ls] = dry_ener[0] << temp_1;
1072 q_scale[i_ls] = q_dry_ener[0] + temp_1 - 30;
1073 }
1074 scale[i_ls] = ixheaacd_mps_sqrt(scale[i_ls], &(q_scale[i_ls]), sqrt_tab);
1075
1076 if (wet_ener[i_rs] != 0) {
1077 scale[i_rs] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_rs], &qtemp2);
1078 q_scale[i_rs] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_rs];
1079 } else {
1080 temp_1 = ixheaac_norm32(dry_ener[1]);
1081 scale[i_rs] = dry_ener[1] << temp_1;
1082 q_scale[i_rs] = q_dry_ener[1] + temp_1 - 30;
1083 }
1084 scale[i_rs] = ixheaacd_mps_sqrt(scale[i_rs], &(q_scale[i_rs]), sqrt_tab);
1085
1086 if (wet_ener[i_al] != 0) {
1087 scale[i_al] = ixheaacd_mps_div_32(dry_ener[0], wet_ener[i_al], &qtemp2);
1088 q_scale[i_al] = qtemp2 + q_dry_ener[0] - q_wet_ener[i_al];
1089 } else {
1090 temp_1 = ixheaac_norm32(dry_ener[0]);
1091 scale[i_al] = dry_ener[0] << temp_1;
1092 q_scale[i_al] = q_dry_ener[0] + temp_1 - 30;
1093 }
1094 scale[i_al] = ixheaacd_mps_sqrt(scale[i_al], &(q_scale[i_al]), sqrt_tab);
1095
1096 if (wet_ener[i_ar] != 0) {
1097 scale[i_ar] = ixheaacd_mps_div_32(dry_ener[1], wet_ener[i_ar], &qtemp2);
1098 q_scale[i_ar] = qtemp2 + q_dry_ener[1] - q_wet_ener[i_ar];
1099 } else {
1100 temp_1 = ixheaac_norm32(dry_ener[1]);
1101 scale[i_ar] = dry_ener[1] << temp_1;
1102 q_scale[i_ar] = q_dry_ener[1] + temp_1 - 30;
1103 }
1104 scale[i_ar] = ixheaacd_mps_sqrt(scale[i_ar], &(q_scale[i_ar]), sqrt_tab);
1105 for (ch = 0; ch < 6; ch++) {
1106 if (ch == 3 || ch == 0) continue;
1107 temp_1 = ixheaacd_mps_mult32_shr_15(scale[ch], one_minus_damp);
1108 scale[ch] = ixheaacd_mps_add32(temp_1, damp, &(q_scale[ch]), 15);
1109 scale[ch] = ixheaacd_mps_convert_to_qn(scale[ch], q_scale[ch], 15);
1110 if (scale[ch] > STP_SCALE_LIMIT_FIX) scale[ch] = STP_SCALE_LIMIT_FIX;
1111 if (scale[ch] < ONE_BY_STP_SCALE_LIMIT)
1112 scale[ch] = ONE_BY_STP_SCALE_LIMIT;
1113 }
1114
1115 break;
1116 default:
1117 break;
1118 }
1119
1120 for (ch = 0; ch < num_output_channels; ch++) {
1121 temp_1 = ixheaacd_mps_mult32_shr_15(STP_LPF_COEFF2_FIX, scale[ch]);
1122 temp_2 =
1123 ixheaacd_mps_mult32_shr_15(ONE_MINUS_STP_LPF_COEFF2, prev_tp_scale[ch]);
1124 scale[ch] = temp_1 + temp_2;
1125 prev_tp_scale[ch] = scale[ch];
1126 }
1127
1128 offset = ts * MAX_HYBRID_BANDS;
1129 p_buffer_real = p_array_struct->buf_real + offset + HYBRID_BAND_BORDER;
1130 p_buffer_imag = p_array_struct->buf_imag + offset + HYBRID_BAND_BORDER;
1131
1132 p_buf_real = p_array_struct->buffer_real + offset + FIVE;
1133 p_buf_imag = p_array_struct->buffer_imag + offset + FIVE;
1134
1135 p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry +
1136 ts * MAX_HYBRID_BANDS + HYBRID_BAND_BORDER;
1137 p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry +
1138 ts * MAX_HYBRID_BANDS + HYBRID_BAND_BORDER;
1139
1140 for (ch = 0; ch < num_output_channels; ch++) {
1141 no_scaling = 1;
1142
1143 ixheaacd_get_ch_idx(pstr_mps_state, ch, &i);
1144 if (i != -1) {
1145 no_scaling = !pstr_mps_state->aux_struct->temp_shape_enable_channel_stp[i];
1146 }
1147 p_buffer_re = p_buffer_real;
1148 p_buffer_im = p_buffer_imag;
1149
1150 p_buf_re = p_buf_real;
1151 p_buf_im = p_buf_imag;
1152
1153 hyb_output_real_dry = p_hyb_out_dry_real;
1154 hyb_output_imag_dry = p_hyb_out_dry_imag;
1155
1156 if (no_scaling == 1) {
1157 for (n = HYBRID_BAND_BORDER; n < (HP_SIZE + QMF_TO_HYB_OFFSET); n++) {
1158 *p_buf_re++ = *hyb_output_real_dry++ + *p_buffer_re++;
1159
1160 *p_buf_im++ = *hyb_output_imag_dry++ + *p_buffer_im++;
1161 }
1162
1163 for (; n < hybrid_bands; n++, k++) {
1164 temp = (no_scaling ? ONE_IN_Q15 : scale[ch]);
1165
1166 *p_buf_re++ = *hyb_output_real_dry++ + *p_buffer_re++;
1167
1168 *p_buf_im++ = *hyb_output_imag_dry++ + *p_buffer_im++;
1169 }
1170 } else {
1171 for (n = HYBRID_BAND_BORDER; n < (HP_SIZE + QMF_TO_HYB_OFFSET); n++) {
1172 temp = ixheaacd_mps_mult32_shr_30(
1173 scale[ch], tp_process_table_ptr->bp[n - QMF_TO_HYB_OFFSET]);
1174
1175 *p_buf_re++ = *hyb_output_real_dry++ +
1176 ixheaacd_mps_mult32_shr_15(temp, *p_buffer_re);
1177 p_buffer_re++;
1178
1179 *p_buf_im++ = *hyb_output_imag_dry++ +
1180 ixheaacd_mps_mult32_shr_15(temp, *p_buffer_im);
1181 p_buffer_im++;
1182 }
1183
1184 for (; n < hybrid_bands; n++, k++) {
1185 temp = (no_scaling ? ONE_IN_Q15 : scale[ch]);
1186
1187 *p_buf_re++ = *hyb_output_real_dry++ +
1188 ixheaacd_mps_mult32_shr_15(temp, *p_buffer_re);
1189 p_buffer_re++;
1190
1191 *p_buf_im++ = *hyb_output_imag_dry++ +
1192 ixheaacd_mps_mult32_shr_15(temp, *p_buffer_im);
1193 p_buffer_im++;
1194 }
1195 }
1196
1197 p_buffer_real += TSXHB;
1198 p_buffer_imag += TSXHB;
1199
1200 p_buf_real += TSXHB;
1201 p_buf_imag += TSXHB;
1202
1203 p_hyb_out_dry_real += TSXHB;
1204 p_hyb_out_dry_imag += TSXHB;
1205 }
1206
1207 return;
1208 }
1209
ixheaacd_tp_process(ia_heaac_mps_state_struct * pstr_mps_state)1210 VOID ixheaacd_tp_process(ia_heaac_mps_state_struct *pstr_mps_state) {
1211 WORD32 ch, ts, hyb, n;
1212 WORD32 temp, temp_1, temp_2;
1213 ia_mps_dec_synthesis_interface *syn = pstr_mps_state->syn;
1214 WORD32 *hyb_output_real_wet, *hyb_output_imag_wet;
1215 WORD32 *hyb_output_real_dry, *hyb_output_imag_dry;
1216
1217 WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im;
1218 WORD32 *p_buf_real, *p_buf_imag, *p_buf_re, *p_buf_im;
1219 WORD32 *buf_real, *buf_imag;
1220
1221 WORD32 num_output_channels = pstr_mps_state->num_output_channels;
1222 WORD32 time_slots = pstr_mps_state->time_slots;
1223 WORD32 qmf_bands = pstr_mps_state->qmf_bands;
1224 WORD32 num_output_channels_at = pstr_mps_state->num_output_channels_at;
1225 WORD32 tree_config = pstr_mps_state->tree_config;
1226 WORD32 up_mix_type = pstr_mps_state->up_mix_type;
1227 WORD32 tp_hyb_band_border = pstr_mps_state->tp_hyb_band_border;
1228
1229 ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct;
1230 WORD32 *p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
1231 WORD32 *p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;
1232 WORD32 *p_hyb_out_dry_re, *p_hyb_out_dry_im;
1233
1234 WORD32 *p_time_out;
1235
1236 p_buffer_real = p_array_struct->buf_real;
1237 p_buffer_imag = p_array_struct->buf_imag;
1238
1239 p_buf_real = p_array_struct->buffer_real;
1240 p_buf_imag = p_array_struct->buffer_imag;
1241
1242 if (!pstr_mps_state->scaling_enable) {
1243 for (ch = 0; ch < num_output_channels; ch++) {
1244 p_buffer_re = p_buffer_real;
1245 p_buffer_im = p_buffer_imag;
1246
1247 p_buf_re = p_buf_real;
1248 p_buf_im = p_buf_imag;
1249
1250 p_hyb_out_dry_re = p_hyb_out_dry_real;
1251 p_hyb_out_dry_im = p_hyb_out_dry_imag;
1252
1253 for (ts = 0; ts < time_slots; ts++) {
1254 hyb_output_real_wet = p_buffer_re;
1255 hyb_output_imag_wet = p_buffer_im;
1256 hyb_output_real_dry = p_hyb_out_dry_re;
1257 hyb_output_imag_dry = p_hyb_out_dry_im;
1258
1259 buf_real = p_buf_re;
1260 buf_imag = p_buf_im;
1261
1262 temp_1 = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1263 temp_2 = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1264 for (n = 1; n < 6; n++) {
1265 temp_1 += *hyb_output_real_dry++ + *hyb_output_real_wet++;
1266 temp_2 += *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1267 }
1268
1269 *buf_real++ = temp_1;
1270 *buf_imag++ = temp_2;
1271
1272 temp = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1273 *buf_real = temp + *hyb_output_real_dry++ + *hyb_output_real_wet++;
1274 temp = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1275 *buf_imag = temp + *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1276
1277 buf_real++;
1278 buf_imag++;
1279
1280 temp = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1281 *buf_real = temp + *hyb_output_real_dry++ + *hyb_output_real_wet++;
1282 temp = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1283 *buf_imag = temp + *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1284
1285 buf_real++;
1286 buf_imag++;
1287
1288 for (n = 0; n < qmf_bands; n++) {
1289 *buf_real++ = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1290 *buf_imag++ = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1291 }
1292
1293 p_buffer_re += MAX_HYBRID_BANDS;
1294 p_buffer_im += MAX_HYBRID_BANDS;
1295
1296 p_buf_re += MAX_HYBRID_BANDS;
1297 p_buf_im += MAX_HYBRID_BANDS;
1298
1299 p_hyb_out_dry_re += MAX_HYBRID_BANDS;
1300 p_hyb_out_dry_im += MAX_HYBRID_BANDS;
1301 }
1302 p_buffer_real += TSXHB;
1303 p_buffer_imag += TSXHB;
1304
1305 p_buf_real += TSXHB;
1306 p_buf_imag += TSXHB;
1307
1308 p_hyb_out_dry_real += TSXHB;
1309 p_hyb_out_dry_imag += TSXHB;
1310 }
1311 } else {
1312 for (ch = 0; ch < num_output_channels; ch++) {
1313 p_buffer_re = p_buffer_real;
1314 p_buffer_im = p_buffer_imag;
1315
1316 p_buf_re = p_buf_real;
1317 p_buf_im = p_buf_imag;
1318
1319 p_hyb_out_dry_re = p_hyb_out_dry_real;
1320 p_hyb_out_dry_im = p_hyb_out_dry_imag;
1321
1322 for (ts = 0; ts < time_slots; ts++) {
1323 hyb_output_real_wet = p_buffer_re;
1324 hyb_output_imag_wet = p_buffer_im;
1325 hyb_output_real_dry = p_hyb_out_dry_re;
1326 hyb_output_imag_dry = p_hyb_out_dry_im;
1327
1328 buf_real = p_buf_re;
1329 buf_imag = p_buf_im;
1330
1331 temp_1 = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1332 temp_2 = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1333 for (n = 1; n < 6; n++) {
1334 temp_1 += *hyb_output_real_dry++ + *hyb_output_real_wet++;
1335 temp_2 += *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1336 }
1337
1338 *buf_real++ = temp_1;
1339 *buf_imag++ = temp_2;
1340
1341 *buf_real = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1342 *buf_real += *hyb_output_real_dry++ + *hyb_output_real_wet++;
1343
1344 *buf_imag = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1345 *buf_imag += *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1346
1347 buf_real++;
1348 buf_imag++;
1349
1350 *buf_real = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1351 *buf_real += *hyb_output_real_dry++ + *hyb_output_real_wet++;
1352 *buf_imag = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1353 *buf_imag += *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1354
1355 buf_real++;
1356 buf_imag++;
1357
1358 for (hyb = 3; hyb < tp_hyb_band_border - QMF_TO_HYB_OFFSET; hyb++) {
1359 *buf_real++ = *hyb_output_real_dry++ + *hyb_output_real_wet++;
1360 *buf_imag++ = *hyb_output_imag_dry++ + *hyb_output_imag_wet++;
1361 }
1362 p_buffer_re += MAX_HYBRID_BANDS;
1363 p_buffer_im += MAX_HYBRID_BANDS;
1364
1365 p_buf_re += MAX_HYBRID_BANDS;
1366 p_buf_im += MAX_HYBRID_BANDS;
1367
1368 p_hyb_out_dry_re += MAX_HYBRID_BANDS;
1369 p_hyb_out_dry_im += MAX_HYBRID_BANDS;
1370 }
1371 p_buffer_real += TSXHB;
1372 p_buffer_imag += TSXHB;
1373
1374 p_buf_real += TSXHB;
1375 p_buf_imag += TSXHB;
1376
1377 p_hyb_out_dry_real += TSXHB;
1378 p_hyb_out_dry_imag += TSXHB;
1379 }
1380
1381 for (ts = 0; ts < time_slots; ts++) {
1382 ixheaacd_subband_tp(pstr_mps_state, ts);
1383 }
1384 }
1385
1386 if ((!pstr_mps_state->bs_config.arbitrary_tree) &&
1387 ((up_mix_type != 2) && (up_mix_type != 3))) {
1388 WORD32 *time_out_5xxx =
1389 pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr->time_out_idx_5xxx;
1390 WORD32 *time_out_7xxx =
1391 pstr_mps_state->ia_mps_dec_mps_table.tp_process_table_ptr->time_out_idx_7xxx;
1392
1393 p_buf_real = p_array_struct->buffer_real;
1394 p_buf_imag = p_array_struct->buffer_imag;
1395
1396 for (ch = 0; ch < num_output_channels_at; ch++) {
1397 WORD32 tempch = 0;
1398 switch (tree_config) {
1399 case TREE_5151:
1400 tempch = ch;
1401 break;
1402 case TREE_5152:
1403 case TREE_525:
1404 tempch = time_out_5xxx[ch];
1405 break;
1406 case TREE_7271:
1407 case TREE_7272:
1408 case TREE_7571:
1409 case TREE_7572:
1410 tempch = time_out_7xxx[ch];
1411 break;
1412 default:
1413 break;
1414 }
1415 p_time_out = p_array_struct->time_out + tempch * QBXTS;
1416 syn->syn_filter_bank(&pstr_mps_state->syn_qmf_bank, p_buf_real, p_buf_imag,
1417 p_time_out, ch, qmf_bands, time_slots,
1418 pstr_mps_state->ia_mps_dec_mps_table.qmf_table_ptr);
1419
1420 p_buf_real += TSXHB;
1421 p_buf_imag += TSXHB;
1422 }
1423 } else {
1424 p_time_out = p_array_struct->time_out;
1425 for (ch = 0; ch < num_output_channels_at; ch++) {
1426 syn->syn_filter_bank(&pstr_mps_state->syn_qmf_bank, p_buf_real, p_buf_imag,
1427 p_time_out, ch, qmf_bands, time_slots,
1428 pstr_mps_state->ia_mps_dec_mps_table.qmf_table_ptr);
1429
1430 p_buf_real += TSXHB;
1431 p_buf_imag += TSXHB;
1432 p_time_out += QBXTS;
1433 }
1434 }
1435
1436 return;
1437 }
1438