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 <stdlib.h>
21 #include "ixheaac_type_def.h"
22 #include "ixheaac_error_standards.h"
23 #include "ixheaac_constants.h"
24 #include "ixheaac_basic_ops32.h"
25 #include "ixheaac_basic_ops16.h"
26 #include "ixheaac_basic_ops40.h"
27 #include "ixheaacd_sbr_common.h"
28
29 #include "ixheaacd_bitbuffer.h"
30 #include "ixheaacd_defines.h"
31 #include "ixheaacd_aac_rom.h"
32
33 #include "ixheaacd_sbrdecsettings.h"
34 #include "ixheaacd_sbr_scale.h"
35 #include "ixheaacd_env_extr_part.h"
36 #include "ixheaacd_sbr_rom.h"
37
38 #include "ixheaacd_lpp_tran.h"
39 #include "ixheaacd_hybrid.h"
40 #include "ixheaacd_ps_dec.h"
41
42 #include "ixheaacd_env_extr.h"
43 #include "ixheaacd_common_rom.h"
44
45 #include "ixheaacd_pulsedata.h"
46
47 #include "ixheaacd_pns.h"
48 #include "ixheaacd_drc_data_struct.h"
49
50 #include "ixheaacd_lt_predict.h"
51
52 #include "ixheaacd_cnst.h"
53 #include "ixheaacd_ec_defines.h"
54 #include "ixheaacd_ec_struct_def.h"
55 #include "ixheaacd_channelinfo.h"
56 #include "ixheaacd_drc_dec.h"
57 #include "ixheaacd_sbrdecoder.h"
58 #include "ixheaacd_block.h"
59 #include "ixheaacd_channel.h"
60
61 #include "ixheaacd_adts.h"
62 #include "ixheaacd_audioobjtypes.h"
63 #include "ixheaacd_sbrdecoder.h"
64 #include "ixheaacd_memory_standards.h"
65
66 #include "ixheaacd_latmdemux.h"
67
68 #include "ixheaacd_aacdec.h"
69 #include "ixheaacd_mps_polyphase.h"
70 #include "ixheaacd_config.h"
71 #include "ixheaacd_qmf_dec.h"
72 #include "ixheaacd_mps_macro_def.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 #include "ixheaacd_error_codes.h"
79 #include "ixheaacd_definitions.h"
80 #include "ixheaacd_adts_crc_check.h"
81
82 #include "ixheaacd_headerdecode.h"
83
84 #include "ixheaacd_interface.h"
85 #include "ixheaacd_info.h"
86 #include "ixheaacd_mps_interface.h"
87 #include "ixheaacd_config.h"
88
89 #include "ixheaacd_struct.h"
90 #include "ixheaacd_function_selector.h"
91 #include "ixheaacd_ld_mps_dec.h"
92
93 #include "ixheaac_error_standards.h"
94
95 #define ELDEXT_SAOC 1
96 #define ELDEXT_TERM 0
97 #define ELDEXT_LDSAC 2
98
99 extern const WORD32 ixheaacd_sampl_freq_idx_table[17];
100
101 #define AAC_LC_PROFILE (2)
102
103 #define ADTS_HEADER_LENGTH 7
104
105 static PLATFORM_INLINE VOID
ixheaacd_aac_bytealign(struct ia_bit_buf_struct * it_bit_buff)106 ixheaacd_aac_bytealign(struct ia_bit_buf_struct *it_bit_buff) {
107 WORD16 num_bit;
108 num_bit = (it_bit_buff->bit_pos + 1);
109 if (num_bit != 8) {
110 it_bit_buff->bit_pos = 7;
111 it_bit_buff->cnt_bits -= num_bit;
112 it_bit_buff->ptr_read_next += 1;
113 }
114 }
115
ixheaacd_read_pce_channel_info(WORD32 ch,WORD8 * ptr_is_cpe,WORD8 * ptr_tag_select,struct ia_bit_buf_struct * it_bit_buff)116 WORD32 ixheaacd_read_pce_channel_info(WORD32 ch, WORD8 *ptr_is_cpe,
117 WORD8 *ptr_tag_select,
118 struct ia_bit_buf_struct *it_bit_buff) {
119 WORD32 num_ch = 0, i, tmp;
120 for (i = 0; i < ch; i++) {
121 tmp = ixheaacd_read_bits_buf(it_bit_buff, 5);
122 ptr_is_cpe[i] = (tmp & 0x10) >> 4;
123
124 if (ptr_is_cpe[i]) {
125 num_ch += 2;
126 } else {
127 num_ch++;
128 }
129
130 ptr_tag_select[i] = (tmp & 0xF);
131 }
132 return num_ch;
133 }
134
ixheaacd_read_pce_mixdown_data(struct ia_bit_buf_struct * it_bit_buff,WORD32 mix_down_present,WORD32 mix_down_element_no)135 VOID ixheaacd_read_pce_mixdown_data(struct ia_bit_buf_struct *it_bit_buff,
136 WORD32 mix_down_present,
137 WORD32 mix_down_element_no) {
138 WORD32 mix_down_flag = ixheaacd_read_bits_buf(it_bit_buff, mix_down_present);
139 if (mix_down_flag == 1) {
140 ixheaacd_read_bits_buf(it_bit_buff, mix_down_element_no);
141 }
142 }
143
ixheaacd_skip_bits(struct ia_bit_buf_struct * it_bit_buff,WORD32 bits,WORD32 num_element)144 VOID ixheaacd_skip_bits(struct ia_bit_buf_struct *it_bit_buff, WORD32 bits,
145 WORD32 num_element) {
146 WORD32 i;
147 for (i = 0; i < num_element; i++) {
148 ixheaacd_read_bits_buf(it_bit_buff, bits);
149 }
150 }
151
ixheaacd_read_prog_config_element(ia_program_config_struct * ptr_config_element,struct ia_bit_buf_struct * it_bit_buff)152 WORD32 ixheaacd_read_prog_config_element(
153 ia_program_config_struct *ptr_config_element,
154 struct ia_bit_buf_struct *it_bit_buff) {
155 WORD32 i, tmp;
156 WORD count = 0, num_ch = 0;
157
158 tmp = ixheaacd_read_bits_buf(it_bit_buff, 6);
159
160 ptr_config_element->element_instance_tag = (tmp >> 2);
161 ptr_config_element->object_type = tmp & 0x3;
162
163 if ((ptr_config_element->object_type + 1) != 2
164
165 && (ptr_config_element->object_type + 1) != 4
166
167 ) {
168 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
169 }
170
171 ptr_config_element->samp_freq_index = ixheaacd_read_bits_buf(it_bit_buff, 4);
172 if (ptr_config_element->samp_freq_index > 11) {
173 return IA_XHEAAC_DEC_EXE_NONFATAL_DECODE_FRAME_ERROR;
174 }
175
176 tmp = ixheaacd_read_bits_buf(it_bit_buff, 21);
177
178 count += ptr_config_element->num_front_channel_elements = (tmp >> 17);
179 count += ptr_config_element->num_side_channel_elements =
180 (tmp & 0x1E000) >> 13;
181 count += ptr_config_element->num_back_channel_elements = (tmp & 0x1E00) >> 9;
182 count += ptr_config_element->num_lfe_channel_elements = (tmp & 0x180) >> 7;
183 ptr_config_element->num_assoc_data_elements = (tmp & 0x70) >> 4;
184 count += ptr_config_element->num_valid_cc_elements = tmp & 0xF;
185
186 if (count > MAX_BS_ELEMENT) {
187 return IA_XHEAAC_DEC_INIT_FATAL_STREAM_CHAN_GT_MAX;
188 }
189
190 ixheaacd_read_pce_mixdown_data(it_bit_buff, 1, 4);
191 ixheaacd_read_pce_mixdown_data(it_bit_buff, 1, 4);
192 ixheaacd_read_pce_mixdown_data(it_bit_buff, 1, 3);
193
194 num_ch += ixheaacd_read_pce_channel_info(
195 ptr_config_element->num_front_channel_elements,
196 ptr_config_element->front_element_is_cpe,
197 ptr_config_element->front_element_tag_select, it_bit_buff);
198
199 num_ch += ixheaacd_read_pce_channel_info(
200 ptr_config_element->num_side_channel_elements,
201 ptr_config_element->side_element_is_cpe,
202 ptr_config_element->side_element_tag_select, it_bit_buff);
203
204 num_ch += ixheaacd_read_pce_channel_info(
205 ptr_config_element->num_back_channel_elements,
206 ptr_config_element->back_element_is_cpe,
207 ptr_config_element->back_element_tag_select, it_bit_buff);
208
209 num_ch += ptr_config_element->num_lfe_channel_elements;
210
211 for (i = 0; i < (ptr_config_element->num_lfe_channel_elements); i++) {
212 ptr_config_element->lfe_element_tag_select[i] =
213 ixheaacd_read_bits_buf(it_bit_buff, 4);
214 }
215
216 ptr_config_element->channels = num_ch;
217
218 for (i = 0; i < (ptr_config_element->num_assoc_data_elements); i++) {
219 ixheaacd_read_bits_buf(it_bit_buff, 4);
220 }
221
222 ixheaacd_skip_bits(it_bit_buff, 5, ptr_config_element->num_valid_cc_elements);
223
224 {
225 WORD32 bits_to_read = ptr_config_element->alignment_bits;
226 if (bits_to_read <= it_bit_buff->bit_pos) {
227 bits_to_read = it_bit_buff->bit_pos - bits_to_read;
228 } else {
229 bits_to_read = 8 - (bits_to_read) + it_bit_buff->bit_pos;
230 }
231 tmp = ixheaacd_read_bits_buf(it_bit_buff, bits_to_read);
232 }
233 tmp = ixheaacd_read_bits_buf(it_bit_buff, 8);
234
235 ixheaacd_skip_bits(it_bit_buff, 8, tmp);
236
237 return 0;
238 }
239
ixheaacd_decode_pce(struct ia_bit_buf_struct * it_bit_buff,UWORD32 * ui_pce_found_in_hdr,ia_program_config_struct * ptr_prog_config)240 WORD ixheaacd_decode_pce(struct ia_bit_buf_struct *it_bit_buff,
241 UWORD32 *ui_pce_found_in_hdr,
242 ia_program_config_struct *ptr_prog_config) {
243 WORD32 error_code = 0;
244
245 if (*ui_pce_found_in_hdr == 1 || *ui_pce_found_in_hdr == 3) {
246 ia_program_config_struct ptr_config_element = {0};
247 ptr_config_element.alignment_bits = ptr_prog_config->alignment_bits;
248 error_code =
249 ixheaacd_read_prog_config_element(&ptr_config_element, it_bit_buff);
250 *ui_pce_found_in_hdr = 3;
251 } else {
252 error_code =
253 ixheaacd_read_prog_config_element(ptr_prog_config, it_bit_buff);
254 *ui_pce_found_in_hdr = 2;
255 }
256 return error_code;
257 }
258
ixheaacd_get_adif_header(ia_adif_header_struct * adif,struct ia_bit_buf_struct * it_bit_buff)259 static PLATFORM_INLINE WORD32 ixheaacd_get_adif_header(
260 ia_adif_header_struct *adif, struct ia_bit_buf_struct *it_bit_buff) {
261 WORD32 i;
262 WORD32 ret_val = 0, tmp;
263
264 ixheaacd_read_bits_buf(it_bit_buff, 16);
265 tmp = ixheaacd_read_bits_buf(it_bit_buff, 17);
266
267 if (tmp & 0x1) {
268 ixheaacd_skip_bits(it_bit_buff, 8, 9);
269 }
270
271 tmp = ixheaacd_read_bits_buf(it_bit_buff, 3);
272
273 adif->bit_stream_type = (tmp & 0x1);
274
275 ixheaacd_read_bits_buf(it_bit_buff, 23);
276
277 tmp = ixheaacd_read_bits_buf(it_bit_buff, 4);
278
279 for (i = 0; i <= tmp; i++) {
280 if (adif->bit_stream_type == 0) {
281 ixheaacd_read_bits_buf(it_bit_buff, 20);
282 }
283
284 adif->prog_config_present = 1;
285 adif->str_prog_config.alignment_bits = 7;
286 ret_val =
287 ixheaacd_read_prog_config_element(&adif->str_prog_config, it_bit_buff);
288 if (ret_val) {
289 return ret_val;
290 }
291 }
292
293 return 0;
294 }
295
ixheaacd_find_syncword(ia_adts_header_struct * adts,struct ia_bit_buf_struct * it_bit_buff)296 WORD32 ixheaacd_find_syncword(ia_adts_header_struct *adts,
297 struct ia_bit_buf_struct *it_bit_buff) {
298 adts->sync_word = (WORD16)ixheaacd_read_bits_buf(it_bit_buff, 12);
299 if (adts->sync_word == 0xFFF) {
300 return 0;
301 }
302
303 while (1) {
304 ixheaacd_read_bidirection(it_bit_buff, -4);
305 if (it_bit_buff->cnt_bits < 12) {
306 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
307 }
308 adts->sync_word = (WORD16)ixheaacd_read_bits_buf(it_bit_buff, 12);
309 if (adts->sync_word == 0xFFF) {
310 ixheaacd_read_bidirection(it_bit_buff, -12);
311 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
312 }
313 }
314 }
315
ixheaacd_adtsframe(ia_adts_header_struct * adts,struct ia_bit_buf_struct * it_bit_buff)316 WORD32 ixheaacd_adtsframe(ia_adts_header_struct *adts,
317 struct ia_bit_buf_struct *it_bit_buff) {
318 WORD32 tmp;
319 IA_ERRORCODE err = IA_NO_ERROR;
320 WORD32 crc_reg;
321 ia_adts_crc_info_struct *ptr_adts_crc_info = it_bit_buff->pstr_adts_crc_info;
322 ptr_adts_crc_info->crc_active = 1;
323 ptr_adts_crc_info->no_reg = 0;
324 ixheaacd_read_bidirection(it_bit_buff, -12);
325 crc_reg = ixheaacd_adts_crc_start_reg(ptr_adts_crc_info, it_bit_buff,
326 CRC_ADTS_HEADER_LEN);
327 err = ixheaacd_find_syncword(adts, it_bit_buff);
328 if (err) return err;
329
330 tmp = ixheaacd_read_bits_buf(it_bit_buff, 10);
331
332 adts->id = (tmp & 0x200) >> 9;
333 adts->layer = (tmp & 0x180) >> 7;
334 adts->protection_absent = (tmp & 0x40) >> 6;
335 adts->profile = (tmp & 0x30) >> 4;
336 { adts->profile++; }
337 adts->samp_freq_index = (tmp & 0xF);
338
339 if (((adts->profile != AAC_LC_PROFILE)) || (adts->samp_freq_index > 11))
340
341 {
342 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
343 }
344
345 tmp = ixheaacd_read_bits_buf(it_bit_buff, 21);
346
347 adts->channel_configuration = (WORD32)(tmp & 0xE0000) >> 17;
348
349 adts->aac_frame_length = (tmp & 0x1FFF);
350
351 tmp = ixheaacd_read_bits_buf(it_bit_buff, 13);
352
353 adts->no_raw_data_blocks = (tmp & 0x3);
354
355 ixheaacd_adts_crc_end_reg(ptr_adts_crc_info, it_bit_buff, crc_reg);
356
357 if (adts->protection_absent == 0) {
358 ixheaacd_skip_bits(it_bit_buff, 16, adts->no_raw_data_blocks);
359 adts->crc_check = ixheaacd_read_bits_buf(it_bit_buff, 16);
360
361 ptr_adts_crc_info->crc_active = 1;
362 ptr_adts_crc_info->file_value = adts->crc_check;
363 } else
364 ptr_adts_crc_info->crc_active = 0;
365
366 ixheaacd_aac_bytealign(it_bit_buff);
367 return 0;
368 }
369
ixheaacd_get_samp_rate(struct ia_bit_buf_struct * it_bit_buff,ia_sampling_rate_info_struct * pstr_samp_rate_info,ia_audio_specific_config_struct * pstr_audio_specific_config)370 WORD32 ixheaacd_get_samp_rate(
371 struct ia_bit_buf_struct *it_bit_buff,
372 ia_sampling_rate_info_struct *pstr_samp_rate_info,
373 ia_audio_specific_config_struct *pstr_audio_specific_config) {
374 WORD32 index;
375 WORD32 sampling_rate;
376 index = ixheaacd_read_bits_buf(it_bit_buff, 4);
377 pstr_audio_specific_config->samp_frequency_index = index;
378
379 if (index == 0x0F) {
380 sampling_rate = ixheaacd_read_bits_buf(it_bit_buff, 24);
381
382 if (pstr_audio_specific_config->audio_object_type != AOT_USAC) {
383 if (sampling_rate < 9391)
384 sampling_rate = 8000;
385 else if ((sampling_rate >= 9391) && (sampling_rate < 11502))
386 sampling_rate = 11025;
387 else if ((sampling_rate >= 11502) && (sampling_rate < 13856))
388 sampling_rate = 12000;
389 else if ((sampling_rate >= 13856) && (sampling_rate < 18783))
390 sampling_rate = 16000;
391 else if ((sampling_rate >= 18783) && (sampling_rate < 23004))
392 sampling_rate = 22050;
393 else if ((sampling_rate >= 23004) && (sampling_rate < 27713))
394 sampling_rate = 24000;
395 else if ((sampling_rate >= 27713) && (sampling_rate < 37566))
396 sampling_rate = 32000;
397 else if ((sampling_rate >= 37566) && (sampling_rate < 46009))
398 sampling_rate = 44100;
399 else if ((sampling_rate >= 46009) && (sampling_rate < 55426))
400 sampling_rate = 48000;
401 else if ((sampling_rate >= 55426) && (sampling_rate < 75132))
402 sampling_rate = 64000;
403 else if ((sampling_rate >= 75132) && (sampling_rate < 92017))
404 sampling_rate = 88200;
405 else if (sampling_rate >= 92017)
406 sampling_rate = 96000;
407 }
408 return sampling_rate;
409 } else if ((index > 12) && (index < 15)) {
410 return -1;
411 } else {
412 return ((pstr_samp_rate_info[index].sampling_frequency));
413 }
414 }
ixheaacd_get_ld_sbr_header(ia_bit_buf_struct * it_bit_buff,ia_sbr_header_data_struct * sbr_header_data)415 static int ixheaacd_get_ld_sbr_header(
416 ia_bit_buf_struct *it_bit_buff,
417 ia_sbr_header_data_struct *sbr_header_data) {
418 WORD32 header_extra_1, header_extra_2;
419 UWORD32 tmp, bit_cnt = 0;
420
421 tmp = ixheaacd_read_bits_buf(it_bit_buff, 16);
422 bit_cnt += 16;
423
424 sbr_header_data->amp_res = (tmp & 0x8000) >> 15;
425 sbr_header_data->start_freq = (tmp & 0x7800) >> 11;
426 sbr_header_data->stop_freq = (tmp & 0x780) >> 7;
427 sbr_header_data->xover_band = (tmp & 0x70) >> 4;
428 header_extra_1 = (tmp & 0x0002) >> 1;
429 header_extra_2 = (tmp & 0x0001);
430
431 if (header_extra_1) {
432 sbr_header_data->freq_scale = ixheaacd_read_bits_buf(it_bit_buff, 2);
433 sbr_header_data->alter_scale = ixheaacd_read_bits_buf(it_bit_buff, 1);
434 sbr_header_data->noise_bands = ixheaacd_read_bits_buf(it_bit_buff, 2);
435 } else {
436 sbr_header_data->freq_scale = 2;
437 sbr_header_data->alter_scale = 1;
438 sbr_header_data->noise_bands = 2;
439 }
440
441 if (header_extra_2) {
442 sbr_header_data->limiter_bands = ixheaacd_read_bits_buf(it_bit_buff, 2);
443 sbr_header_data->limiter_gains = ixheaacd_read_bits_buf(it_bit_buff, 2);
444 sbr_header_data->interpol_freq = ixheaacd_read_bits_buf(it_bit_buff, 1);
445 sbr_header_data->smoothing_mode = ixheaacd_read_bits_buf(it_bit_buff, 1);
446 } else {
447 sbr_header_data->limiter_bands = 2;
448 sbr_header_data->limiter_gains = 2;
449 sbr_header_data->interpol_freq = 1;
450 sbr_header_data->smoothing_mode = 1;
451 }
452
453 return (bit_cnt);
454 }
455
ixheaacd_eld_sbr_header(ia_bit_buf_struct * it_bit_buff,WORD32 channels,ia_sbr_header_data_struct * pstr_sbr_config)456 WORD32 ixheaacd_eld_sbr_header(ia_bit_buf_struct *it_bit_buff, WORD32 channels,
457 ia_sbr_header_data_struct *pstr_sbr_config) {
458 int num_sbr_header, el, bit_cnt = 0;
459 switch (channels) {
460 default:
461 num_sbr_header = 0;
462 break;
463 case 1:
464 case 2:
465 num_sbr_header = 1;
466 break;
467 case 3:
468 num_sbr_header = 2;
469 break;
470 case 4:
471 case 5:
472 case 6:
473 num_sbr_header = 3;
474 break;
475 case 7:
476 num_sbr_header = 4;
477 break;
478 }
479 for (el = 0; el < num_sbr_header; el++) {
480 bit_cnt = ixheaacd_get_ld_sbr_header(it_bit_buff, pstr_sbr_config);
481 }
482 return (bit_cnt);
483 }
484
ixheaacd_ga_hdr_dec(ia_aac_dec_state_struct * aac_state_struct,WORD32 header_len,WORD32 * bytes_consumed,ia_sampling_rate_info_struct * pstr_samp_rate_info,struct ia_bit_buf_struct * it_bit_buff)485 WORD32 ixheaacd_ga_hdr_dec(ia_aac_dec_state_struct *aac_state_struct,
486 WORD32 header_len, WORD32 *bytes_consumed,
487 ia_sampling_rate_info_struct *pstr_samp_rate_info,
488 struct ia_bit_buf_struct *it_bit_buff) {
489 WORD32 tmp;
490 WORD32 cnt_bits = it_bit_buff->cnt_bits;
491 UWORD32 aot_init;
492 UWORD32 tmp_aot;
493
494 ia_audio_specific_config_struct *pstr_audio_specific_config;
495
496 memset(aac_state_struct->ia_audio_specific_config, 0,
497 sizeof(ia_audio_specific_config_struct));
498
499 memset(&(aac_state_struct->eld_specific_config), 0,
500 sizeof(ia_eld_specific_config_struct));
501
502 pstr_audio_specific_config = aac_state_struct->ia_audio_specific_config;
503
504 aac_state_struct->p_config->str_prog_config.alignment_bits =
505 it_bit_buff->bit_pos;
506
507 aot_init = aac_state_struct->audio_object_type;
508 aac_state_struct->frame_length = FRAME_SIZE;
509
510 tmp_aot = ixheaacd_read_bits_buf(it_bit_buff, 5);
511
512 if (tmp_aot == 31) {
513 tmp = ixheaacd_read_bits_buf(it_bit_buff, 6);
514 tmp_aot = 32 + tmp;
515 }
516
517 if (aac_state_struct->header_dec_done || aac_state_struct->ui_init_done) {
518 if (tmp_aot != aot_init && tmp_aot != AOT_SBR && tmp_aot != AOT_PS)
519 return IA_FATAL_ERROR;
520 }
521
522 pstr_audio_specific_config->audio_object_type =
523 aac_state_struct->audio_object_type = tmp_aot;
524
525 tmp = ixheaacd_get_samp_rate(it_bit_buff, pstr_samp_rate_info,
526 pstr_audio_specific_config);
527 pstr_audio_specific_config->sampling_frequency = tmp;
528
529 if (tmp == -1) {
530 *bytes_consumed = 1;
531 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
532 } else
533 aac_state_struct->sampling_rate = tmp;
534 aac_state_struct->p_config->ui_samp_freq = tmp;
535
536 aac_state_struct->ch_config = ixheaacd_read_bits_buf(it_bit_buff, 4);
537
538 if (aac_state_struct->audio_object_type == AOT_USAC &&
539 ((aac_state_struct->ch_config >= 3) && (aac_state_struct->ch_config != 8))) {
540 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
541 }
542
543 pstr_audio_specific_config->channel_configuration =
544 aac_state_struct->ch_config;
545
546 if (aac_state_struct->audio_object_type == AOT_SBR ||
547 aac_state_struct->audio_object_type == AOT_PS) {
548 tmp = ixheaacd_get_samp_rate(it_bit_buff, pstr_samp_rate_info,
549 pstr_audio_specific_config);
550 aac_state_struct->sbr_present_flag = 1;
551 if (tmp == -1) {
552 *bytes_consumed = 1;
553 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
554 } else
555 aac_state_struct->extension_samp_rate = tmp;
556
557 aac_state_struct->audio_object_type =
558 ixheaacd_read_bits_buf(it_bit_buff, 5);
559 }
560
561 if (aac_state_struct->header_dec_done || aac_state_struct->ui_init_done) {
562 if (aac_state_struct->audio_object_type != aot_init) return IA_FATAL_ERROR;
563 }
564
565 if (((aac_state_struct->audio_object_type >= AOT_AAC_MAIN &&
566 aac_state_struct->audio_object_type <= AOT_AAC_LTP) ||
567 aac_state_struct->audio_object_type == AOT_AAC_SCAL ||
568 aac_state_struct->audio_object_type == AOT_TWIN_VQ ||
569 aac_state_struct->audio_object_type == AOT_ER_AAC_LD ||
570 aac_state_struct->audio_object_type == AOT_ER_AAC_ELD ||
571 aac_state_struct->audio_object_type == AOT_ER_AAC_SCAL ||
572 aac_state_struct->audio_object_type == AOT_ER_AAC_LC) &&
573 aac_state_struct->audio_object_type != AOT_USAC)
574
575 {
576 aac_state_struct->usac_flag = 0;
577
578 aac_state_struct->frame_len_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
579 if (aac_state_struct->audio_object_type != AOT_ER_AAC_ELD) {
580 aac_state_struct->depends_on_core_coder =
581 ixheaacd_read_bits_buf(it_bit_buff, 1);
582 aac_state_struct->extension_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
583
584 if (aac_state_struct->ch_config == 0) {
585 WORD32 error_code;
586 error_code = ixheaacd_read_prog_config_element(
587 &aac_state_struct->p_config->str_prog_config, it_bit_buff);
588 if (error_code != 0) {
589 *bytes_consumed = 1;
590 return error_code;
591 }
592 aac_state_struct->p_config->ui_pce_found_in_hdr = 1;
593 }
594 }
595 if (aac_state_struct->audio_object_type == AOT_ER_AAC_ELD ||
596 aac_state_struct->audio_object_type == AOT_ER_AAC_LD ||
597 aac_state_struct->audio_object_type == AOT_ER_AAC_LC ||
598 aac_state_struct->audio_object_type == AOT_ER_AAC_SCAL) {
599 aac_state_struct->eld_specific_config.aac_sect_data_resil_flag = 0;
600 aac_state_struct->eld_specific_config.aac_sf_data_resil_flag = 0;
601 aac_state_struct->eld_specific_config.aac_spect_data_resil_flag = 0;
602 aac_state_struct->eld_specific_config.ep_config = 0;
603 if ((aac_state_struct->extension_flag == 1) ||
604 aac_state_struct->audio_object_type == AOT_ER_AAC_ELD) {
605 if (aac_state_struct->audio_object_type >= ER_OBJECT_START) {
606 aac_state_struct->eld_specific_config.aac_sect_data_resil_flag =
607 ixheaacd_read_bits_buf(it_bit_buff, 1);
608 aac_state_struct->eld_specific_config.aac_sf_data_resil_flag =
609 ixheaacd_read_bits_buf(it_bit_buff, 1);
610 aac_state_struct->eld_specific_config.aac_spect_data_resil_flag =
611 ixheaacd_read_bits_buf(it_bit_buff, 1);
612 if (aac_state_struct->audio_object_type == AOT_ER_AAC_LD)
613 aac_state_struct->eld_specific_config.ep_config =
614 ixheaacd_read_bits_buf(it_bit_buff, 2);
615 if (aac_state_struct->audio_object_type == AOT_ER_AAC_ELD)
616 aac_state_struct->eld_specific_config.ld_sbr_flag_present =
617 ixheaacd_read_bits_buf(it_bit_buff, 1);
618 }
619 }
620 }
621 }
622 if (pstr_audio_specific_config->audio_object_type == AOT_USAC) {
623 {
624 pstr_audio_specific_config->sbr_present_flag = 0;
625 pstr_audio_specific_config->ext_audio_object_type = 0;
626 }
627
628 {
629 {
630 SIZE_T tmp = 0xf;
631 UWORD32 i;
632 WORD32 err = 0;
633
634 aac_state_struct->usac_flag = 1;
635
636 ixheaacd_conf_default(&(pstr_audio_specific_config->str_usac_config));
637 err = ixheaacd_config(it_bit_buff, &(pstr_audio_specific_config->str_usac_config),
638 &(pstr_audio_specific_config->channel_configuration),
639 aac_state_struct->ec_enable);
640 if (err != 0) return err;
641
642 pstr_audio_specific_config->sampling_frequency =
643 pstr_audio_specific_config->str_usac_config.usac_sampling_frequency;
644
645 if (pstr_audio_specific_config->audio_object_type == AOT_USAC) {
646 pstr_audio_specific_config->sbr_present_flag = 1;
647 pstr_audio_specific_config->ext_audio_object_type = AOT_SBR;
648 pstr_audio_specific_config->ext_sampling_frequency =
649 pstr_audio_specific_config->sampling_frequency;
650 pstr_audio_specific_config->ext_samp_frequency_index =
651 pstr_audio_specific_config->samp_frequency_index;
652
653 for (i = 0; i < sizeof(ixheaacd_sampl_freq_idx_table) /
654 sizeof(ixheaacd_sampl_freq_idx_table[0]);
655 i++) {
656 if (ixheaacd_sampl_freq_idx_table[i] ==
657 (int)(pstr_audio_specific_config->sampling_frequency)) {
658 tmp = i;
659 break;
660 }
661 }
662 pstr_audio_specific_config->samp_frequency_index = (UINT32)tmp;
663 } else {
664 pstr_audio_specific_config->sbr_present_flag = 0;
665 }
666 }
667 }
668
669 if (aac_state_struct->bs_format != LOAS_BSFORMAT) {
670 ixheaacd_skip_bits_buf(it_bit_buff, it_bit_buff->cnt_bits);
671
672 if ((SIZE_T)it_bit_buff->ptr_read_next ==
673 (SIZE_T)it_bit_buff->ptr_bit_buf_base) {
674 *bytes_consumed = ((WORD32)it_bit_buff->size) >> 3;
675 } else {
676 *bytes_consumed = (WORD32)((((((SIZE_T)it_bit_buff->ptr_read_next -
677 (SIZE_T)it_bit_buff->ptr_bit_buf_base))
678 << 3) +
679 7 - it_bit_buff->bit_pos + 7) >>
680 3);
681 }
682 }
683 return 0;
684 }
685
686 aac_state_struct->frame_length = FRAME_SIZE;
687 if (aac_state_struct->frame_len_flag)
688 aac_state_struct->frame_length = FRAME_SIZE_SMALL;
689
690 if (aac_state_struct->extension_flag)
691 aac_state_struct->extension_flag_3 = ixheaacd_read_bits_buf(it_bit_buff, 1);
692
693 if (aac_state_struct->audio_object_type == AOT_ER_AAC_LD)
694 aac_state_struct->frame_length >>= 1;
695
696 if (aac_state_struct->audio_object_type == AOT_ER_AAC_ELD) {
697 aac_state_struct->frame_length >>= 1;
698 if (aac_state_struct->eld_specific_config.ld_sbr_flag_present) {
699 aac_state_struct->eld_specific_config.ld_sbr_samp_rate =
700 ixheaacd_read_bits_buf(it_bit_buff, 1);
701 aac_state_struct->eld_specific_config.ld_sbr_crc_flag =
702 ixheaacd_read_bits_buf(it_bit_buff, 1);
703
704 ixheaacd_eld_sbr_header(it_bit_buff, aac_state_struct->ch_config,
705 &aac_state_struct->str_sbr_config);
706
707 aac_state_struct->dwnsmp_signal =
708 !aac_state_struct->eld_specific_config.ld_sbr_samp_rate;
709 }
710
711 {
712 UWORD16 len, eld_ext_type;
713 WORD32 err;
714 UWORD16 cnt;
715
716 if (ixheaacd_show_bits_buf(it_bit_buff, 4) != ELDEXT_TERM) {
717 while ((eld_ext_type = ixheaacd_read_bits_buf(it_bit_buff, 4)) !=
718 ELDEXT_TERM) {
719 len = ixheaacd_read_bits_buf(it_bit_buff, 4);
720 if (len == 15) {
721 len += ixheaacd_read_bits_buf(it_bit_buff, 8);
722 }
723 if (len == 15 + 255) {
724 len += ixheaacd_read_bits_buf(it_bit_buff, 16);
725 }
726
727 switch (eld_ext_type) {
728 case ELDEXT_SAOC:
729 break;
730 case ELDEXT_LDSAC:
731 aac_state_struct->ldmps_present = 1;
732 aac_state_struct->mps_dec_handle.ldmps_config.ldmps_present_flag =
733 1;
734 aac_state_struct->mps_dec_handle.object_type =
735 aac_state_struct->audio_object_type;
736 aac_state_struct->mps_dec_handle.ec_flag = aac_state_struct->ec_enable;
737 err = ixheaacd_ld_spatial_specific_config(
738 &(aac_state_struct->mps_dec_handle.ldmps_config), it_bit_buff);
739 if (err) return err;
740
741 if (ixheaacd_mps_create(
742 &aac_state_struct->mps_dec_handle,
743 aac_state_struct->mps_dec_handle.ldmps_config
744 .bs_frame_length,
745 0, &(aac_state_struct->mps_dec_handle.ldmps_config))) {
746 return -1;
747 }
748 break;
749 default:
750 for (cnt = 0; cnt < len; cnt++) {
751 ixheaacd_read_bits_buf(it_bit_buff, 8);
752 }
753
754 break;
755 }
756 break;
757 }
758 }
759 }
760 if (!((aac_state_struct->ldmps_present == 1) &&
761 !(it_bit_buff->cnt_bits >= 1)))
762 ixheaacd_read_bits_buf(it_bit_buff, 1);
763 }
764 if (!((aac_state_struct->ldmps_present == 1) && !(it_bit_buff->cnt_bits > 0))) {
765 if (aac_state_struct->audio_object_type == AOT_ER_AAC_ELD ||
766 aac_state_struct->audio_object_type == AOT_ER_AAC_LC ||
767 aac_state_struct->audio_object_type == AOT_ER_AAC_SCAL) {
768 WORD32 ep_config = ixheaacd_read_bits_buf(it_bit_buff, 2);
769 if (ep_config == 2 || ep_config == 3) {
770 }
771 if (ep_config == 3) {
772 WORD32 direct_map = ixheaacd_read_bits_buf(it_bit_buff, 1);
773 if (!direct_map) {
774 }
775 }
776 }
777
778 tmp = (header_len * 8) - it_bit_buff->cnt_bits;
779
780 if (aac_state_struct->audio_object_type != AOT_SBR &&
781 (it_bit_buff->cnt_bits >= 16)) {
782 tmp = ixheaacd_read_bits_buf(it_bit_buff, 11);
783
784 if (tmp == 0x2b7) {
785 tmp = ixheaacd_read_bits_buf(it_bit_buff, 5);
786
787 if (tmp == AOT_SBR) {
788 WORD32 sbr_present_flag = ixheaacd_read_bits_buf(it_bit_buff, 1);
789 if (sbr_present_flag) {
790 tmp = ixheaacd_get_samp_rate(it_bit_buff, pstr_samp_rate_info,
791 pstr_audio_specific_config);
792 if (tmp == -1) {
793 *bytes_consumed = 1;
794 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
795 } else
796 aac_state_struct->extension_samp_rate = tmp;
797
798 if (it_bit_buff->cnt_bits >= 12) {
799 tmp = ixheaacd_read_bits_buf(it_bit_buff, 11);
800 if (tmp == 0x548) {
801 tmp = ixheaacd_read_bits_buf(it_bit_buff, 1);
802 }
803 }
804 }
805 }
806 } else if (aac_state_struct->bs_format == LOAS_BSFORMAT) {
807 ixheaacd_read_bidirection(it_bit_buff, -11);
808 }
809 }
810 }
811
812 if (aac_state_struct->audio_object_type != AOT_AAC_LC &&
813 aac_state_struct->audio_object_type != AOT_SBR &&
814 aac_state_struct->audio_object_type != AOT_PS &&
815 aac_state_struct->audio_object_type != AOT_ER_AAC_LC &&
816 aac_state_struct->audio_object_type != AOT_ER_AAC_LD &&
817 aac_state_struct->audio_object_type != AOT_ER_AAC_ELD &&
818 aac_state_struct->audio_object_type != AOT_AAC_LTP) {
819 *bytes_consumed = 1;
820 return IA_XHEAAC_DEC_INIT_FATAL_AUDIOOBJECTTYPE_NOT_SUPPORTED;
821 } else {
822 if (aac_state_struct->bs_format == LOAS_BSFORMAT) {
823 *bytes_consumed = (cnt_bits - it_bit_buff->cnt_bits) >> 3;
824 if (it_bit_buff->bit_pos < 7) *bytes_consumed += 1;
825
826 } else
827 *bytes_consumed = header_len;
828
829 return 0;
830 }
831 }
832
ixheaacd_check_if_adts(ia_adts_header_struct * adts,struct ia_bit_buf_struct * it_bit_buff,WORD32 usr_max_ch)833 WORD32 ixheaacd_check_if_adts(ia_adts_header_struct *adts,
834 struct ia_bit_buf_struct *it_bit_buff,
835 WORD32 usr_max_ch) {
836 WORD32 max_frm_len_per_ch, result = 0;
837
838 result = ixheaacd_adtsframe(adts, it_bit_buff);
839
840 max_frm_len_per_ch = ixheaac_mult32(768, (adts->no_raw_data_blocks + 1));
841
842 if (adts->channel_configuration != 0)
843 max_frm_len_per_ch =
844 ixheaac_mult32(max_frm_len_per_ch, adts->channel_configuration);
845 else
846 max_frm_len_per_ch = max_frm_len_per_ch * usr_max_ch;
847
848 return ((result != 0) || (adts->aac_frame_length < 8) || (adts->layer != 0) ||
849 (adts->profile != AAC_LC_PROFILE));
850 }
851
ixheaacd_latm_header_decode(ia_aac_dec_state_struct * aac_state_struct,struct ia_bit_buf_struct * it_bit_buff,WORD32 * bytes_consumed,ia_sampling_rate_info_struct * pstr_samp_rate_info)852 IA_ERRORCODE ixheaacd_latm_header_decode(
853 ia_aac_dec_state_struct *aac_state_struct,
854 struct ia_bit_buf_struct *it_bit_buff, WORD32 *bytes_consumed,
855 ia_sampling_rate_info_struct *pstr_samp_rate_info) {
856 WORD32 sync;
857 IA_ERRORCODE result;
858 WORD32 next_sync, audio_mux_len_bytes_last;
859 WORD32 audio_mux_len_bits_last;
860 WORD32 sync_status = aac_state_struct->sync_status;
861 WORD32 bit_count = aac_state_struct->bit_count;
862 WORD32 cnt_bits = it_bit_buff->cnt_bits;
863
864 *bytes_consumed = 0;
865
866 aac_state_struct->bs_format = LOAS_BSFORMAT;
867
868 if (sync_status == 0) {
869 do {
870 sync = ixheaacd_read_bits_buf(it_bit_buff, 11);
871 bit_count += 11;
872 while (sync != 0x2B7) {
873 sync = ((sync & 0x3ff) << 1) | ixheaacd_read_bits_buf(it_bit_buff, 1);
874 bit_count += 1;
875 if (it_bit_buff->cnt_bits < 13) {
876 ixheaacd_read_bidirection(it_bit_buff, -11);
877 *bytes_consumed = (cnt_bits - it_bit_buff->cnt_bits) / 8;
878 return (IA_XHEAAC_DEC_INIT_NONFATAL_HEADER_NOT_AT_START);
879 }
880 }
881
882 audio_mux_len_bytes_last = ixheaacd_read_bits_buf(it_bit_buff, 13);
883 bit_count += 13;
884 audio_mux_len_bits_last = audio_mux_len_bytes_last << 3;
885 if (it_bit_buff->cnt_bits >= (audio_mux_len_bits_last + 11)) {
886 ixheaacd_read_bidirection(it_bit_buff, audio_mux_len_bits_last);
887 bit_count += audio_mux_len_bits_last;
888
889 next_sync = ixheaacd_read_bits_buf(it_bit_buff, 11);
890 bit_count += 11;
891
892 if (next_sync == 0x2B7) {
893 ixheaacd_read_bidirection(it_bit_buff,
894 -(11 + audio_mux_len_bits_last + 13 + 11));
895 bit_count -= 11 + audio_mux_len_bits_last + 13 + 11;
896 break;
897 } else {
898 ixheaacd_read_bidirection(it_bit_buff,
899 -(audio_mux_len_bits_last + 24 + 11 - 1));
900 bit_count -= audio_mux_len_bits_last + 24 + 11 - 1;
901 }
902
903 } else {
904 if (it_bit_buff->cnt_bits != audio_mux_len_bits_last) {
905 ixheaacd_read_bidirection(it_bit_buff, -(13 + 11));
906 bit_count -= (13 + 11);
907 *bytes_consumed = (cnt_bits - it_bit_buff->cnt_bits) / 8;
908 return IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES;
909 } else {
910 ixheaacd_read_bidirection(it_bit_buff, -(13 + 11));
911 bit_count -= (13 + 11);
912 break;
913 }
914 }
915 } while (1);
916
917 do {
918 WORD32 audio_mux_len_bytes_last;
919 WORD32 use_same_stream_mux;
920
921 sync = ixheaacd_read_bits_buf(it_bit_buff, 11);
922 bit_count += 11;
923
924 if (sync != 0x2b7) {
925 ixheaacd_read_bidirection(it_bit_buff, -25);
926 bit_count -= 11;
927 *bytes_consumed = (cnt_bits - it_bit_buff->cnt_bits) / 8;
928 return IA_XHEAAC_DEC_INIT_NONFATAL_HEADER_NOT_AT_START;
929 }
930
931 audio_mux_len_bytes_last = ixheaacd_read_bits_buf(it_bit_buff, 13);
932 bit_count += 13;
933
934 use_same_stream_mux = ixheaacd_read_bits_buf(it_bit_buff, 1);
935 bit_count += 1;
936
937 if (!use_same_stream_mux) {
938 ixheaacd_read_bidirection(it_bit_buff, -25);
939 bit_count -= 25;
940 sync_status = 1;
941 aac_state_struct->sync_status = sync_status;
942 break;
943 } else {
944 ixheaacd_read_bidirection(it_bit_buff, -25);
945 bit_count -= 25;
946 aac_state_struct->bit_count = bit_count;
947 *bytes_consumed = 1;
948 return IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES;
949 }
950
951
952 ixheaacd_read_bidirection(it_bit_buff, audio_mux_len_bytes_last * 8 - 1);
953 bit_count += audio_mux_len_bytes_last * 8 - 1;
954
955 } while (sync_status == 0);
956
957 *bytes_consumed = (cnt_bits - it_bit_buff->cnt_bits) / 8;
958 {
959 ixheaacd_latm_struct latm_struct_element;
960 WORD32 sync;
961 memset(&latm_struct_element, 0, sizeof(ixheaacd_latm_struct));
962
963 sync = ixheaacd_read_bits_buf(it_bit_buff, 11);
964 if (sync == 0x2b7) {
965 result = ixheaacd_latm_audio_mux_element(
966 it_bit_buff, &latm_struct_element, aac_state_struct,
967 pstr_samp_rate_info);
968 if (result != 0) {
969 sync_status = 0;
970 aac_state_struct->sync_status = sync_status;
971
972 *bytes_consumed += 1;
973 return result;
974 }
975 }
976 }
977 }
978 return IA_NO_ERROR;
979 }
980
ixheaacd_aac_headerdecode(ia_exhaacplus_dec_api_struct * p_obj_exhaacplus_dec,UWORD8 * buffer,WORD32 * bytes_consumed,const ia_aac_dec_huffman_tables_struct * pstr_huffmann_tables)981 WORD32 ixheaacd_aac_headerdecode(
982 ia_exhaacplus_dec_api_struct *p_obj_exhaacplus_dec, UWORD8 *buffer,
983 WORD32 *bytes_consumed,
984 const ia_aac_dec_huffman_tables_struct *pstr_huffmann_tables) {
985 struct ia_bit_buf_struct it_bit_buff = {0}, *handle_bit_buff;
986 ia_adif_header_struct adif = {0};
987 ia_adts_header_struct adts = {0};
988 WORD32 result;
989 WORD32 header_len;
990 WORD32 sync = 0;
991
992 WORD32 disable_sync = p_obj_exhaacplus_dec->aac_config.ui_disable_sync;
993 WORD32 is_ga_header = p_obj_exhaacplus_dec->aac_config.ui_mp4_flag;
994
995 WORD32 loas_present = p_obj_exhaacplus_dec->aac_config.loas_present;
996
997 ia_aac_dec_state_struct *aac_state_struct =
998 p_obj_exhaacplus_dec->pp_mem_aac[IA_ENHAACPLUS_DEC_PERSIST_IDX];
999 WORD32 usr_max_ch = aac_state_struct->p_config->ui_max_channels;
1000
1001 ia_sampling_rate_info_struct *pstr_samp_rate_info =
1002 (ia_sampling_rate_info_struct *)&pstr_huffmann_tables
1003 ->str_sample_rate_info[0];
1004
1005 if (buffer == 0) {
1006 return IA_XHEAAC_DEC_INIT_FATAL_DEC_INIT_FAIL;
1007 }
1008
1009 header_len = aac_state_struct->ui_in_bytes;
1010
1011 handle_bit_buff = ixheaacd_create_bit_buf(&it_bit_buff, (UWORD8 *)buffer,
1012 (WORD16)header_len);
1013 handle_bit_buff->cnt_bits += (header_len << 3);
1014 handle_bit_buff->xaac_jmp_buf = &aac_state_struct->xaac_jmp_buf;
1015
1016 if (is_ga_header == 1) {
1017 return ixheaacd_ga_hdr_dec(aac_state_struct, header_len, bytes_consumed,
1018 pstr_samp_rate_info, handle_bit_buff);
1019 } else if (loas_present) {
1020 return ixheaacd_latm_header_decode(aac_state_struct, &it_bit_buff,
1021 bytes_consumed, pstr_samp_rate_info);
1022 }
1023
1024 else {
1025 WORD32 header_found = 0;
1026 WORD32 bytes_taken = -1;
1027 WORD32 prev_offset = 0;
1028 WORD32 run_once = 1;
1029 if (disable_sync == 0) run_once = 0;
1030
1031 do {
1032 bytes_taken++;
1033 buffer += (bytes_taken - prev_offset);
1034
1035 prev_offset = bytes_taken;
1036
1037 handle_bit_buff = ixheaacd_create_bit_buf(
1038 &it_bit_buff, (UWORD8 *)buffer, (WORD16)(header_len - bytes_taken));
1039 handle_bit_buff->cnt_bits += (8 * (header_len - bytes_taken));
1040
1041 handle_bit_buff->pstr_adts_crc_info = &handle_bit_buff->str_adts_crc_info;
1042 ixheaacd_adts_crc_open(handle_bit_buff->pstr_adts_crc_info);
1043
1044 aac_state_struct->ldmps_present = 0;
1045 aac_state_struct->latm_initialized = 0;
1046 memset(&aac_state_struct->mps_dec_handle, 0,
1047 sizeof(aac_state_struct->mps_dec_handle));
1048 memset(&aac_state_struct->eld_specific_config, 0,
1049 sizeof(aac_state_struct->eld_specific_config));
1050
1051 if ((buffer[0] == 'A') && (buffer[1] == 'D') && (buffer[2] == 'I') &&
1052 (buffer[3] == 'F')) {
1053 adif.prog_config_present = 0;
1054 result = ixheaacd_get_adif_header(&adif, handle_bit_buff);
1055 if (result == 0) {
1056 if (adif.prog_config_present == 1) {
1057 aac_state_struct->p_config->ui_pce_found_in_hdr = 1;
1058 aac_state_struct->p_config->str_prog_config = adif.str_prog_config;
1059 }
1060 aac_state_struct->s_adif_hdr_present = 1;
1061 aac_state_struct->audio_object_type =
1062 adif.str_prog_config.object_type;
1063 aac_state_struct->sampling_rate =
1064 pstr_samp_rate_info[adif.str_prog_config.samp_freq_index]
1065 .sampling_frequency;
1066 aac_state_struct->ch_config = adif.str_prog_config.channels;
1067 bytes_taken +=
1068 ((handle_bit_buff->size - handle_bit_buff->cnt_bits) >> 3);
1069
1070 header_found = 1;
1071 aac_state_struct->frame_length = FRAME_SIZE;
1072 if (aac_state_struct->audio_object_type == AOT_ER_AAC_LD)
1073 aac_state_struct->frame_length >>= 1;
1074 }
1075 }
1076
1077 else if ((sync = ixheaacd_read_bits_buf(&it_bit_buff, 12)) == 0xfff) {
1078 result = ixheaacd_check_if_adts(&adts, handle_bit_buff, usr_max_ch);
1079 if (result != 0) {
1080 continue;
1081 }
1082
1083 if ((adts.aac_frame_length + ADTS_HEADER_LENGTH) <
1084 (header_len - bytes_taken)) {
1085 ia_adts_header_struct adts_loc = {0};
1086
1087 ixheaacd_create_init_bit_buf(
1088 &it_bit_buff, (UWORD8 *)(buffer + adts.aac_frame_length),
1089 (WORD16)(header_len - bytes_taken - adts.aac_frame_length));
1090
1091 handle_bit_buff = &it_bit_buff;
1092
1093 adts_loc.sync_word =
1094 (WORD16)ixheaacd_read_bits_buf(handle_bit_buff, 12);
1095
1096 if (adts_loc.sync_word != 0xFFF) {
1097 continue;
1098 }
1099
1100 result =
1101 ixheaacd_check_if_adts(&adts_loc, handle_bit_buff, usr_max_ch);
1102 if ((result != 0) ||
1103 (adts.samp_freq_index != adts_loc.samp_freq_index) ||
1104 (adts.channel_configuration != adts_loc.channel_configuration)) {
1105 continue;
1106 }
1107 }
1108
1109 {
1110 WORD32 obj_type;
1111 obj_type = adts.profile;
1112
1113 aac_state_struct->audio_object_type = obj_type;
1114 aac_state_struct->sampling_rate =
1115 ((pstr_samp_rate_info[adts.samp_freq_index].sampling_frequency));
1116 aac_state_struct->ch_config = adts.channel_configuration;
1117 aac_state_struct->s_adts_hdr_present = 1;
1118 header_found = 1;
1119 aac_state_struct->bs_format = ADTS_BSFORMAT;
1120 aac_state_struct->frame_length = FRAME_SIZE;
1121 if (aac_state_struct->audio_object_type == AOT_ER_AAC_LD)
1122 aac_state_struct->frame_length >>= 1;
1123 }
1124 } else if (0x2b7 == (sync >> 1)) {
1125 ixheaacd_read_bidirection(&it_bit_buff, -12);
1126 result =
1127 ixheaacd_latm_header_decode(aac_state_struct, &it_bit_buff,
1128 bytes_consumed, pstr_samp_rate_info);
1129 if (result != 0) {
1130 if ((result == (WORD32)IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES) ||
1131 (result < 0)) {
1132 bytes_taken += *bytes_consumed;
1133 *bytes_consumed = bytes_taken;
1134 return result;
1135 } else
1136 bytes_taken += *bytes_consumed - 1;
1137 continue;
1138 }
1139 header_found = 1;
1140 aac_state_struct->bs_format = LOAS_BSFORMAT;
1141 bytes_taken += *bytes_consumed;
1142 }
1143
1144 } while ((header_found == 0 && ((bytes_taken + 1) < (header_len - 68))) &&
1145 run_once != 1);
1146
1147 if (header_found == 0 && disable_sync == 1) {
1148 WORD32 err_code;
1149 ixheaacd_read_bidirection(&it_bit_buff, -12);
1150 err_code =
1151 ixheaacd_ga_hdr_dec(aac_state_struct, header_len, bytes_consumed,
1152 pstr_samp_rate_info, handle_bit_buff);
1153
1154 if (err_code == 0) p_obj_exhaacplus_dec->aac_config.ui_mp4_flag = 1;
1155 return err_code;
1156 }
1157
1158 switch (aac_state_struct->audio_object_type) {
1159 case AOT_AAC_MAIN:
1160 case AOT_AAC_LC:
1161 case AOT_AAC_SSR:
1162 case AOT_AAC_LTP:
1163 case AOT_AAC_SCAL:
1164 case AOT_TWIN_VQ:
1165 case AOT_ER_AAC_LD:
1166 case AOT_ER_AAC_ELD:
1167 case AOT_ER_AAC_LC:
1168 case AOT_USAC:
1169 break;
1170 default:
1171 return IA_XHEAAC_DEC_INIT_FATAL_AUDIOOBJECTTYPE_NOT_SUPPORTED;
1172 }
1173
1174 if (aac_state_struct->audio_object_type != AOT_USAC)
1175 aac_state_struct->usac_flag = 0;
1176 *bytes_consumed = bytes_taken;
1177
1178 if ((handle_bit_buff->cnt_bits < 0) &&
1179 (handle_bit_buff->size <
1180 (usr_max_ch * (IA_ENHAACPLUS_DEC_INP_BUF_SIZE << 3)))) {
1181 return (WORD16)(
1182 (WORD32)IA_XHEAAC_DEC_EXE_NONFATAL_INSUFFICIENT_INPUT_BYTES);
1183 }
1184
1185 if (header_found == 0) {
1186 *bytes_consumed = bytes_taken + 1;
1187 return IA_XHEAAC_DEC_INIT_NONFATAL_HEADER_NOT_AT_START;
1188 } else {
1189 return 0;
1190 }
1191 }
1192 }
1193