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 <string.h>
21 #include "ixheaacd_sbr_common.h"
22 #include "ixheaac_type_def.h"
23
24 #include "ixheaac_constants.h"
25 #include "ixheaac_basic_ops32.h"
26 #include "ixheaac_basic_ops16.h"
27 #include "ixheaac_basic_ops40.h"
28 #include "ixheaac_basic_ops.h"
29 #include "ixheaacd_defines.h"
30
31 #include "ixheaacd_intrinsics.h"
32 #include "ixheaac_sbr_const.h"
33 #include "ixheaac_basic_op.h"
34 #include "ixheaacd_defines.h"
35 #include "ixheaacd_bitbuffer.h"
36 #include "ixheaacd_pns.h"
37
38 #include "ixheaacd_aac_rom.h"
39 #include "ixheaacd_pulsedata.h"
40
41 #include "ixheaacd_drc_data_struct.h"
42 #include "ixheaacd_lt_predict.h"
43 #include "ixheaacd_cnst.h"
44 #include "ixheaacd_ec_defines.h"
45 #include "ixheaacd_ec_struct_def.h"
46 #include "ixheaacd_channelinfo.h"
47 #include "ixheaacd_drc_dec.h"
48
49 #include "ixheaacd_sbrdecoder.h"
50
51 #include "ixheaacd_sbrdecsettings.h"
52 #include "ixheaacd_sbr_scale.h"
53 #include "ixheaacd_lpp_tran.h"
54 #include "ixheaacd_env_extr_part.h"
55 #include "ixheaacd_sbr_rom.h"
56 #include "ixheaacd_hybrid.h"
57 #include "ixheaacd_ps_dec.h"
58 #include "ixheaacd_ps_bitdec.h"
59 #include "ixheaacd_env_extr.h"
60 #include "ixheaacd_common_rom.h"
61 #include "ixheaacd_freq_sca.h"
62
63 #include "ixheaacd_qmf_dec.h"
64
65 #include "ixheaacd_env_calc.h"
66
67 #include "ixheaacd_pvc_dec.h"
68 #include "ixheaacd_sbr_dec.h"
69 #include "ixheaacd_env_dec.h"
70 #include "ixheaacd_basic_funcs.h"
71 #include "ixheaacd_sbr_crc.h"
72
73 #include "ixheaacd_sbrqmftrans.h"
74
75 #include "ixheaacd_audioobjtypes.h"
76
77 extern const WORD32 ixheaacd_ldmps_polyphase_filter_coeff_fix[1280];
78
79 #define ALIGN_SIZE64(x) ((((x) + 7) >> 3) << 3)
80
81 #define FD_OVERSAMPLING_FAC (1.5f)
82
ixheaacd_getsize_sbr_persistent()83 WORD32 ixheaacd_getsize_sbr_persistent() {
84 return (IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_pers_struct), BYTE_ALIGN_8));
85 }
86
ixheaacd_esbr_hbe_data_init(ia_esbr_hbe_txposer_struct * pstr_esbr_hbe_txposer,const WORD32 num_aac_samples,WORD32 samp_fac_4_flag,const WORD32 num_out_samples,VOID * persistent_hbe_mem,WORD32 * total_persistant)87 VOID ixheaacd_esbr_hbe_data_init(
88 ia_esbr_hbe_txposer_struct *pstr_esbr_hbe_txposer,
89 const WORD32 num_aac_samples, WORD32 samp_fac_4_flag,
90 const WORD32 num_out_samples, VOID *persistent_hbe_mem,
91 WORD32 *total_persistant) {
92 WORD32 i;
93 WORD32 used_persistent = 0;
94
95 if (pstr_esbr_hbe_txposer) {
96 memset(pstr_esbr_hbe_txposer, 0,
97 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_esbr_hbe_txposer_struct), BYTE_ALIGN_8));
98
99 pstr_esbr_hbe_txposer->core_frame_length = num_aac_samples;
100
101 pstr_esbr_hbe_txposer->no_bins = num_out_samples / NO_QMF_SYNTH_CHANNELS;
102 pstr_esbr_hbe_txposer->hbe_qmf_in_len =
103 pstr_esbr_hbe_txposer->no_bins;
104 pstr_esbr_hbe_txposer->hbe_qmf_out_len =
105 2 * pstr_esbr_hbe_txposer->hbe_qmf_in_len;
106
107 pstr_esbr_hbe_txposer->ptr_input_buf =
108 (FLOAT32 *)((WORD8 *)persistent_hbe_mem);
109 used_persistent +=
110 (num_aac_samples + NO_QMF_SYNTH_CHANNELS) * sizeof(FLOAT32);
111
112 pstr_esbr_hbe_txposer->qmf_in_buf =
113 (FLOAT32 **)((WORD8 *)persistent_hbe_mem + used_persistent);
114 used_persistent +=
115 pstr_esbr_hbe_txposer->hbe_qmf_in_len * sizeof(FLOAT32 *);
116
117 for (i = 0; i < pstr_esbr_hbe_txposer->hbe_qmf_in_len; i++) {
118 pstr_esbr_hbe_txposer->qmf_in_buf[i] =
119 (FLOAT32 *)((WORD8 *)persistent_hbe_mem + used_persistent);
120
121 used_persistent += (TWICE_QMF_SYNTH_CHANNELS_NUM * sizeof(FLOAT32));
122 }
123
124 pstr_esbr_hbe_txposer->qmf_out_buf =
125 (FLOAT32 **)((WORD8 *)persistent_hbe_mem + used_persistent);
126 used_persistent +=
127 (pstr_esbr_hbe_txposer->hbe_qmf_out_len * sizeof(FLOAT32 *));
128
129 for (i = 0; i < pstr_esbr_hbe_txposer->hbe_qmf_out_len; i++) {
130 pstr_esbr_hbe_txposer->qmf_out_buf[i] =
131 (FLOAT32 *)((WORD8 *)persistent_hbe_mem + used_persistent);
132 used_persistent += (TWICE_QMF_SYNTH_CHANNELS_NUM * sizeof(FLOAT32));
133 }
134 pstr_esbr_hbe_txposer->upsamp_4_flag = samp_fac_4_flag;
135 if (pstr_esbr_hbe_txposer) {
136 pstr_esbr_hbe_txposer->fft_size[0] = num_aac_samples;
137 pstr_esbr_hbe_txposer->fft_size[1] = (WORD32)(FD_OVERSAMPLING_FAC * num_aac_samples);
138
139 pstr_esbr_hbe_txposer->ptr_spectrum = &pstr_esbr_hbe_txposer->spectrum_buf[0];
140 pstr_esbr_hbe_txposer->ptr_spectrum_tx =
141 &pstr_esbr_hbe_txposer->spectrum_transposed_buf[0];
142 pstr_esbr_hbe_txposer->mag = &pstr_esbr_hbe_txposer->mag_buf[0];
143 pstr_esbr_hbe_txposer->phase = &pstr_esbr_hbe_txposer->phase_buf[0];
144 pstr_esbr_hbe_txposer->ptr_output_buf = &pstr_esbr_hbe_txposer->output_buf[0];
145 }
146 }
147 *total_persistant = used_persistent;
148 return;
149 }
150
ixheaacd_set_sbr_persistent_table_pointer(VOID * sbr_persistent_mem_v,ia_sbr_tables_struct * sbr_tables_ptr,ixheaacd_misc_tables * pstr_common_tables)151 VOID ixheaacd_set_sbr_persistent_table_pointer(
152 VOID *sbr_persistent_mem_v, ia_sbr_tables_struct *sbr_tables_ptr,
153 ixheaacd_misc_tables *pstr_common_tables) {
154 ia_sbr_pers_struct *sbr_persistent_mem =
155 (ia_sbr_pers_struct *)sbr_persistent_mem_v;
156 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables = sbr_tables_ptr;
157 sbr_persistent_mem->str_sbr_dec_inst.pstr_common_tables = pstr_common_tables;
158 }
159
ixheaacd_set_sbr_persistent_buffers(VOID * sbr_persistent_mem_v,WORD32 * persistent_used,WORD32 num_channel,WORD ps_enable)160 VOID ixheaacd_set_sbr_persistent_buffers(VOID *sbr_persistent_mem_v,
161 WORD32 *persistent_used,
162 WORD32 num_channel, WORD ps_enable) {
163 WORD32 i = 0;
164 WORD32 used_persistent = *persistent_used;
165 WORD32 temp, temp1, temp2, temp3;
166 struct ia_sbr_pers_struct *sbr_persistent_mem =
167 (struct ia_sbr_pers_struct *)sbr_persistent_mem_v;
168
169 struct ia_sbr_dec_inst_struct *p_str_sbr_dec_inst =
170 &sbr_persistent_mem->str_sbr_dec_inst;
171
172 num_channel = max(2, num_channel);
173 memset(sbr_persistent_mem, 0,
174 IXHEAAC_GET_SIZE_ALIGNED(sizeof(struct ia_sbr_pers_struct), BYTE_ALIGN_8));
175
176 sbr_persistent_mem->sbr_qmf_analy_states =
177 (WORD16 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
178 temp = num_channel *
179 IXHEAAC_GET_SIZE_ALIGNED((QMF_FILTER_STATE_ANA_SIZE + 2 * NO_ANALYSIS_CHANNELS) *
180 sizeof(sbr_persistent_mem->sbr_qmf_analy_states[0]),
181 BYTE_ALIGN_8);
182 used_persistent += temp;
183
184 sbr_persistent_mem->sbr_qmf_analy_states_32 =
185 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
186 temp1 = num_channel *
187 IXHEAAC_GET_SIZE_ALIGNED((QMF_FILTER_STATE_ANA_SIZE + 2 * NO_ANALYSIS_CHANNELS) *
188 sizeof(sbr_persistent_mem->sbr_qmf_analy_states_32[0]),
189 BYTE_ALIGN_8);
190 used_persistent += temp1;
191
192 sbr_persistent_mem->sbr_qmf_synth_states =
193 (WORD16 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
194
195 temp2 = (num_channel *
196 IXHEAAC_GET_SIZE_ALIGNED((QMF_FILTER_STATE_SYN_SIZE + 2 * NO_SYNTHESIS_CHANNELS) *
197 sizeof(sbr_persistent_mem->sbr_qmf_synth_states[0]),
198 BYTE_ALIGN_8));
199 used_persistent += temp2;
200
201 sbr_persistent_mem->sbr_qmf_synth_states_32 =
202 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
203
204 temp3 = (num_channel *
205 IXHEAAC_GET_SIZE_ALIGNED((QMF_FILTER_STATE_SYN_SIZE + 2 * NO_SYNTHESIS_CHANNELS) *
206 sizeof(sbr_persistent_mem->sbr_qmf_synth_states_32[0]),
207 BYTE_ALIGN_8));
208 used_persistent += temp3;
209
210 memset(sbr_persistent_mem->sbr_qmf_analy_states, 0,
211 (temp + temp1 + temp2 + temp3));
212
213 for (i = 0; i < num_channel; i++) {
214 sbr_persistent_mem->ptr_sbr_overlap_buf[i] =
215 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
216
217 if (ps_enable) {
218 memset(
219 sbr_persistent_mem->ptr_sbr_overlap_buf[i], 0,
220 2 * IXHEAAC_GET_SIZE_ALIGNED(MAX_OV_COLS * NO_SYNTHESIS_CHANNELS *
221 sizeof(sbr_persistent_mem->ptr_sbr_overlap_buf[i][0]),
222 BYTE_ALIGN_8));
223 used_persistent +=
224 2 * IXHEAAC_GET_SIZE_ALIGNED(MAX_OV_COLS * NO_SYNTHESIS_CHANNELS *
225 sizeof(sbr_persistent_mem->ptr_sbr_overlap_buf[i][0]),
226 BYTE_ALIGN_8);
227 } else {
228 memset(sbr_persistent_mem->ptr_sbr_overlap_buf[i], 0,
229 IXHEAAC_GET_SIZE_ALIGNED(MAX_OV_COLS * NO_SYNTHESIS_CHANNELS *
230 sizeof(sbr_persistent_mem->ptr_sbr_overlap_buf[i][0]),
231 BYTE_ALIGN_8));
232 used_persistent +=
233 IXHEAAC_GET_SIZE_ALIGNED(MAX_OV_COLS * NO_SYNTHESIS_CHANNELS *
234 sizeof(sbr_persistent_mem->ptr_sbr_overlap_buf[i][0]),
235 BYTE_ALIGN_8);
236 }
237 }
238
239 for (i = 0; i < num_channel; i++) {
240 WORD32 j;
241 sbr_persistent_mem->sbr_lpc_filter_states_real[i] =
242 (WORD32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
243 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
244 LPC_ORDER * sizeof(sbr_persistent_mem->sbr_lpc_filter_states_real[i][0]), BYTE_ALIGN_8);
245 for (j = 0; j < LPC_ORDER; j++) {
246 sbr_persistent_mem->sbr_lpc_filter_states_real[i][j] =
247 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
248
249 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
250 NO_ANALYSIS_CHANNELS * sizeof(sbr_persistent_mem->sbr_lpc_filter_states_real[i][j][0]),
251 BYTE_ALIGN_8);
252
253 memset(sbr_persistent_mem->sbr_lpc_filter_states_real[i][j], 0,
254 IXHEAAC_GET_SIZE_ALIGNED(
255 NO_ANALYSIS_CHANNELS *
256 sizeof(sbr_persistent_mem->sbr_lpc_filter_states_real[i][j][0]),
257 BYTE_ALIGN_8));
258 }
259 }
260
261 if (ps_enable) {
262 for (i = 0; i < num_channel; i++) {
263 WORD32 j;
264
265 sbr_persistent_mem->sbr_lpc_filter_states_imag[i] =
266 (WORD32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
267 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
268 LPC_ORDER * sizeof(sbr_persistent_mem->sbr_lpc_filter_states_imag[i][0]), BYTE_ALIGN_8);
269 for (j = 0; j < LPC_ORDER; j++) {
270 sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j] =
271 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
272
273 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
274 NO_ANALYSIS_CHANNELS *
275 sizeof(sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j][0]),
276 BYTE_ALIGN_8);
277
278 memset(sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j], 0,
279 IXHEAAC_GET_SIZE_ALIGNED(
280 NO_ANALYSIS_CHANNELS *
281 sizeof(sbr_persistent_mem->sbr_lpc_filter_states_imag[i][j][0]),
282 BYTE_ALIGN_8));
283 }
284 }
285 }
286 for (i = 0; i < num_channel; i++) {
287 WORD32 initial_used = used_persistent;
288 WORD32 temp_used = used_persistent;
289
290 sbr_persistent_mem->sbr_smooth_gain_buf[i] =
291 (WORD16 *)((WORD8 *)sbr_persistent_mem_v + temp_used);
292 temp_used += 2 * IXHEAAC_GET_SIZE_ALIGNED(
293 MAX_FREQ_COEFFS * sizeof(sbr_persistent_mem->sbr_smooth_gain_buf[i][0]),
294 BYTE_ALIGN_8);
295
296 sbr_persistent_mem->sbr_smooth_noise_buf[i] =
297 (WORD16 *)((WORD8 *)sbr_persistent_mem_v + temp_used);
298
299 temp_used += IXHEAAC_GET_SIZE_ALIGNED(
300 MAX_FREQ_COEFFS * sizeof(sbr_persistent_mem->sbr_smooth_noise_buf[i][0]), BYTE_ALIGN_8);
301
302 p_str_sbr_dec_inst->pstr_freq_band_data[i] =
303 (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used);
304
305 temp_used += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_freq_band_data_struct), BYTE_ALIGN_8);
306
307 sbr_persistent_mem->pstr_prev_frame_data[i] =
308 (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used);
309
310 temp_used += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_prev_frame_data_struct), BYTE_ALIGN_8);
311
312 p_str_sbr_dec_inst->pstr_sbr_channel[i] =
313 (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used);
314
315 temp_used += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_channel_struct), BYTE_ALIGN_8);
316
317 p_str_sbr_dec_inst->pstr_sbr_header[i] =
318 (VOID *)((WORD8 *)sbr_persistent_mem_v + temp_used);
319
320 temp_used += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_header_data_struct), BYTE_ALIGN_8);
321
322 memset(sbr_persistent_mem->sbr_smooth_gain_buf[i], 0,
323 temp_used - initial_used);
324
325 used_persistent = temp_used;
326 }
327
328 if (ps_enable) {
329 p_str_sbr_dec_inst->pstr_ps_stereo_dec =
330 (ia_ps_dec_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
331
332 memset(p_str_sbr_dec_inst->pstr_ps_stereo_dec, 0,
333 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_ps_dec_struct), BYTE_ALIGN_8));
334
335 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_ps_dec_struct), BYTE_ALIGN_8);
336 }
337
338 p_str_sbr_dec_inst->frame_buffer[0] =
339 (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
340 memset(p_str_sbr_dec_inst->frame_buffer[0], 0,
341 IXHEAAC_GET_SIZE_ALIGNED(
342 sizeof(ia_sbr_frame_info_data_struct) + MAX_FREQ_COEFFS * sizeof(WORD32) * 2 + 8,
343 BYTE_ALIGN_8));
344 used_persistent =
345 used_persistent + IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_frame_info_data_struct) +
346 MAX_FREQ_COEFFS * sizeof(WORD32) + 8,
347 BYTE_ALIGN_8);
348
349 p_str_sbr_dec_inst->frame_buffer[1] =
350 (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
351 memset(p_str_sbr_dec_inst->frame_buffer[1], 0,
352 IXHEAAC_GET_SIZE_ALIGNED(
353 sizeof(ia_sbr_frame_info_data_struct) + MAX_FREQ_COEFFS * sizeof(WORD32) * 2 + 8,
354 BYTE_ALIGN_8));
355 used_persistent =
356 used_persistent + IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_sbr_frame_info_data_struct) +
357 MAX_FREQ_COEFFS * sizeof(WORD32) + 8,
358 BYTE_ALIGN_8);
359
360 {
361 WORD32 index = 0;
362 p_str_sbr_dec_inst->ptr_pvc_data_str =
363 (ia_pvc_data_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
364 memset(p_str_sbr_dec_inst->ptr_pvc_data_str, 0,
365 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_pvc_data_struct), BYTE_ALIGN_8));
366 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_pvc_data_struct), BYTE_ALIGN_8);
367
368 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_hbe_txposer =
369 (ia_esbr_hbe_txposer_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
370 memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_hbe_txposer, 0,
371 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_esbr_hbe_txposer_struct), BYTE_ALIGN_8));
372 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_esbr_hbe_txposer_struct), BYTE_ALIGN_8);
373
374 if (num_channel == 2) {
375 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_hbe_txposer =
376 (ia_esbr_hbe_txposer_struct *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
377 memset(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_hbe_txposer, 0,
378 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_esbr_hbe_txposer_struct), BYTE_ALIGN_8));
379 used_persistent +=
380 IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_esbr_hbe_txposer_struct), BYTE_ALIGN_8);
381 }
382
383 p_str_sbr_dec_inst->hbe_txposer_buffers =
384 (VOID *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
385 memset(p_str_sbr_dec_inst->hbe_txposer_buffers, 0,
386 num_channel * IXHEAAC_GET_SIZE_ALIGNED(MAX_HBE_PERSISTENT_SIZE, BYTE_ALIGN_8));
387 used_persistent +=
388 num_channel * IXHEAAC_GET_SIZE_ALIGNED(MAX_HBE_PERSISTENT_SIZE, BYTE_ALIGN_8);
389
390 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real =
391 (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
392 memset(
393 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real, 0,
394 IXHEAAC_GET_SIZE_ALIGNED(
395 MAX_QMF_BUF_LEN *
396 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real[0]),
397 BYTE_ALIGN_8));
398 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
399 MAX_QMF_BUF_LEN *
400 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real[0]),
401 BYTE_ALIGN_8);
402
403 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag =
404 (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
405 memset(
406 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag, 0,
407 IXHEAAC_GET_SIZE_ALIGNED(
408 MAX_QMF_BUF_LEN *
409 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag[0]),
410 BYTE_ALIGN_8));
411 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
412 MAX_QMF_BUF_LEN *
413 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag[0]),
414 BYTE_ALIGN_8);
415
416 if (num_channel == 2) {
417 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real =
418 (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
419 memset(
420 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real, 0,
421 IXHEAAC_GET_SIZE_ALIGNED(
422 MAX_QMF_BUF_LEN *
423 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real[0]),
424 BYTE_ALIGN_8));
425 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
426 MAX_QMF_BUF_LEN *
427 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_real[0]),
428 BYTE_ALIGN_8);
429
430 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag =
431 (FLOAT32 **)((WORD8 *)sbr_persistent_mem_v + used_persistent);
432 memset(
433 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag, 0,
434 IXHEAAC_GET_SIZE_ALIGNED(
435 MAX_QMF_BUF_LEN *
436 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag[0]),
437 BYTE_ALIGN_8));
438 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
439 MAX_QMF_BUF_LEN *
440 sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.pp_qmf_buf_imag[0]),
441 BYTE_ALIGN_8);
442 }
443
444 for (index = 0; index < MAX_QMF_BUF_LEN; index++) {
445 p_str_sbr_dec_inst->pstr_sbr_channel[0]
446 ->str_sbr_dec.pp_qmf_buf_real[index] =
447 (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
448 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
449 MAX_QMF_BUF_LEN *
450 sizeof(
451 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_real[index][0]),
452 BYTE_ALIGN_8);
453 }
454
455 for (index = 0; index < MAX_QMF_BUF_LEN; index++) {
456 p_str_sbr_dec_inst->pstr_sbr_channel[0]
457 ->str_sbr_dec.pp_qmf_buf_imag[index] =
458 (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
459 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
460 MAX_QMF_BUF_LEN *
461 sizeof(
462 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.pp_qmf_buf_imag[index][0]),
463 BYTE_ALIGN_8);
464 }
465
466 if (num_channel == 2) {
467 for (index = 0; index < MAX_QMF_BUF_LEN; index++) {
468 p_str_sbr_dec_inst->pstr_sbr_channel[1]
469 ->str_sbr_dec.pp_qmf_buf_real[index] =
470 (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
471 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
472 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
473 ->str_sbr_dec.pp_qmf_buf_real[index][0]),
474 BYTE_ALIGN_8);
475 }
476
477 for (index = 0; index < MAX_QMF_BUF_LEN; index++) {
478 p_str_sbr_dec_inst->pstr_sbr_channel[1]
479 ->str_sbr_dec.pp_qmf_buf_imag[index] =
480 (FLOAT32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
481 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
482 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
483 ->str_sbr_dec.pp_qmf_buf_imag[index][0]),
484 BYTE_ALIGN_8);
485 }
486 }
487
488 for (i = 0; i < MAX_ENV_COLS; i++) {
489 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_real[i] =
490 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
491 memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_real[i], 0,
492 IXHEAAC_GET_SIZE_ALIGNED(
493 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]
494 ->str_sbr_dec.p_arr_qmf_buf_real[i][0]),
495 BYTE_ALIGN_8));
496 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
497 MAX_QMF_BUF_LEN *
498 sizeof(
499 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_real[i][0]),
500 BYTE_ALIGN_8);
501
502 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_imag[i] =
503 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
504 memset(p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_imag[i], 0,
505 IXHEAAC_GET_SIZE_ALIGNED(
506 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[0]
507 ->str_sbr_dec.p_arr_qmf_buf_imag[i][0]),
508 BYTE_ALIGN_8));
509 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
510 MAX_QMF_BUF_LEN *
511 sizeof(
512 p_str_sbr_dec_inst->pstr_sbr_channel[0]->str_sbr_dec.p_arr_qmf_buf_imag[i][0]),
513 BYTE_ALIGN_8);
514 }
515
516 if (num_channel == 2) {
517 for (i = 0; i < MAX_ENV_COLS; i++) {
518 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_arr_qmf_buf_real[i] =
519 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
520 memset(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_arr_qmf_buf_real[i], 0,
521 IXHEAAC_GET_SIZE_ALIGNED(
522 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
523 ->str_sbr_dec.p_arr_qmf_buf_real[i][0]),
524 BYTE_ALIGN_8));
525 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
526 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
527 ->str_sbr_dec.p_arr_qmf_buf_real[i][0]),
528 BYTE_ALIGN_8);
529
530 p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_arr_qmf_buf_imag[i] =
531 (WORD32 *)((WORD8 *)sbr_persistent_mem_v + used_persistent);
532 memset(p_str_sbr_dec_inst->pstr_sbr_channel[1]->str_sbr_dec.p_arr_qmf_buf_imag[i], 0,
533 IXHEAAC_GET_SIZE_ALIGNED(
534 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
535 ->str_sbr_dec.p_arr_qmf_buf_imag[i][0]),
536 BYTE_ALIGN_8));
537 used_persistent += IXHEAAC_GET_SIZE_ALIGNED(
538 MAX_QMF_BUF_LEN * sizeof(p_str_sbr_dec_inst->pstr_sbr_channel[1]
539 ->str_sbr_dec.p_arr_qmf_buf_imag[i][0]),
540 BYTE_ALIGN_8);
541 }
542 }
543 }
544
545 *persistent_used = used_persistent;
546 }
547
ixheaacd_init_headerdata(ia_sbr_header_data_struct * ptr_header_data,WORD32 sample_rate_dec,WORD32 samp_per_frame,ia_freq_band_data_struct * freq_band_data,ia_sbr_tables_struct * sbr_tables,WORD audio_obj_type)548 static PLATFORM_INLINE VOID ixheaacd_init_headerdata(
549 ia_sbr_header_data_struct *ptr_header_data, WORD32 sample_rate_dec,
550 WORD32 samp_per_frame, ia_freq_band_data_struct *freq_band_data,
551 ia_sbr_tables_struct *sbr_tables, WORD audio_obj_type) {
552 ia_freq_band_data_struct *pstr_freq_band_data = freq_band_data;
553 WORD32 tmp;
554
555 if (audio_obj_type != AOT_ER_AAC_ELD) {
556 memcpy(ptr_header_data,
557 &sbr_tables->env_extr_tables_ptr->str_sbr_default_header,
558 sizeof(ia_sbr_header_data_struct));
559 }
560
561 if (audio_obj_type == AOT_ER_AAC_ELD) ptr_header_data->time_step -= 1;
562
563 pstr_freq_band_data->freq_band_table[LOW] =
564 pstr_freq_band_data->freq_band_tbl_lo;
565 pstr_freq_band_data->freq_band_table[HIGH] =
566 pstr_freq_band_data->freq_band_tbl_hi;
567 ptr_header_data->pstr_freq_band_data = pstr_freq_band_data;
568
569 ptr_header_data->core_frame_size = samp_per_frame;
570 ptr_header_data->out_sampling_freq = sample_rate_dec << 1;
571
572 if (audio_obj_type != AOT_ER_AAC_ELD) {
573 tmp = ptr_header_data->time_step + 4;
574
575 if (tmp < 0)
576 ptr_header_data->num_time_slots =
577 ixheaac_extract16l(samp_per_frame << (-tmp));
578 else
579 ptr_header_data->num_time_slots =
580 ixheaac_extract16l(samp_per_frame >> tmp);
581 } else {
582 ptr_header_data->time_step = 1;
583
584 ptr_header_data->num_time_slots =
585 (samp_per_frame / 32 >> (ptr_header_data->time_step - 1));
586 }
587 }
588
ixheaacd_setesbr_flags(VOID * sbr_persistent_mem_v,FLAG pvc_flag,FLAG hbe_flag,FLAG inter_tes_flag)589 VOID ixheaacd_setesbr_flags(VOID *sbr_persistent_mem_v, FLAG pvc_flag,
590 FLAG hbe_flag, FLAG inter_tes_flag) {
591 ia_sbr_pers_struct *sbr_persistent_mem;
592 sbr_persistent_mem = (ia_sbr_pers_struct *)sbr_persistent_mem_v;
593 sbr_persistent_mem->str_sbr_dec_inst.hbe_flag = hbe_flag;
594 sbr_persistent_mem->str_sbr_dec_inst.pvc_flag = pvc_flag;
595 sbr_persistent_mem->str_sbr_dec_inst.inter_tes_flag = inter_tes_flag;
596 return;
597 }
598
ixheaacd_init_sbr(WORD32 sample_rate_dec,WORD32 samp_per_frame,FLAG * down_sample_flag,VOID * sbr_persistent_mem_v,WORD32 * ptr_overlap_buf,WORD32 channel,WORD32 ps_enable,WORD32 sbr_ratio_idx,WORD32 output_frame_size,WORD32 * use_hbe,VOID * p_usac_dflt_header,ia_sbr_header_data_struct str_sbr_config,WORD32 audio_object_type,WORD32 ldmps_present,WORD32 ldsbr_present)599 ia_handle_sbr_dec_inst_struct ixheaacd_init_sbr(
600 WORD32 sample_rate_dec, WORD32 samp_per_frame, FLAG *down_sample_flag,
601 VOID *sbr_persistent_mem_v, WORD32 *ptr_overlap_buf, WORD32 channel,
602 WORD32 ps_enable, WORD32 sbr_ratio_idx, WORD32 output_frame_size,
603 WORD32 *use_hbe, VOID *p_usac_dflt_header,
604 ia_sbr_header_data_struct str_sbr_config, WORD32 audio_object_type,
605 WORD32 ldmps_present, WORD32 ldsbr_present) {
606 WORD16 i;
607 WORD16 err;
608 ia_sbr_header_data_struct *ptr_header_data[MAXNRSBRCHANNELS];
609 ia_sbr_dec_struct *ptr_sbr_dec[2];
610 ia_qmf_dec_tables_struct *qmf_dec_tables_ptr;
611 ia_sbr_pers_struct *sbr_persistent_mem;
612
613 sbr_persistent_mem = (ia_sbr_pers_struct *)sbr_persistent_mem_v;
614 ptr_sbr_dec[0] =
615 &sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[0]->str_sbr_dec;
616 ptr_sbr_dec[1] =
617 &sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[1]->str_sbr_dec;
618
619 qmf_dec_tables_ptr =
620 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr;
621
622 if (sample_rate_dec > 48000) {
623 *down_sample_flag = 1;
624 }
625
626 for (i = 0; i < channel; i++) {
627 if (audio_object_type == AOT_ER_AAC_ELD) {
628 memcpy(sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_header[i],
629 &str_sbr_config, sizeof(ia_sbr_header_data_struct));
630 }
631 ptr_header_data[i] =
632 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_header[i];
633
634 ixheaacd_init_headerdata(
635 ptr_header_data[i], sample_rate_dec, samp_per_frame,
636 sbr_persistent_mem->str_sbr_dec_inst.pstr_freq_band_data[i],
637 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables,
638 audio_object_type);
639
640 err = ixheaacd_create_sbrdec(
641
642 sbr_persistent_mem->str_sbr_dec_inst.pstr_common_tables,
643 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_channel[i],
644 ptr_header_data[i], i, *down_sample_flag, sbr_persistent_mem, ps_enable,
645 audio_object_type, ldmps_present, ldsbr_present);
646
647 ptr_header_data[i]->status = 1;
648 ptr_sbr_dec[i]->band_count = 64;
649 ptr_header_data[i]->pstr_freq_band_data[0].qmf_sb_prev = 64;
650 ptr_header_data[i]->pstr_freq_band_data[1].qmf_sb_prev = 64;
651
652 if (err) {
653 return NULL;
654 }
655 }
656
657 if (channel != 1) {
658 if (ps_enable) {
659 if (audio_object_type == AOT_ER_AAC_ELD)
660 ixheaacd_create_psdec(
661 sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec,
662 sbr_persistent_mem, &ptr_overlap_buf[512 * 4], samp_per_frame);
663 else
664 ixheaacd_create_psdec(
665 sbr_persistent_mem->str_sbr_dec_inst.pstr_ps_stereo_dec,
666 sbr_persistent_mem, ptr_overlap_buf, samp_per_frame);
667 }
668 }
669
670 if ((use_hbe != NULL) && !((audio_object_type == AOT_ER_AAC_ELD) ||
671 (audio_object_type == AOT_ER_AAC_LD))) {
672 ia_sbr_header_data_struct *ptr_sbr_dflt_header =
673 &sbr_persistent_mem->str_sbr_dec_inst.str_sbr_dflt_header;
674 ia_sbr_header_data_struct *ptr_usac_dflt_header =
675 (ia_sbr_header_data_struct *)p_usac_dflt_header;
676 struct ia_sbr_dec_inst_struct *p_str_sbr_dec_inst =
677 &sbr_persistent_mem->str_sbr_dec_inst;
678 VOID *hbe_txposer_buffers = p_str_sbr_dec_inst->hbe_txposer_buffers;
679
680 ptr_header_data[0] = p_str_sbr_dec_inst->pstr_sbr_header[0];
681 ptr_header_data[1] = p_str_sbr_dec_inst->pstr_sbr_header[1];
682
683 ptr_header_data[0]->sbr_ratio_idx = sbr_ratio_idx;
684 ptr_header_data[0]->output_framesize = output_frame_size;
685 ptr_header_data[0]->pstr_freq_band_data->sub_band_start = 64;
686 ptr_header_data[0]->esbr_start_up = 1;
687 ptr_header_data[0]->esbr_start_up_pvc = 1;
688
689 if (channel > 1) {
690 ptr_header_data[1]->sbr_ratio_idx = sbr_ratio_idx;
691 ptr_header_data[1]->output_framesize = output_frame_size;
692 ptr_header_data[1]->pstr_freq_band_data->sub_band_start = 64;
693 ptr_header_data[1]->esbr_start_up = 1;
694 ptr_header_data[1]->esbr_start_up_pvc = 1;
695 }
696 if (hbe_txposer_buffers != NULL) {
697 WORD32 persistant_used = 0;
698 ixheaacd_esbr_hbe_data_init(ptr_sbr_dec[0]->p_hbe_txposer, samp_per_frame,
699 sbr_ratio_idx == SBR_UPSAMPLE_IDX_4_1 ? 1 : 0,
700 output_frame_size, hbe_txposer_buffers, &persistant_used);
701
702 hbe_txposer_buffers = (WORD8 *)hbe_txposer_buffers +
703 IXHEAAC_GET_SIZE_ALIGNED(MAX_HBE_PERSISTENT_SIZE, BYTE_ALIGN_8);
704
705 ixheaacd_esbr_hbe_data_init(ptr_sbr_dec[1]->p_hbe_txposer, samp_per_frame,
706 sbr_ratio_idx == SBR_UPSAMPLE_IDX_4_1 ? 1 : 0,
707 output_frame_size, hbe_txposer_buffers, &persistant_used);
708 }
709
710 p_str_sbr_dec_inst->ptr_pvc_data_str->prev_first_bnd_idx = -1;
711 p_str_sbr_dec_inst->ptr_pvc_data_str->prev_pvc_rate = -1;
712 p_str_sbr_dec_inst->ptr_pvc_data_str->prev_sbr_mode = UNKNOWN_SBR;
713
714 p_str_sbr_dec_inst->pstr_sbr_channel[0]
715 ->str_sbr_dec.str_codec_qmf_bank.num_time_slots =
716 output_frame_size / 64;
717 p_str_sbr_dec_inst->pstr_sbr_channel[1]
718 ->str_sbr_dec.str_codec_qmf_bank.num_time_slots =
719 output_frame_size / 64;
720
721 ptr_header_data[0]->core_frame_size = samp_per_frame;
722 ptr_header_data[1]->core_frame_size = samp_per_frame;
723
724 switch (sbr_ratio_idx) {
725 case SBR_UPSAMPLE_IDX_0_0:
726 ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 32;
727 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle =
728 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32;
729 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
730 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32;
731 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos =
732 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32;
733 ptr_header_data[0]->is_usf_4 = 0;
734 ptr_header_data[0]->upsamp_fac = 1;
735
736 ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 32;
737 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle =
738 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32;
739 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
740 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32;
741 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos =
742 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32;
743 ptr_header_data[1]->is_usf_4 = 0;
744 ptr_header_data[1]->upsamp_fac = 1;
745 break;
746 case SBR_UPSAMPLE_IDX_2_1:
747 ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 32;
748 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle =
749 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32;
750 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
751 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32;
752 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos =
753 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32;
754 ptr_header_data[0]->is_usf_4 = 0;
755 ptr_header_data[0]->upsamp_fac = 2;
756
757 ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 32;
758 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle =
759 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l32;
760 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
761 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l32;
762 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos =
763 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l32;
764 ptr_header_data[1]->is_usf_4 = 0;
765 ptr_header_data[1]->upsamp_fac = 2;
766 break;
767 case SBR_UPSAMPLE_IDX_8_3:
768 ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 24;
769 ptr_sbr_dec[0]->str_codec_qmf_bank.filter_pos_32 =
770 qmf_dec_tables_ptr->esbr_qmf_c_24;
771 ptr_sbr_dec[0]->str_codec_qmf_bank.analy_win_coeff_32 =
772 qmf_dec_tables_ptr->esbr_qmf_c_24;
773 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle =
774 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l24;
775 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
776 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l24;
777 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos =
778 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l24;
779
780 ptr_header_data[0]->is_usf_4 = 0;
781 ptr_header_data[0]->upsamp_fac = 2;
782
783 ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 24;
784 ptr_sbr_dec[1]->str_codec_qmf_bank.filter_pos_32 =
785 qmf_dec_tables_ptr->esbr_qmf_c_24;
786 ptr_sbr_dec[1]->str_codec_qmf_bank.analy_win_coeff_32 =
787 qmf_dec_tables_ptr->esbr_qmf_c_24;
788 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle =
789 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l24;
790 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
791 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l24;
792 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos =
793 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l24;
794
795 ptr_header_data[1]->is_usf_4 = 0;
796 ptr_header_data[1]->upsamp_fac = 2;
797 break;
798 case SBR_UPSAMPLE_IDX_4_1:
799 ptr_sbr_dec[0]->str_codec_qmf_bank.no_channels = 16;
800 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_cos_twiddle =
801 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l16;
802 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
803 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l16;
804 ptr_sbr_dec[0]->str_codec_qmf_bank.esbr_t_cos =
805 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l16;
806 ptr_header_data[0]->is_usf_4 = 1;
807 ptr_header_data[0]->upsamp_fac = 4;
808 ptr_header_data[0]->out_sampling_freq =
809 ptr_header_data[0]->out_sampling_freq * 2;
810
811 ptr_sbr_dec[1]->str_codec_qmf_bank.no_channels = 16;
812 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_cos_twiddle =
813 (WORD32 *)qmf_dec_tables_ptr->esbr_sin_cos_twiddle_l16;
814 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_alt_sin_twiddle =
815 (WORD32 *)qmf_dec_tables_ptr->esbr_alt_sin_twiddle_l16;
816 ptr_sbr_dec[1]->str_codec_qmf_bank.esbr_t_cos =
817 (WORD32 *)qmf_dec_tables_ptr->esbr_t_cos_sin_l16;
818 ptr_header_data[1]->is_usf_4 = 1;
819 ptr_header_data[1]->upsamp_fac = 4;
820 ptr_header_data[1]->out_sampling_freq =
821 ptr_header_data[1]->out_sampling_freq * 2;
822 break;
823 }
824
825 if (ptr_usac_dflt_header != NULL) {
826 ptr_sbr_dflt_header->start_freq = ptr_usac_dflt_header->start_freq;
827 ptr_sbr_dflt_header->stop_freq = ptr_usac_dflt_header->stop_freq;
828
829 if (ptr_usac_dflt_header->header_extra_1) {
830 ptr_sbr_dflt_header->freq_scale = ptr_usac_dflt_header->freq_scale;
831 ptr_sbr_dflt_header->alter_scale = ptr_usac_dflt_header->alter_scale;
832 ptr_sbr_dflt_header->noise_bands = ptr_usac_dflt_header->noise_bands;
833 } else {
834 ptr_sbr_dflt_header->freq_scale = SBR_FREQ_SCALE_DEFAULT;
835 ptr_sbr_dflt_header->alter_scale = SBR_ALTER_SCALE_DEFAULT;
836 ptr_sbr_dflt_header->noise_bands = SBR_NOISE_BANDS_DEFAULT;
837 }
838
839 if (ptr_usac_dflt_header->header_extra_2) {
840 ptr_sbr_dflt_header->limiter_bands = ptr_usac_dflt_header->limiter_bands;
841 ptr_sbr_dflt_header->limiter_gains = ptr_usac_dflt_header->limiter_gains;
842 ptr_sbr_dflt_header->interpol_freq = ptr_usac_dflt_header->interpol_freq;
843 ptr_sbr_dflt_header->smoothing_mode =
844 ptr_usac_dflt_header->smoothing_mode;
845 } else {
846 ptr_sbr_dflt_header->limiter_bands = SBR_LIMITER_BANDS_DEFAULT;
847 ptr_sbr_dflt_header->limiter_gains = SBR_LIMITER_GAINS_DEFAULT;
848 ptr_sbr_dflt_header->interpol_freq = SBR_INTERPOL_FREQ_DEFAULT;
849 ptr_sbr_dflt_header->smoothing_mode = SBR_SMOOTHING_LENGTH_DEFAULT;
850 }
851 }
852 }
853 return &(sbr_persistent_mem->str_sbr_dec_inst);
854 }
855
ixheaacd_create_sbr_env_calc(ixheaacd_misc_tables * pstr_common_table,ia_sbr_calc_env_struct * hs,WORD16 chan,VOID * sbr_persistent_mem_v,ia_sbr_header_data_struct * ptr_header_data,WORD audio_object_type)856 static PLATFORM_INLINE WORD16 ixheaacd_create_sbr_env_calc(
857
858 ixheaacd_misc_tables *pstr_common_table, ia_sbr_calc_env_struct *hs,
859 WORD16 chan, VOID *sbr_persistent_mem_v,
860 ia_sbr_header_data_struct *ptr_header_data, WORD audio_object_type) {
861 WORD16 err;
862 ia_sbr_pers_struct *sbr_persistent_mem =
863 (ia_sbr_pers_struct *)sbr_persistent_mem_v;
864
865 err = 0;
866 memset(&hs->harm_flags_prev[0], 0, sizeof(WORD8) * MAX_FREQ_COEFFS);
867
868 hs->harm_index = 0;
869
870 hs->filt_buf_me = sbr_persistent_mem->sbr_smooth_gain_buf[chan];
871 hs->filt_buf_noise_m = sbr_persistent_mem->sbr_smooth_noise_buf[chan];
872 hs->tansient_env_prev = -1;
873
874 ixheaacd_reset_sbrenvelope_calc(hs);
875
876 if ((chan == 0) && (audio_object_type == AOT_ER_AAC_ELD)) {
877 err = ixheaacd_calc_frq_bnd_tbls(ptr_header_data, pstr_common_table);
878 }
879
880 return err;
881 }
882
ixheaacd_init_sbr_prev_framedata(ia_sbr_prev_frame_data_struct * ptr_prev_data,WORD16 time_slots)883 static PLATFORM_INLINE VOID ixheaacd_init_sbr_prev_framedata(
884 ia_sbr_prev_frame_data_struct *ptr_prev_data, WORD16 time_slots) {
885 WORD16 *psfb_nrg_prev = ptr_prev_data->sfb_nrg_prev;
886 WORD16 *psfb_noise_level = ptr_prev_data->prev_noise_level;
887 WORD32 *ppsbr_invf_mode = ptr_prev_data->sbr_invf_mode;
888
889 memset(psfb_nrg_prev, 0, sizeof(WORD16) * (MAX_FREQ_COEFFS));
890 memset(psfb_noise_level, 0, sizeof(WORD16) * (MAX_NOISE_COEFFS));
891
892 memset(ppsbr_invf_mode, 0, sizeof(WORD32) * MAX_INVF_BANDS);
893
894 ptr_prev_data->end_position = time_slots;
895 ptr_prev_data->coupling_mode = COUPLING_OFF;
896 ptr_prev_data->amp_res = 0;
897 ptr_prev_data->max_qmf_subband_aac = 0;
898 }
899
900 static PLATFORM_INLINE VOID
ixheaacd_create_hyb_filterbank(ia_hybrid_struct * ptr_hybrid,WORD32 ** p_ptr,ia_sbr_tables_struct * sbr_tables_ptr)901 ixheaacd_create_hyb_filterbank(ia_hybrid_struct *ptr_hybrid, WORD32 **p_ptr,
902 ia_sbr_tables_struct *sbr_tables_ptr) {
903 WORD16 i;
904 WORD32 *ptr = (WORD32 *)*p_ptr;
905
906 ptr_hybrid->ptr_resol = sbr_tables_ptr->ps_tables_ptr->hyb_resol;
907 ptr_hybrid->ptr_qmf_buf = HYBRID_FILTER_LENGTH - 1;
908
909 ptr_hybrid->ptr_temp_re = ptr;
910 ptr += NO_HYBRID_CHANNELS_HIGH;
911 ptr_hybrid->ptr_temp_im = ptr;
912 ptr += NO_HYBRID_CHANNELS_HIGH;
913
914 memset(ptr_hybrid->ptr_temp_re, 0,
915 2 * NO_HYBRID_CHANNELS_HIGH * sizeof(WORD32));
916
917 ptr_hybrid->ptr_work_re = ptr;
918 ptr += 16;
919 ptr_hybrid->ptr_work_im = ptr;
920 ptr += 16;
921
922 for (i = 0; i < NO_QMF_CHANNELS_IN_HYBRID; i++) {
923 ptr_hybrid->ptr_qmf_buf_re[i] = ptr;
924 ptr += ptr_hybrid->ptr_qmf_buf;
925
926 ptr_hybrid->ptr_qmf_buf_im[i] = ptr;
927 ptr += ptr_hybrid->ptr_qmf_buf;
928
929 memset(ptr_hybrid->ptr_qmf_buf_re[i], 0,
930 2 * ptr_hybrid->ptr_qmf_buf * sizeof(WORD32));
931 }
932
933 *p_ptr = ptr;
934
935 return;
936 }
937
ixheaacd_create_hf_generator(ia_sbr_hf_generator_struct * ptr_hf_gen_str,WORD16 num_columns,WORD16 chan,VOID * sbr_persistent_mem_v,WORD32 ps_enable)938 static PLATFORM_INLINE VOID ixheaacd_create_hf_generator(
939 ia_sbr_hf_generator_struct *ptr_hf_gen_str, WORD16 num_columns, WORD16 chan,
940 VOID *sbr_persistent_mem_v, WORD32 ps_enable) {
941 WORD16 i;
942 ia_sbr_pers_struct *sbr_persistent_mem =
943 (ia_sbr_pers_struct *)sbr_persistent_mem_v;
944
945 ptr_hf_gen_str->pstr_settings = &sbr_persistent_mem->str_sbr_tran_settings;
946
947 ptr_hf_gen_str->lpc_filt_states_real[0] =
948 sbr_persistent_mem->sbr_lpc_filter_states_real[chan][0];
949 ptr_hf_gen_str->lpc_filt_states_real[1] =
950 sbr_persistent_mem->sbr_lpc_filter_states_real[chan][1];
951
952 if (ps_enable) {
953 ptr_hf_gen_str->lpc_filt_states_imag[0] =
954 sbr_persistent_mem->sbr_lpc_filter_states_imag[chan][0];
955 ptr_hf_gen_str->lpc_filt_states_imag[1] =
956 sbr_persistent_mem->sbr_lpc_filter_states_imag[chan][1];
957 }
958
959 for (i = 0; i < LPC_ORDER; i++) {
960 if (ptr_hf_gen_str->lpc_filt_states_real[i] != NULL) {
961 memset(ptr_hf_gen_str->lpc_filt_states_real[i], 0,
962 NO_ANALYSIS_CHANNELS * sizeof(WORD32));
963 }
964
965 if (ps_enable)
966 memset(ptr_hf_gen_str->lpc_filt_states_imag[i], 0,
967 NO_ANALYSIS_CHANNELS * sizeof(WORD32));
968 }
969
970 if (chan == 0) {
971 ptr_hf_gen_str->pstr_settings->num_columns = num_columns;
972 }
973 return;
974 }
975
ixheaacd_create_psdec(ia_ps_dec_struct * ptr_ps_dec,VOID * sbr_persistent_mem_v,WORD32 * ptr_overlap_buf,WORD32 frame_size)976 VOID ixheaacd_create_psdec(ia_ps_dec_struct *ptr_ps_dec,
977 VOID *sbr_persistent_mem_v,
978 WORD32 *ptr_overlap_buf, WORD32 frame_size) {
979 ia_sbr_pers_struct *sbr_persistent_mem =
980 (ia_sbr_pers_struct *)sbr_persistent_mem_v;
981
982 WORD16 *ptr1 = (WORD16 *)&(
983 sbr_persistent_mem->ptr_sbr_overlap_buf[MAXNRSBRCHANNELS - 1][0]);
984 WORD32 *ptr2 = (WORD32 *)&ptr_overlap_buf[512];
985 WORD16 *initial_ptr;
986 WORD16 delay;
987 WORD32 temp;
988
989 ia_sbr_tables_struct *sbr_tables_ptr =
990 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables;
991
992 memset(ptr_ps_dec, 0, sizeof(ia_ps_dec_struct));
993
994 ptr_ps_dec->ps_data_present = 0;
995 ptr_ps_dec->enable_iid = 0;
996 ptr_ps_dec->enable_icc = 0;
997 ptr_ps_dec->enable_ext = 0;
998 ptr_ps_dec->iid_mode = 0;
999 ptr_ps_dec->icc_mode = 0;
1000
1001 ptr_ps_dec->ptr_hyb_left_re = ptr2;
1002 ptr2 += 16;
1003 ptr_ps_dec->ptr_hyb_left_im = ptr2;
1004 ptr2 += 16;
1005 ptr_ps_dec->ptr_hyb_right_re = ptr2;
1006 ptr2 += 16;
1007 ptr_ps_dec->ptr_hyb_right_im = ptr2;
1008 ptr2 += 16;
1009
1010 memset(ptr_ps_dec->ptr_hyb_left_re, 0, sizeof(WORD32) * 16 * 4);
1011
1012 ixheaacd_create_hyb_filterbank(&ptr_ps_dec->str_hybrid, &ptr2,
1013 sbr_tables_ptr);
1014
1015 ptr_ps_dec->peak_decay_diff = ptr2;
1016 ptr2 += NUM_OF_BINS;
1017 ptr_ps_dec->energy_prev = ptr2;
1018 ptr2 += NUM_OF_BINS;
1019 ptr_ps_dec->peak_decay_diff_prev = ptr2;
1020 ptr2 += NUM_OF_BINS;
1021
1022 memset(ptr_ps_dec->peak_decay_diff, 0, 3 * sizeof(WORD32) * NUM_OF_BINS);
1023
1024 ptr_ps_dec->delay_buf_idx = 0;
1025 ptr_ps_dec->delay_buf_idx_long = 0;
1026
1027 memset(ptr_ps_dec->delay_buf_qmf_sub_re_im, 0,
1028 2 * 16 * DEL_ALL_PASS * sizeof(WORD16));
1029 memset(ptr_ps_dec->delay_buf_qmf_sub_ser_re_im, 0,
1030 2 * 16 * NUM_SER_AP_LINKS * 5 * sizeof(WORD16));
1031
1032 initial_ptr = ptr1;
1033 ptr_ps_dec->delay_buf_qmf_ser_re_im = (VOID *)ptr1;
1034 ptr1 += 2 * NUM_SER_AP_LINKS * 32 * 5;
1035
1036 delay = 2;
1037 ptr_ps_dec->delay_buf_qmf_ap_re_im = (VOID *)ptr1;
1038 ptr1 += 2 * delay * 32;
1039
1040 delay = HIGH_DEL;
1041 ptr_ps_dec->delay_buf_qmf_ld_re_im = (VOID *)ptr1;
1042 ptr1 += 2 * delay * SMALL_DEL_STRT;
1043
1044 delay = SMALL_DEL;
1045 ptr_ps_dec->delay_buf_qmf_sd_re_im = (VOID *)ptr1;
1046 ptr1 +=
1047 2 * delay * (NUM_OF_QUAD_MIRROR_FILTER_ICC_CHNLS -
1048 (NUM_OF_QUAD_MIRROR_FILTER_ALL_PASS_CHNLS + SMALL_DEL_STRT));
1049
1050 temp = (WORD32)(ptr1 - initial_ptr);
1051 memset(ptr_ps_dec->delay_buf_qmf_ser_re_im, 0, temp * sizeof(WORD16));
1052
1053 memset(ptr_ps_dec->delay_buf_idx_ser, 0, NUM_SER_AP_LINKS * sizeof(WORD16));
1054 memcpy(ptr_ps_dec->delay_sample_ser,
1055 sbr_tables_ptr->ps_tables_ptr->rev_link_delay_ser,
1056 NUM_SER_AP_LINKS * sizeof(WORD16));
1057
1058 memset(ptr_ps_dec->h11_h12_vec, 0xff,
1059 (NO_IID_GROUPS + 2) * 2 * sizeof(WORD16));
1060 memset(ptr_ps_dec->h21_h22_vec, 0, sizeof(ptr_ps_dec->h21_h22_vec));
1061
1062 if (frame_size == 960)
1063 ptr_ps_dec->num_sub_samples = NUM_SUB_SAMPLES_960;
1064 else
1065 ptr_ps_dec->num_sub_samples = NUM_SUB_SAMPLES;
1066
1067
1068 ixheaacd_create_ps_esbr_dec(ptr_ps_dec, sbr_tables_ptr->ps_tables_ptr,
1069 64, ptr_ps_dec->num_sub_samples, 0);
1070
1071 return;
1072 }
1073
ixheaacd_create_cplx_anal_qmfbank(ia_sbr_qmf_filter_bank_struct * ptr_sbr_qmf,ia_sbr_scale_fact_struct * sbr_scale_factor,WORD16 no_bins,WORD16 usb,WORD16 chan,WORD16 * sbr_qmf_analy_states,WORD32 * sbr_qmf_analy_states_32,ia_qmf_dec_tables_struct * qmf_dec_tables_ptr,WORD32 audio_object_type,WORD32 ldmps_present,WORD32 no_ldsbr)1074 static PLATFORM_INLINE VOID ixheaacd_create_cplx_anal_qmfbank(
1075 ia_sbr_qmf_filter_bank_struct *ptr_sbr_qmf,
1076 ia_sbr_scale_fact_struct *sbr_scale_factor, WORD16 no_bins, WORD16 usb,
1077 WORD16 chan, WORD16 *sbr_qmf_analy_states, WORD32 *sbr_qmf_analy_states_32,
1078 ia_qmf_dec_tables_struct *qmf_dec_tables_ptr, WORD32 audio_object_type,
1079 WORD32 ldmps_present, WORD32 no_ldsbr) {
1080 memset(ptr_sbr_qmf, 0, sizeof(ia_sbr_qmf_filter_bank_struct));
1081
1082 ptr_sbr_qmf->analy_win_coeff_32 = qmf_dec_tables_ptr->esbr_qmf_c;
1083 if (audio_object_type != AOT_ER_AAC_ELD &&
1084 audio_object_type != AOT_ER_AAC_LD) {
1085 ptr_sbr_qmf->analy_win_coeff = qmf_dec_tables_ptr->qmf_c;
1086 } else {
1087 ptr_sbr_qmf->analy_win_coeff = qmf_dec_tables_ptr->qmf_c_eld3;
1088 if (ldmps_present == 1)
1089 ptr_sbr_qmf->analy_win_coeff_32 = qmf_dec_tables_ptr->qmf_c_ldsbr_mps;
1090 if (no_ldsbr == 1)
1091 ptr_sbr_qmf->analy_win_coeff_32 =
1092 (WORD32 *)ixheaacd_ldmps_polyphase_filter_coeff_fix;
1093 }
1094
1095 ptr_sbr_qmf->no_channels = NO_ANALYSIS_CHANNELS;
1096 if (no_ldsbr) ptr_sbr_qmf->no_channels = 64;
1097 ptr_sbr_qmf->num_time_slots = no_bins;
1098
1099 ptr_sbr_qmf->lsb = 0;
1100 ptr_sbr_qmf->usb = usb;
1101
1102 ptr_sbr_qmf->anal_filter_states =
1103 &(sbr_qmf_analy_states[chan ? QMF_FILTER_STATE_ANA_SIZE : 0]);
1104
1105 memset(ptr_sbr_qmf->anal_filter_states, 0,
1106 sizeof(WORD16) * QMF_FILTER_STATE_ANA_SIZE);
1107
1108 ptr_sbr_qmf->anal_filter_states_32 =
1109 &(sbr_qmf_analy_states_32[chan ? QMF_FILTER_STATE_ANA_SIZE : 0]);
1110
1111 memset(ptr_sbr_qmf->anal_filter_states_32, 0,
1112 sizeof(WORD32) * QMF_FILTER_STATE_ANA_SIZE);
1113
1114 ptr_sbr_qmf->core_samples_buffer = ptr_sbr_qmf->anal_filter_states;
1115 ptr_sbr_qmf->core_samples_buffer_32 = ptr_sbr_qmf->anal_filter_states_32;
1116
1117 ptr_sbr_qmf->filter_pos_32 = (WORD32 *)qmf_dec_tables_ptr->esbr_qmf_c;
1118 ptr_sbr_qmf->state_new_samples_pos_low_32 =
1119 ptr_sbr_qmf->anal_filter_states_32;
1120 if (audio_object_type != AOT_ER_AAC_ELD &&
1121 audio_object_type != AOT_ER_AAC_LD) {
1122 ptr_sbr_qmf->filter_pos = (WORD16 *)qmf_dec_tables_ptr->qmf_c;
1123 } else {
1124 ptr_sbr_qmf->filter_pos = (WORD16 *)qmf_dec_tables_ptr->qmf_c_eld3;
1125 if (ldmps_present == 1)
1126 ptr_sbr_qmf->filter_pos_32 =
1127 (WORD32 *)qmf_dec_tables_ptr->qmf_c_ldsbr_mps;
1128 if (no_ldsbr == 1)
1129 ptr_sbr_qmf->filter_pos_32 =
1130 (WORD32 *)ixheaacd_ldmps_polyphase_filter_coeff_fix;
1131 }
1132
1133 sbr_scale_factor->st_lb_scale = 0;
1134
1135 sbr_scale_factor->st_syn_scale = -6;
1136
1137 if (audio_object_type == AOT_ER_AAC_ELD ||
1138 audio_object_type == AOT_ER_AAC_LD) {
1139 ptr_sbr_qmf->filter_2_32 =
1140 ptr_sbr_qmf->filter_pos_32 + ptr_sbr_qmf->no_channels;
1141 ptr_sbr_qmf->fp1_anal_32 = ptr_sbr_qmf->anal_filter_states_32;
1142 ptr_sbr_qmf->fp2_anal_32 =
1143 ptr_sbr_qmf->anal_filter_states_32 + ptr_sbr_qmf->no_channels;
1144
1145 ptr_sbr_qmf->filter_2 = ptr_sbr_qmf->filter_pos + ptr_sbr_qmf->no_channels;
1146 ptr_sbr_qmf->fp1_anal = ptr_sbr_qmf->anal_filter_states;
1147 ptr_sbr_qmf->fp2_anal =
1148 ptr_sbr_qmf->anal_filter_states + ptr_sbr_qmf->no_channels;
1149 }
1150
1151 return;
1152 }
1153
ixheaacd_create_cplx_synt_qmfbank(ia_sbr_qmf_filter_bank_struct * ptr_sbr_qmf,WORD16 no_bins,WORD16 lsb,WORD16 usb,WORD16 chan,FLAG down_sample_flag,WORD16 * sbr_qmf_synth_states,WORD32 * sbr_qmf_synth_states_32,ia_qmf_dec_tables_struct * qmf_dec_tables_ptr,WORD32 audio_object_type)1154 static PLATFORM_INLINE VOID ixheaacd_create_cplx_synt_qmfbank(
1155 ia_sbr_qmf_filter_bank_struct *ptr_sbr_qmf, WORD16 no_bins, WORD16 lsb,
1156 WORD16 usb, WORD16 chan, FLAG down_sample_flag,
1157 WORD16 *sbr_qmf_synth_states, WORD32 *sbr_qmf_synth_states_32,
1158 ia_qmf_dec_tables_struct *qmf_dec_tables_ptr, WORD32 audio_object_type) {
1159 WORD32 L;
1160
1161 WORD32 qmf_filter_state_size;
1162
1163 memset(ptr_sbr_qmf, 0, sizeof(ia_sbr_qmf_filter_bank_struct));
1164
1165 if (down_sample_flag) {
1166 L = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED;
1167 qmf_filter_state_size = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED;
1168 ptr_sbr_qmf->usb = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED;
1169 } else {
1170 L = NO_SYNTHESIS_CHANNELS;
1171 qmf_filter_state_size = QMF_FILTER_STATE_SYN_SIZE;
1172 ptr_sbr_qmf->usb = usb;
1173 }
1174
1175 ptr_sbr_qmf->ixheaacd_drc_offset = 0;
1176 if (audio_object_type != AOT_ER_AAC_ELD &&
1177 audio_object_type != AOT_ER_AAC_LD) {
1178 ptr_sbr_qmf->filter_pos_syn = (WORD16 *)qmf_dec_tables_ptr->qmf_c;
1179 ptr_sbr_qmf->p_filter = qmf_dec_tables_ptr->qmf_c;
1180 } else {
1181 ptr_sbr_qmf->filter_pos_syn = (WORD16 *)qmf_dec_tables_ptr->qmf_c_eld;
1182 ptr_sbr_qmf->p_filter = qmf_dec_tables_ptr->qmf_c_eld;
1183 }
1184
1185 ptr_sbr_qmf->filter_pos_syn_32 = (WORD32 *)qmf_dec_tables_ptr->esbr_qmf_c;
1186 ptr_sbr_qmf->p_filter_32 = qmf_dec_tables_ptr->esbr_qmf_c;
1187
1188 ptr_sbr_qmf->no_channels = L;
1189 ptr_sbr_qmf->qmf_filter_state_size = qmf_filter_state_size;
1190 ptr_sbr_qmf->num_time_slots = no_bins;
1191 ptr_sbr_qmf->lsb = lsb;
1192
1193 ptr_sbr_qmf->filter_states =
1194 &sbr_qmf_synth_states[chan ? qmf_filter_state_size : 0];
1195
1196 memset(ptr_sbr_qmf->filter_states, 0, sizeof(WORD16) * qmf_filter_state_size);
1197
1198 ptr_sbr_qmf->filter_states_32 =
1199 &sbr_qmf_synth_states_32[chan ? qmf_filter_state_size : 0];
1200
1201 memset(ptr_sbr_qmf->filter_states_32, 0,
1202 sizeof(WORD32) * qmf_filter_state_size);
1203
1204 if (audio_object_type == AOT_ER_AAC_ELD ||
1205 audio_object_type == AOT_ER_AAC_LD) {
1206 ptr_sbr_qmf->fp1_syn = ptr_sbr_qmf->filter_states;
1207 ptr_sbr_qmf->fp2_syn =
1208 ptr_sbr_qmf->filter_states + ptr_sbr_qmf->no_channels;
1209 ptr_sbr_qmf->sixty4 = NO_SYNTHESIS_CHANNELS;
1210 }
1211
1212 return;
1213 }
1214
ixheaacd_create_sbrdec(ixheaacd_misc_tables * pstr_common_table,ia_sbr_channel_struct * ptr_sbr_channel,ia_sbr_header_data_struct * ptr_header_data,WORD16 chan,FLAG down_sample_flag,VOID * sbr_persistent_mem_v,WORD ps_enable,WORD audio_object_type,WORD32 ldmps_present,WORD32 ldsbr_present)1215 WORD16 ixheaacd_create_sbrdec(ixheaacd_misc_tables *pstr_common_table,
1216 ia_sbr_channel_struct *ptr_sbr_channel,
1217 ia_sbr_header_data_struct *ptr_header_data,
1218 WORD16 chan, FLAG down_sample_flag,
1219 VOID *sbr_persistent_mem_v, WORD ps_enable,
1220 WORD audio_object_type, WORD32 ldmps_present,
1221 WORD32 ldsbr_present)
1222
1223 {
1224 WORD16 err;
1225 WORD16 time_slots;
1226 WORD16 no_bins;
1227 ia_sbr_pers_struct *sbr_persistent_mem =
1228 (ia_sbr_pers_struct *)sbr_persistent_mem_v;
1229 ia_sbr_dec_struct *hs = &(ptr_sbr_channel->str_sbr_dec);
1230
1231 time_slots = ptr_header_data->num_time_slots;
1232
1233 no_bins = (WORD16)(time_slots * ptr_header_data->time_step);
1234
1235 hs->str_sbr_scale_fact.ov_lb_scale = INT_BITS - 1;
1236 hs->str_sbr_scale_fact.hb_scale = INT_BITS - 1;
1237 hs->str_sbr_scale_fact.ov_hb_scale = INT_BITS - 1;
1238 hs->str_sbr_scale_fact.st_syn_scale = INT_BITS - 1;
1239
1240 ptr_sbr_channel->pstr_prev_frame_data =
1241 sbr_persistent_mem->pstr_prev_frame_data[chan];
1242
1243 err = ixheaacd_create_sbr_env_calc(pstr_common_table, &hs->str_sbr_calc_env,
1244 chan, sbr_persistent_mem, ptr_header_data,
1245 audio_object_type);
1246
1247 if (err) {
1248 return (-1);
1249 }
1250
1251 ixheaacd_create_cplx_anal_qmfbank(
1252 &hs->str_codec_qmf_bank, &hs->str_sbr_scale_fact, no_bins,
1253 ptr_header_data->pstr_freq_band_data->sub_band_start, chan,
1254 sbr_persistent_mem->sbr_qmf_analy_states,
1255 sbr_persistent_mem->sbr_qmf_analy_states_32,
1256 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr,
1257 audio_object_type, ldmps_present, ldsbr_present);
1258
1259 ixheaacd_create_cplx_synt_qmfbank(
1260 &hs->str_synthesis_qmf_bank, no_bins,
1261 ptr_header_data->pstr_freq_band_data->sub_band_start,
1262 ptr_header_data->pstr_freq_band_data->sub_band_end, chan,
1263 down_sample_flag, sbr_persistent_mem->sbr_qmf_synth_states,
1264 sbr_persistent_mem->sbr_qmf_synth_states_32,
1265 sbr_persistent_mem->str_sbr_dec_inst.pstr_sbr_tables->qmf_dec_tables_ptr,
1266 audio_object_type);
1267
1268 ixheaacd_init_sbr_prev_framedata(ptr_sbr_channel->pstr_prev_frame_data,
1269 time_slots);
1270
1271 ixheaacd_create_hf_generator(&hs->str_hf_generator,
1272 hs->str_codec_qmf_bank.num_time_slots, chan,
1273 sbr_persistent_mem, ps_enable);
1274
1275 hs->ptr_sbr_overlap_buf = sbr_persistent_mem->ptr_sbr_overlap_buf[chan];
1276
1277 return 0;
1278 }
1279