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