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 <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24
25 #include "ixheaac_type_def.h"
26 #include "ixheaac_constants.h"
27 #include "ixheaacd_cnst.h"
28
29 #include "ixheaacd_bitbuffer.h"
30 #include "ixheaacd_config.h"
31 #include "ixheaacd_interface.h"
32 #include "ixheaacd_acelp_info.h"
33
34 #include "ixheaacd_tns_usac.h"
35 #include "ixheaacd_sbrdecsettings.h"
36 #include "ixheaacd_info.h"
37 #include "ixheaacd_struct.h"
38 #include "ixheaacd_sbr_common.h"
39 #include "ixheaacd_drc_data_struct.h"
40 #include "ixheaacd_drc_dec.h"
41
42 #include "ixheaacd_sbr_scale.h"
43 #include "ixheaacd_env_extr_part.h"
44 #include "ixheaacd_sbr_rom.h"
45 #include "ixheaacd_hybrid.h"
46 #include "ixheaacd_ps_dec.h"
47 #include "ixheaacd_common_rom.h"
48 #include "ixheaacd_qmf_dec.h"
49 #include "ixheaac_sbr_const.h"
50 #include "ixheaacd_lpp_tran.h"
51 #include "ixheaacd_sbrdecoder.h"
52 #include "ixheaacd_env_extr.h"
53 #include "ixheaacd_env_calc.h"
54 #include "ixheaacd_pvc_dec.h"
55 #include "ixheaacd_sbr_dec.h"
56 #include "ixheaacd_mps_polyphase.h"
57
58 #include "ixheaacd_memory_standards.h"
59 #include "ixheaacd_defines.h"
60 #include "ixheaacd_aac_rom.h"
61 #include "ixheaacd_bitbuffer.h"
62 #include "ixheaacd_pulsedata.h"
63 #include "ixheaacd_pns.h"
64
65 #include "ixheaacd_ec_defines.h"
66 #include "ixheaacd_ec_struct_def.h"
67 #include "ixheaacd_main.h"
68 #include "ixheaacd_channelinfo.h"
69 #include "ixheaacd_ec.h"
70 #include "ixheaacd_audioobjtypes.h"
71 #include "ixheaacd_latmdemux.h"
72 #include "ixheaacd_aacdec.h"
73 #include "ixheaacd_mps_struct_def.h"
74 #include "ixheaacd_mps_res_rom.h"
75 #include "ixheaacd_mps_aac_struct.h"
76 #include "ixheaacd_mps_dec.h"
77 #include "ixheaacd_struct_def.h"
78
79 #include "ixheaacd_create.h"
80
81 #include "ixheaacd_mps_interface.h"
82
83 #include "ixheaacd_func_def.h"
84
85 extern const ia_huff_code_word_struct ixheaacd_huff_book_scl[];
86
87 extern const WORD32 ixheaacd_book_scl_index[];
88 extern const WORD16 ixheaacd_book_scl_code_book[];
89
90 extern const ia_usac_samp_rate_info ixheaacd_samp_rate_info[];
91 extern const WORD32 ixheaacd_sampling_boundaries[(1 << LEN_SAMP_IDX)];
92
93 const WORD32 ixheaacd_sampl_freq_idx_table[17] = {
94 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000,
95 12000, 11025, 8000, 7350, -1, -1, -1, -1};
96
ixheaacd_info_init(const ia_usac_samp_rate_info * ptr_samp_info,WORD32 block_size_samples,ia_sfb_info_struct * pstr_sfb_info_long,ia_sfb_info_struct * pstr_sfb_info_short,WORD16 * sfb_width_short,WORD16 * sfb_width_long)97 static VOID ixheaacd_info_init(const ia_usac_samp_rate_info *ptr_samp_info,
98 WORD32 block_size_samples,
99 ia_sfb_info_struct *pstr_sfb_info_long,
100 ia_sfb_info_struct *pstr_sfb_info_short,
101 WORD16 *sfb_width_short,
102 WORD16 *sfb_width_long) {
103 WORD32 i, j, k, n, ws;
104 const WORD16 *sfbands;
105 ia_sfb_info_struct *pstr_sfb_info_ip;
106
107 pstr_sfb_info_long->islong = 1;
108 pstr_sfb_info_long->max_win_len = 1;
109 pstr_sfb_info_long->samp_per_bk = block_size_samples;
110
111 switch (block_size_samples) {
112 case 480:
113 pstr_sfb_info_long->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_480;
114 pstr_sfb_info_long->sfb_per_sbk = ptr_samp_info->num_sfb_480;
115 break;
116 case 512:
117 pstr_sfb_info_long->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_512;
118 pstr_sfb_info_long->sfb_per_sbk = ptr_samp_info->num_sfb_512;
119 break;
120 case 768:
121 pstr_sfb_info_long->sfb_per_sbk = ptr_samp_info->num_sfb_768;
122 pstr_sfb_info_long->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_768;
123 break;
124 case 960:
125 pstr_sfb_info_long->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_960;
126 pstr_sfb_info_long->sfb_per_sbk = ptr_samp_info->num_sfb_960;
127 break;
128 case 1024:
129 pstr_sfb_info_long->sfb_per_sbk = ptr_samp_info->num_sfb_1024;
130 pstr_sfb_info_long->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_1024;
131 break;
132 default:
133 assert(0);
134 break;
135 }
136
137 pstr_sfb_info_long->sfb_width = sfb_width_long;
138 pstr_sfb_info_long->num_groups = 1;
139 pstr_sfb_info_long->group_len[0] = 1;
140
141 for (i = 0, j = 0, n = pstr_sfb_info_long->sfb_per_sbk; i < n; i++) {
142 k = pstr_sfb_info_long->ptr_sfb_tbl[i];
143 pstr_sfb_info_long->sfb_width[i] = k - j;
144 j = k;
145 }
146
147 pstr_sfb_info_short->islong = 0;
148 pstr_sfb_info_short->max_win_len = NSHORT;
149 pstr_sfb_info_short->samp_per_bk = block_size_samples;
150
151 for (i = 0; i < pstr_sfb_info_short->max_win_len; i++) {
152 switch (block_size_samples) {
153 case 768:
154 pstr_sfb_info_short->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_96;
155 pstr_sfb_info_short->sfb_per_sbk = ptr_samp_info->num_sfb_96;
156 break;
157 case 960:
158 pstr_sfb_info_short->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_120;
159 pstr_sfb_info_short->sfb_per_sbk = ptr_samp_info->num_sfb_120;
160 break;
161 case 1024:
162 pstr_sfb_info_short->ptr_sfb_tbl = ptr_samp_info->ptr_sfb_128;
163 pstr_sfb_info_short->sfb_per_sbk = ptr_samp_info->num_sfb_128;
164 break;
165 default:
166 assert(0);
167 break;
168 }
169 }
170
171 pstr_sfb_info_short->sfb_width = sfb_width_short;
172 for (i = 0, j = 0, n = pstr_sfb_info_short->sfb_per_sbk; i < n; i++) {
173 k = pstr_sfb_info_short->ptr_sfb_tbl[i];
174 pstr_sfb_info_short->sfb_width[i] = k - j;
175 j = k;
176 }
177
178 pstr_sfb_info_ip = pstr_sfb_info_long;
179 for (ws = 0; ws < 2; ws++) {
180 pstr_sfb_info_ip->sfb_per_bk = 0;
181 k = 0;
182 n = 0;
183 for (i = 0; i < pstr_sfb_info_ip->max_win_len; i++) {
184 pstr_sfb_info_ip->bins_per_sbk =
185 pstr_sfb_info_ip->samp_per_bk / pstr_sfb_info_ip->max_win_len;
186
187 pstr_sfb_info_ip->sfb_per_bk += pstr_sfb_info_ip->sfb_per_sbk;
188
189 sfbands = pstr_sfb_info_ip->ptr_sfb_tbl;
190 for (j = 0; j < pstr_sfb_info_ip->sfb_per_sbk; j++)
191 pstr_sfb_info_ip->sfb_idx_tbl[j + k] = sfbands[j] + n;
192
193 n += pstr_sfb_info_ip->bins_per_sbk;
194 k += pstr_sfb_info_ip->sfb_per_sbk;
195 }
196 pstr_sfb_info_ip = pstr_sfb_info_short;
197 }
198 }
199
ixheaacd_decode_init(VOID * handle,WORD32 sample_rate,ia_usac_data_struct * usac_data,ia_audio_specific_config_struct * pstr_stream_config)200 WORD32 ixheaacd_decode_init(
201 VOID *handle, WORD32 sample_rate, ia_usac_data_struct *usac_data,
202 ia_audio_specific_config_struct *pstr_stream_config) {
203 WORD32 i;
204 ia_exhaacplus_dec_api_struct *codec_handle =
205 (ia_exhaacplus_dec_api_struct *)handle;
206 ia_aac_dec_state_struct *aac_dec_handle = codec_handle->p_state_aac;
207 WORD32 fscale;
208
209 WORD32 ele_id = 0;
210
211 ia_usac_config_struct *ptr_usac_config =
212 &(pstr_stream_config->str_usac_config);
213 ia_usac_decoder_config_struct *ptr_usac_dec_config =
214 &(pstr_stream_config->str_usac_config.str_usac_dec_config);
215 WORD32 num_elements = ptr_usac_dec_config->num_elements;
216 WORD32 chan = 0;
217
218 usac_data->ec_flag = codec_handle->aac_config.ui_err_conceal;
219 usac_data->huffman_code_book_scl = aac_dec_handle->huffman_code_book_scl;
220 usac_data->huffman_code_book_scl_index =
221 aac_dec_handle->huffman_code_book_scl_index;
222
223 usac_data->tns_coeff3_32 =
224 aac_dec_handle->pstr_aac_tables->pstr_block_tables->tns_coeff3_32;
225 usac_data->tns_coeff4_32 =
226 aac_dec_handle->pstr_aac_tables->pstr_block_tables->tns_coeff4_32;
227 usac_data->tns_max_bands_tbl_usac =
228 &aac_dec_handle->pstr_aac_tables->pstr_block_tables
229 ->tns_max_bands_tbl_usac;
230 for (WORD32 ch = 0; ch < MAX_NUM_CHANNELS; ch++) {
231 ixheaacd_usac_ec_init(&usac_data->str_error_concealment[ch], usac_data->core_mode);
232 memset(&usac_data->overlap_data_ptr[ch][0], 0, sizeof(usac_data->overlap_data_ptr[ch]));
233 }
234
235 for (i = 0; i < 11; i++) {
236 if (ixheaacd_sampling_boundaries[i] <= sample_rate) break;
237 }
238
239 if (i == (1 << LEN_SAMP_IDX)) return -1;
240 usac_data->sampling_rate_idx = i;
241
242 fscale = (WORD32)((double)sample_rate * (double)FSCALE_DENOM / 12800.0f);
243
244 for (i = 0; i < MAX_NUM_CHANNELS; i++) {
245 usac_data->window_shape_prev[i] = 0;
246 usac_data->window_shape[i] = 0;
247 }
248
249 ixheaacd_hufftab(&ixheaacd_book, ixheaacd_huff_book_scl,
250 ixheaacd_book_scl_code_book, ixheaacd_book_scl_index, 1, 60,
251 60, 1, 19);
252
253 usac_data->pstr_usac_winmap[0] = &usac_data->str_only_long_info;
254 usac_data->pstr_usac_winmap[1] = &usac_data->str_only_long_info;
255 usac_data->pstr_usac_winmap[2] = &usac_data->str_eight_short_info;
256 usac_data->pstr_usac_winmap[3] = &usac_data->str_only_long_info;
257 usac_data->pstr_usac_winmap[4] = &usac_data->str_only_long_info;
258
259 if ((usac_data->ccfl != 480) && (usac_data->ccfl != 512) &&
260 (usac_data->ccfl != 768) && (usac_data->ccfl != 960) &&
261 (usac_data->ccfl != 1024))
262 return -1;
263 ixheaacd_info_init(&ixheaacd_samp_rate_info[usac_data->sampling_rate_idx],
264 usac_data->ccfl, usac_data->pstr_usac_winmap[0],
265 usac_data->pstr_usac_winmap[2], usac_data->sfb_width_short,
266 usac_data->sfb_width_long);
267
268 for (i = 0; i < MAX_NUM_CHANNELS; i++) {
269 usac_data->str_tddec[i] = &usac_data->arr_str_tddec[i];
270 if (usac_data->ccfl == 768)
271 usac_data->str_tddec[i]->fscale = pstr_stream_config->sampling_frequency;
272 else
273 usac_data->str_tddec[i]->fscale =
274 ((fscale)*usac_data->ccfl) / LEN_SUPERFRAME;
275 usac_data->len_subfrm = usac_data->ccfl / 4;
276
277 {
278 WORD32 fac_length = usac_data->len_subfrm / 4;
279 if (fac_length & (fac_length - 1)) {
280 if ((fac_length != 48) && (fac_length != 96) && (fac_length != 192) &&
281 (fac_length != 384) && (fac_length != 768)) {
282 return -1;
283 }
284 }
285 }
286 usac_data->num_subfrm = (MAX_NUM_SUBFR * usac_data->ccfl) / LEN_SUPERFRAME;
287
288 ixheaacd_init_acelp_data(usac_data, usac_data->str_tddec[i]);
289
290 usac_data->str_tddec[i]->fd_synth =
291 &usac_data->str_tddec[i]->fd_synth_buf[LEN_FRAME];
292 }
293
294 for (ele_id = 0; ele_id < num_elements; ele_id++) {
295 UWORD32 ele_type;
296 WORD32 stereo_config_index;
297
298 ia_usac_dec_element_config_struct *ptr_usac_ele_config =
299 &ptr_usac_config->str_usac_dec_config.str_usac_element_config[ele_id];
300
301 if (ptr_usac_ele_config) {
302 if (usac_data->tw_mdct[ele_id]) {
303 if (usac_data->ec_flag) {
304 usac_data->tw_mdct[ele_id] = 0;
305 } else
306 return -1;
307 }
308
309 usac_data->noise_filling_config[ele_id] = ptr_usac_ele_config->noise_filling;
310 }
311
312 ele_type = ptr_usac_config->str_usac_dec_config.usac_element_type[ele_id];
313
314 stereo_config_index = ptr_usac_ele_config->stereo_config_index;
315
316 switch (ele_type) {
317 case ID_USAC_SCE:
318 case ID_USAC_LFE:
319
320 if ((chan + 1) > MAX_NUM_CHANNELS_USAC_LVL2) return -1;
321 usac_data->seed_value[chan] = 0x3039;
322 chan++;
323
324 break;
325
326 case ID_USAC_CPE: {
327 static const WORD32 frame_len_tbl[MAX_CORE_SBR_FRAME_LEN_IDX + 1] = {
328 -1, -1, 32, 32, 64};
329
330 if ((chan + 2) > MAX_NUM_CHANNELS_USAC_LVL2) return -1;
331 usac_data->seed_value[chan] = 0x3039;
332 chan++;
333
334 usac_data->seed_value[chan] = 0x10932;
335 chan++;
336
337 if (stereo_config_index > 0) {
338 WORD32 bs_frame_length =
339 frame_len_tbl[ptr_usac_config->core_sbr_framelength_index];
340 WORD32 bs_residual_coding = (stereo_config_index > 1) ? 1 : 0;
341
342 ia_usac_dec_mps_config_struct *ptr_usac_mps212_config =
343 &(ptr_usac_config->str_usac_dec_config
344 .str_usac_element_config[ele_id]
345 .str_usac_mps212_config);
346 aac_dec_handle->mps_dec_handle.ec_flag = aac_dec_handle->ec_enable;
347
348 if (ixheaacd_mps_create(&aac_dec_handle->mps_dec_handle,
349 bs_frame_length, bs_residual_coding,
350 ptr_usac_mps212_config)) {
351 return -1;
352 }
353 }
354 break;
355 }
356
357 break;
358 case ID_USAC_EXT:
359 break;
360 default:
361 return -1;
362 break;
363 }
364 }
365
366 return 0;
367 }
368
ixheaacd_dec_data_init(VOID * handle,ia_frame_data_struct * pstr_frame_data,ia_usac_data_struct * usac_data)369 WORD32 ixheaacd_dec_data_init(VOID *handle,
370 ia_frame_data_struct *pstr_frame_data,
371 ia_usac_data_struct *usac_data) {
372 ia_audio_specific_config_struct *pstr_stream_config, *layer_config;
373 WORD32 err_code = 0;
374 WORD32 i_ch, i, ele_id;
375 WORD32 num_elements;
376
377 WORD32 out_frame_len, sbr_ratio_idx;
378
379 ia_usac_config_struct *ptr_usac_config =
380 &(pstr_frame_data->str_audio_specific_config.str_usac_config);
381
382 usac_data->last_frame_ok = 1;
383 usac_data->frame_ok = 1;
384 usac_data->window_shape_prev[0] = WIN_SEL_0;
385 usac_data->window_shape_prev[1] = WIN_SEL_0;
386
387 pstr_frame_data->str_layer.bit_rate =
388 pstr_frame_data->str_audio_specific_config.avg_bit_rate;
389 pstr_stream_config = &pstr_frame_data->str_audio_specific_config;
390 layer_config = &pstr_frame_data->str_audio_specific_config;
391
392 sbr_ratio_idx = ixheaacd_sbr_params(
393 ptr_usac_config->core_sbr_framelength_index, &out_frame_len,
394 &usac_data->ccfl, &usac_data->output_samples,
395 &pstr_frame_data->str_layer.sample_rate_layer,
396 &layer_config->samp_frequency_index);
397 if (!pstr_frame_data->str_layer.sample_rate_layer) {
398 return -1;
399 }
400 pstr_stream_config->sampling_frequency =
401 pstr_frame_data->str_layer.sample_rate_layer;
402 pstr_stream_config->samp_frequency_index = layer_config->samp_frequency_index;
403
404 num_elements = ptr_usac_config->str_usac_dec_config.num_elements;
405
406 for (ele_id = 0; ele_id < num_elements; ele_id++) {
407 ia_usac_dec_element_config_struct *ptr_usac_ele_config =
408 &(ptr_usac_config->str_usac_dec_config.str_usac_element_config[ele_id]);
409
410 if (ptr_usac_ele_config) {
411 usac_data->tw_mdct[ele_id] = ptr_usac_ele_config->tw_mdct;
412 }
413
414 {
415 ia_usac_dec_mps_config_struct *ptr_usac_mps212_config =
416 &ptr_usac_ele_config->str_usac_mps212_config;
417 WORD32 stereo_config_index = ptr_usac_ele_config->stereo_config_index;
418
419 usac_data->mps_pseudo_lr[ele_id] =
420 (stereo_config_index > 1) ? ptr_usac_mps212_config->bs_pseudo_lr : 0;
421 }
422 }
423
424 usac_data->sbr_ratio_idx = sbr_ratio_idx;
425 usac_data->esbr_bit_str[0].no_elements = 0;
426 usac_data->esbr_bit_str[1].no_elements = 0;
427
428 if (usac_data->ccfl == 768)
429 pstr_frame_data->str_layer.sample_rate_layer =
430 4 * pstr_frame_data->str_layer.sample_rate_layer / 3;
431
432 for (i = 0; i < MAX_NUM_CHANNELS; i++) {
433 usac_data->coef_fix[i] = &usac_data->arr_coef_fix[i][0];
434 usac_data->coef[i] = &usac_data->arr_coef[i][0];
435 usac_data->coef_save[i] = &usac_data->arr_coef_save[i][0];
436 usac_data->factors[i] = &usac_data->arr_factors[i][0];
437 usac_data->group_dis[i] = &usac_data->arr_group_dis[i][0];
438 usac_data->pstr_tns[i] = &usac_data->arr_str_tns[i];
439 usac_data->tw_ratio[i] = &usac_data->arr_tw_ratio[i][0];
440 usac_data->ms_used[i] = &usac_data->arr_ms_used[i][0];
441 usac_data->window_shape_prev[i] = WIN_SEL_0;
442
443 usac_data->seed_value[i] = 0x0;
444
445 usac_data->fac_data_present[i] = 0;
446 }
447
448 err_code =
449 ixheaacd_decode_init(handle, pstr_frame_data->str_layer.sample_rate_layer,
450 usac_data, pstr_stream_config);
451 if (err_code != 0) return err_code;
452
453 for (i_ch = 0; i_ch < MAX_NUM_CHANNELS; i_ch++) {
454 if (usac_data->tw_mdct[0] == 1) {
455 WORD32 i;
456 for (i = 0; i < 2 * usac_data->ccfl; i++) {
457 usac_data->warp_cont_mem[i_ch][i] = 1.0;
458 }
459 usac_data->warp_sum[i_ch][0] = usac_data->warp_sum[i_ch][1] =
460 (FLOAT32)usac_data->ccfl;
461 }
462 }
463 return err_code;
464 }
465
ixheaacd_count_tracks_per_layer(int * max_layer,int * stream_count,int * tracks_in_layer)466 static VOID ixheaacd_count_tracks_per_layer(int *max_layer, int *stream_count,
467 int *tracks_in_layer) {
468 WORD32 stream;
469 WORD32 num_layer;
470 WORD32 num_streams;
471 WORD32 layer = 0;
472
473 if (stream_count == NULL)
474 num_streams = 0;
475 else
476 num_streams = *stream_count;
477 if (max_layer == NULL)
478 num_layer = num_streams;
479 else
480 num_layer = *max_layer;
481 if (num_layer < 0) num_layer = num_streams;
482
483 for (stream = 0; (layer <= num_layer) && (stream < num_streams);) {
484 *tracks_in_layer = 1;
485 stream += 1;
486 layer++;
487 if (layer <= num_layer) *tracks_in_layer = 0;
488 }
489
490 if (max_layer) *max_layer = (layer - 1);
491 if (stream_count) *stream_count = stream;
492 }
493
ixheaacd_frm_data_init(ia_audio_specific_config_struct * pstr_audio_conf,ia_dec_data_struct * pstr_dec_data)494 WORD32 ixheaacd_frm_data_init(ia_audio_specific_config_struct *pstr_audio_conf,
495 ia_dec_data_struct *pstr_dec_data)
496
497 {
498 WORD32 layer;
499 WORD32 track;
500 WORD32 num_dec_streams;
501 ia_frame_data_struct *pstr_frame_data;
502
503 WORD32 stream_count = 1;
504 WORD32 max_layer = -1;
505
506 memset(pstr_dec_data, 0, IXHEAAC_GET_SIZE_ALIGNED(sizeof(ia_dec_data_struct), BYTE_ALIGN_8));
507 memset(&(pstr_dec_data->str_frame_data), 0,
508 sizeof(pstr_dec_data->str_frame_data));
509
510 pstr_frame_data = &(pstr_dec_data->str_frame_data);
511
512 if (max_layer < 0) max_layer = stream_count - 1;
513
514 ixheaacd_count_tracks_per_layer(&max_layer, &stream_count,
515 &pstr_frame_data->tracks_in_layer);
516
517 pstr_frame_data->scal_out_select = max_layer;
518
519 pstr_frame_data->stream_count = 0;
520
521 num_dec_streams = track = 0;
522 for (layer = 0; layer < (signed)pstr_frame_data->scal_out_select + 1;
523 layer++) {
524 WORD32 j;
525 for (j = 0; j < 1; j++, num_dec_streams++) {
526 pstr_frame_data->str_audio_specific_config = *pstr_audio_conf;
527 pstr_frame_data->str_layer.sample_rate_layer =
528 pstr_frame_data->str_audio_specific_config.sampling_frequency;
529 pstr_frame_data->str_layer.bit_rate =
530 pstr_frame_data->str_audio_specific_config.avg_bit_rate;
531 }
532
533 track += pstr_frame_data->tracks_in_layer;
534 }
535
536 pstr_frame_data->stream_count = num_dec_streams;
537
538 return num_dec_streams;
539 }
540
ixheaacd_decode_create(ia_exhaacplus_dec_api_struct * handle,ia_dec_data_struct * pstr_dec_data,WORD32 tracks_for_decoder)541 WORD32 ixheaacd_decode_create(ia_exhaacplus_dec_api_struct *handle,
542 ia_dec_data_struct *pstr_dec_data,
543 WORD32 tracks_for_decoder) {
544 WORD32 stream;
545
546 WORD32 err = 0;
547 ia_frame_data_struct *pstr_frame_data;
548 WORD32 stream_count;
549 ia_aac_dec_state_struct *aac_dec_handle = handle->p_state_aac;
550 pstr_frame_data = &(pstr_dec_data->str_frame_data);
551 stream_count = pstr_frame_data->stream_count;
552 pstr_frame_data->stream_count = tracks_for_decoder;
553
554 for (stream = 0; stream < stream_count; stream++) {
555 UWORD32 aot = pstr_frame_data->str_audio_specific_config.audio_object_type;
556
557 switch (aot) {
558 case AOT_USAC:
559
560 err = ixheaacd_dec_data_init(handle, pstr_frame_data,
561 &(pstr_dec_data->str_usac_data));
562
563 if (err != 0) {
564 if (handle->aac_config.ui_err_conceal) {
565 pstr_dec_data->str_usac_data.frame_ok = 0;
566 } else
567 return err;
568 }
569
570 pstr_dec_data->str_usac_data.sampling_rate = pstr_frame_data->str_layer.sample_rate_layer;
571
572 switch (pstr_dec_data->str_usac_data.sbr_ratio_idx) {
573 case 0:
574 handle->aac_config.ui_sbr_mode = 0;
575 break;
576 case 1:
577 handle->aac_config.ui_sbr_mode = 1;
578 break;
579 case 2:
580 handle->aac_config.ui_sbr_mode = 1;
581 break;
582 case 3:
583 handle->aac_config.ui_sbr_mode = 3;
584 break;
585
586 default:
587 handle->aac_config.ui_sbr_mode = 0;
588 }
589
590 if (!aac_dec_handle->peak_lim_init && !handle->aac_config.peak_limiter_off &&
591 handle->aac_config.ui_err_conceal) {
592 memset(&aac_dec_handle->peak_limiter, 0, sizeof(ia_peak_limiter_struct));
593 ixheaacd_peak_limiter_init(&aac_dec_handle->peak_limiter, MAX_NUM_CHANNELS,
594 pstr_dec_data->str_usac_data.sampling_rate,
595 &aac_dec_handle->peak_limiter.buffer[0],
596 &aac_dec_handle->delay_in_samples);
597 aac_dec_handle->peak_lim_init++;
598 }
599
600 break;
601
602 default:
603
604 break;
605 }
606 }
607
608 pstr_frame_data->scal_out_object_type =
609 pstr_frame_data->str_audio_specific_config.audio_object_type;
610 pstr_frame_data->scal_out_num_channels =
611 pstr_frame_data->str_audio_specific_config.channel_configuration;
612 pstr_frame_data->scal_out_sampling_frequency =
613 pstr_frame_data->str_audio_specific_config.sampling_frequency;
614
615 if (&(pstr_dec_data->str_usac_data) != NULL) {
616 ia_sbr_header_data_struct usac_def_header;
617 ia_audio_specific_config_struct *pstr_aud_spec_config =
618 &pstr_frame_data->str_audio_specific_config;
619 ia_usac_config_struct *ptr_usac_config =
620 &(pstr_frame_data->str_audio_specific_config.str_usac_config);
621
622 WORD32 inter_test_flag = 0;
623 WORD32 bs_pvc_flag = 0;
624 WORD32 harmonic_Sbr_flag = 0;
625
626 ia_usac_decoder_config_struct *ptr_usac_dec_config =
627 &ptr_usac_config->str_usac_dec_config;
628 WORD32 const num_ele = ptr_usac_dec_config->num_elements;
629 WORD32 elem_idx = 0;
630
631 memset(&usac_def_header, 0, sizeof(ia_sbr_header_data_struct));
632
633 for (elem_idx = 0; elem_idx < num_ele; elem_idx++) {
634 UWORD32 usac_ele_type =
635 ptr_usac_config->str_usac_dec_config.usac_element_type[elem_idx];
636 ia_usac_dec_element_config_struct *ptr_usac_ele_config =
637 &ptr_usac_config->str_usac_dec_config
638 .str_usac_element_config[elem_idx];
639
640 ia_usac_dec_sbr_config_struct *ptr_usac_sbr_config =
641 &(ptr_usac_dec_config->str_usac_element_config[elem_idx]
642 .str_usac_sbr_config);
643
644 if (ptr_usac_sbr_config->bs_inter_tes) inter_test_flag = 1;
645 if (ptr_usac_sbr_config->bs_pvc) bs_pvc_flag = 1;
646 if (ptr_usac_sbr_config->harmonic_sbr) harmonic_Sbr_flag = 1;
647
648 if ((usac_ele_type != ID_USAC_LFE) && (usac_ele_type != ID_USAC_EXT)) {
649 ia_usac_dec_sbr_config_struct *ptr_usac_sbr_config =
650 &(ptr_usac_ele_config->str_usac_sbr_config);
651
652 usac_def_header.start_freq = ptr_usac_sbr_config->dflt_start_freq;
653 usac_def_header.stop_freq = ptr_usac_sbr_config->dflt_stop_freq;
654 usac_def_header.header_extra_1 =
655 ptr_usac_sbr_config->dflt_header_extra1;
656 usac_def_header.header_extra_2 =
657 ptr_usac_sbr_config->dflt_header_extra2;
658 usac_def_header.freq_scale = ptr_usac_sbr_config->dflt_freq_scale;
659 usac_def_header.alter_scale = ptr_usac_sbr_config->dflt_alter_scale;
660 usac_def_header.noise_bands = ptr_usac_sbr_config->dflt_noise_bands;
661 usac_def_header.limiter_bands = ptr_usac_sbr_config->dflt_limiter_bands;
662 usac_def_header.limiter_gains = ptr_usac_sbr_config->dflt_limiter_gains;
663 usac_def_header.interpol_freq = ptr_usac_sbr_config->dflt_interpol_freq;
664 usac_def_header.smoothing_mode =
665 ptr_usac_sbr_config->dflt_smoothing_mode;
666 }
667 }
668
669 pstr_dec_data->str_usac_data.down_samp_sbr = 0;
670
671 if (pstr_dec_data->str_usac_data.sbr_ratio_idx > 0) {
672 if (pstr_aud_spec_config->ext_sampling_frequency ==
673 pstr_aud_spec_config->sampling_frequency) {
674 pstr_dec_data->str_usac_data.down_samp_sbr = 1;
675 }
676 if (pstr_dec_data->str_usac_data.down_samp_sbr == 0) {
677 if (pstr_dec_data->str_usac_data.sbr_ratio_idx == 3) {
678 pstr_frame_data->scal_out_sampling_frequency =
679 4 * pstr_frame_data->scal_out_sampling_frequency;
680 } else {
681 pstr_frame_data->scal_out_sampling_frequency =
682 2 * pstr_frame_data->scal_out_sampling_frequency;
683 }
684 }
685
686 {
687 void *sbr_persistent_mem_v = aac_dec_handle->sbr_persistent_mem_u;
688
689 pstr_dec_data->str_usac_data.pstr_esbr_dec = ixheaacd_init_sbr(
690 pstr_frame_data->str_layer.sample_rate_layer,
691 pstr_dec_data->str_usac_data.ccfl,
692 &pstr_dec_data->str_usac_data.down_samp_sbr, sbr_persistent_mem_v,
693 NULL, pstr_frame_data->scal_out_num_channels, 0,
694 pstr_dec_data->str_usac_data.sbr_ratio_idx,
695 pstr_dec_data->str_usac_data.output_samples, &harmonic_Sbr_flag,
696 (void *)&usac_def_header, aac_dec_handle->str_sbr_config,
697 pstr_dec_data->str_usac_data.audio_object_type, 0, 0);
698 pstr_dec_data->str_usac_data.sbr_scratch_mem_base =
699 aac_dec_handle->sbr_scratch_mem_u;
700 if (num_ele)
701 ixheaacd_setesbr_flags(sbr_persistent_mem_v, bs_pvc_flag,
702 harmonic_Sbr_flag, inter_test_flag);
703 }
704
705 if (pstr_dec_data->str_usac_data.pstr_esbr_dec == NULL) {
706 return -1;
707 } else {
708 pstr_dec_data->str_usac_data.pstr_esbr_dec->xaac_jmp_buf =
709 &(aac_dec_handle->xaac_jmp_buf);
710 }
711 }
712 }
713 aac_dec_handle->decode_create_done = 1;
714 return 0;
715 }
716