?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vo_glamo: sub.h was moved to sub directory in c9026cb3210205b07e2e068467a18ee40f9259a3
[mplayer/glamo.git] / libfaad2 / syntax.c
blobeeaa12c8bbfe91be9801fce26588866c0d650884
1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 **
19 ** Any non-GPL usage of this software or parts of this software is strictly
20 ** forbidden.
21 **
22 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
24 **
25 ** $Id: syntax.c,v 1.82 2004/09/04 14:56:29 menno Exp $
26 **/
27
28 /*
29 Reads the AAC bitstream as defined in 14496-3 (MPEG-4 Audio)
30 */
31
32 #include "common.h"
33 #include "structs.h"
34
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include "decoder.h"
39 #include "syntax.h"
40 #include "specrec.h"
41 #include "huffman.h"
42 #include "bits.h"
43 #include "pulse.h"
44 #include "analysis.h"
45 #include "drc.h"
46 #ifdef ERROR_RESILIENCE
47 #include "rvlc.h"
48 #endif
49 #ifdef SBR_DEC
50 #include "sbr_syntax.h"
51 #endif
52 #include "mp4.h"
53
54
55 /* static function declarations */
56 static void decode_sce_lfe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
57 uint8_t id_syn_ele);
58 static void decode_cpe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
59 uint8_t id_syn_ele);
60 static uint8_t single_lfe_channel_element(NeAACDecHandle hDecoder, bitfile *ld,
61 uint8_t channel, uint8_t *tag);
62 static uint8_t channel_pair_element(NeAACDecHandle hDecoder, bitfile *ld,
63 uint8_t channel, uint8_t *tag);
64 #ifdef COUPLING_DEC
65 static uint8_t coupling_channel_element(NeAACDecHandle hDecoder, bitfile *ld);
66 #endif
67 static uint16_t data_stream_element(NeAACDecHandle hDecoder, bitfile *ld);
68 static uint8_t program_config_element(program_config *pce, bitfile *ld);
69 static uint8_t fill_element(NeAACDecHandle hDecoder, bitfile *ld, drc_info *drc
70 #ifdef SBR_DEC
71 ,uint8_t sbr_ele
72 #endif
73 );
74 static uint8_t individual_channel_stream(NeAACDecHandle hDecoder, element *ele,
75 bitfile *ld, ic_stream *ics, uint8_t scal_flag,
76 int16_t *spec_data);
77 static uint8_t ics_info(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
78 uint8_t common_window);
79 static uint8_t section_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld);
80 static uint8_t scale_factor_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld);
81 #ifdef SSR_DEC
82 static void gain_control_data(bitfile *ld, ic_stream *ics);
83 #endif
84 static uint8_t spectral_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
85 int16_t *spectral_data);
86 static uint16_t extension_payload(bitfile *ld, drc_info *drc, uint16_t count);
87 static uint8_t pulse_data(ic_stream *ics, pulse_info *pul, bitfile *ld);
88 static void tns_data(ic_stream *ics, tns_info *tns, bitfile *ld);
89 #ifdef LTP_DEC
90 static uint8_t ltp_data(NeAACDecHandle hDecoder, ic_stream *ics, ltp_info *ltp, bitfile *ld);
91 #endif
92 static uint8_t adts_fixed_header(adts_header *adts, bitfile *ld);
93 static void adts_variable_header(adts_header *adts, bitfile *ld);
94 static void adts_error_check(adts_header *adts, bitfile *ld);
95 static uint8_t dynamic_range_info(bitfile *ld, drc_info *drc);
96 static uint8_t excluded_channels(bitfile *ld, drc_info *drc);
97 #ifdef SCALABLE_DEC
98 static int8_t aac_scalable_main_header(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
99 bitfile *ld, uint8_t this_layer_stereo);
100 #endif
101
102
103 /* Table 4.4.1 */
104 int8_t GASpecificConfig(bitfile *ld, mp4AudioSpecificConfig *mp4ASC,
105 program_config *pce_out)
106 {
107 program_config pce;
108
109 /* 1024 or 960 */
110 mp4ASC->frameLengthFlag = faad_get1bit(ld
111 DEBUGVAR(1,138,"GASpecificConfig(): FrameLengthFlag"));
112 #ifndef ALLOW_SMALL_FRAMELENGTH
113 if (mp4ASC->frameLengthFlag == 1)
114 return -3;
115 #endif
116
117 mp4ASC->dependsOnCoreCoder = faad_get1bit(ld
118 DEBUGVAR(1,139,"GASpecificConfig(): DependsOnCoreCoder"));
119 if (mp4ASC->dependsOnCoreCoder == 1)
120 {
121 mp4ASC->coreCoderDelay = (uint16_t)faad_getbits(ld, 14
122 DEBUGVAR(1,140,"GASpecificConfig(): CoreCoderDelay"));
123 }
124
125 mp4ASC->extensionFlag = faad_get1bit(ld DEBUGVAR(1,141,"GASpecificConfig(): ExtensionFlag"));
126 if (mp4ASC->channelsConfiguration == 0)
127 {
128 if (program_config_element(&pce, ld))
129 return -3;
130 //mp4ASC->channelsConfiguration = pce.channels;
131
132 if (pce_out != NULL)
133 memcpy(pce_out, &pce, sizeof(program_config));
134
135 /*
136 if (pce.num_valid_cc_elements)
137 return -3;
138 */
139 }
140
141 #ifdef ERROR_RESILIENCE
142 if (mp4ASC->extensionFlag == 1)
143 {
144 /* Error resilience not supported yet */
145 if (mp4ASC->objectTypeIndex >= ER_OBJECT_START)
146 {
147 mp4ASC->aacSectionDataResilienceFlag = faad_get1bit(ld
148 DEBUGVAR(1,144,"GASpecificConfig(): aacSectionDataResilienceFlag"));
149 mp4ASC->aacScalefactorDataResilienceFlag = faad_get1bit(ld
150 DEBUGVAR(1,145,"GASpecificConfig(): aacScalefactorDataResilienceFlag"));
151 mp4ASC->aacSpectralDataResilienceFlag = faad_get1bit(ld
152 DEBUGVAR(1,146,"GASpecificConfig(): aacSpectralDataResilienceFlag"));
153 }
154 /* 1 bit: extensionFlag3 */
155 faad_getbits(ld, 1);
156 }
157 #endif
158
159 return 0;
160 }
161
162 /* Table 4.4.2 */
163 /* An MPEG-4 Audio decoder is only required to follow the Program
164 Configuration Element in GASpecificConfig(). The decoder shall ignore
165 any Program Configuration Elements that may occur in raw data blocks.
166 PCEs transmitted in raw data blocks cannot be used to convey decoder
167 configuration information.
168 */
169 static uint8_t program_config_element(program_config *pce, bitfile *ld)
170 {
171 uint8_t i;
172
173 memset(pce, 0, sizeof(program_config));
174
175 pce->channels = 0;
176
177 pce->element_instance_tag = (uint8_t)faad_getbits(ld, 4
178 DEBUGVAR(1,10,"program_config_element(): element_instance_tag"));
179
180 pce->object_type = (uint8_t)faad_getbits(ld, 2
181 DEBUGVAR(1,11,"program_config_element(): object_type"));
182 pce->sf_index = (uint8_t)faad_getbits(ld, 4
183 DEBUGVAR(1,12,"program_config_element(): sf_index"));
184 pce->num_front_channel_elements = (uint8_t)faad_getbits(ld, 4
185 DEBUGVAR(1,13,"program_config_element(): num_front_channel_elements"));
186 pce->num_side_channel_elements = (uint8_t)faad_getbits(ld, 4
187 DEBUGVAR(1,14,"program_config_element(): num_side_channel_elements"));
188 pce->num_back_channel_elements = (uint8_t)faad_getbits(ld, 4
189 DEBUGVAR(1,15,"program_config_element(): num_back_channel_elements"));
190 pce->num_lfe_channel_elements = (uint8_t)faad_getbits(ld, 2
191 DEBUGVAR(1,16,"program_config_element(): num_lfe_channel_elements"));
192 pce->num_assoc_data_elements = (uint8_t)faad_getbits(ld, 3
193 DEBUGVAR(1,17,"program_config_element(): num_assoc_data_elements"));
194 pce->num_valid_cc_elements = (uint8_t)faad_getbits(ld, 4
195 DEBUGVAR(1,18,"program_config_element(): num_valid_cc_elements"));
196
197 pce->mono_mixdown_present = faad_get1bit(ld
198 DEBUGVAR(1,19,"program_config_element(): mono_mixdown_present"));
199 if (pce->mono_mixdown_present == 1)
200 {
201 pce->mono_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
202 DEBUGVAR(1,20,"program_config_element(): mono_mixdown_element_number"));
203 }
204
205 pce->stereo_mixdown_present = faad_get1bit(ld
206 DEBUGVAR(1,21,"program_config_element(): stereo_mixdown_present"));
207 if (pce->stereo_mixdown_present == 1)
208 {
209 pce->stereo_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
210 DEBUGVAR(1,22,"program_config_element(): stereo_mixdown_element_number"));
211 }
212
213 pce->matrix_mixdown_idx_present = faad_get1bit(ld
214 DEBUGVAR(1,23,"program_config_element(): matrix_mixdown_idx_present"));
215 if (pce->matrix_mixdown_idx_present == 1)
216 {
217 pce->matrix_mixdown_idx = (uint8_t)faad_getbits(ld, 2
218 DEBUGVAR(1,24,"program_config_element(): matrix_mixdown_idx"));
219 pce->pseudo_surround_enable = faad_get1bit(ld
220 DEBUGVAR(1,25,"program_config_element(): pseudo_surround_enable"));
221 }
222
223 for (i = 0; i < pce->num_front_channel_elements; i++)
224 {
225 pce->front_element_is_cpe[i] = faad_get1bit(ld
226 DEBUGVAR(1,26,"program_config_element(): front_element_is_cpe"));
227 pce->front_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
228 DEBUGVAR(1,27,"program_config_element(): front_element_tag_select"));
229
230 if (pce->front_element_is_cpe[i] & 1)
231 {
232 pce->cpe_channel[pce->front_element_tag_select[i]] = pce->channels;
233 pce->num_front_channels += 2;
234 pce->channels += 2;
235 } else {
236 pce->sce_channel[pce->front_element_tag_select[i]] = pce->channels;
237 pce->num_front_channels++;
238 pce->channels++;
239 }
240 }
241
242 for (i = 0; i < pce->num_side_channel_elements; i++)
243 {
244 pce->side_element_is_cpe[i] = faad_get1bit(ld
245 DEBUGVAR(1,28,"program_config_element(): side_element_is_cpe"));
246 pce->side_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
247 DEBUGVAR(1,29,"program_config_element(): side_element_tag_select"));
248
249 if (pce->side_element_is_cpe[i] & 1)
250 {
251 pce->cpe_channel[pce->side_element_tag_select[i]] = pce->channels;
252 pce->num_side_channels += 2;
253 pce->channels += 2;
254 } else {
255 pce->sce_channel[pce->side_element_tag_select[i]] = pce->channels;
256 pce->num_side_channels++;
257 pce->channels++;
258 }
259 }
260
261 for (i = 0; i < pce->num_back_channel_elements; i++)
262 {
263 pce->back_element_is_cpe[i] = faad_get1bit(ld
264 DEBUGVAR(1,30,"program_config_element(): back_element_is_cpe"));
265 pce->back_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
266 DEBUGVAR(1,31,"program_config_element(): back_element_tag_select"));
267
268 if (pce->back_element_is_cpe[i] & 1)
269 {
270 pce->cpe_channel[pce->back_element_tag_select[i]] = pce->channels;
271 pce->channels += 2;
272 pce->num_back_channels += 2;
273 } else {
274 pce->sce_channel[pce->back_element_tag_select[i]] = pce->channels;
275 pce->num_back_channels++;
276 pce->channels++;
277 }
278 }
279
280 for (i = 0; i < pce->num_lfe_channel_elements; i++)
281 {
282 pce->lfe_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
283 DEBUGVAR(1,32,"program_config_element(): lfe_element_tag_select"));
284
285 pce->sce_channel[pce->lfe_element_tag_select[i]] = pce->channels;
286 pce->num_lfe_channels++;
287 pce->channels++;
288 }
289
290 for (i = 0; i < pce->num_assoc_data_elements; i++)
291 pce->assoc_data_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
292 DEBUGVAR(1,33,"program_config_element(): assoc_data_element_tag_select"));
293
294 for (i = 0; i < pce->num_valid_cc_elements; i++)
295 {
296 pce->cc_element_is_ind_sw[i] = faad_get1bit(ld
297 DEBUGVAR(1,34,"program_config_element(): cc_element_is_ind_sw"));
298 pce->valid_cc_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
299 DEBUGVAR(1,35,"program_config_element(): valid_cc_element_tag_select"));
300 }
301
302 faad_byte_align(ld);
303
304 pce->comment_field_bytes = (uint8_t)faad_getbits(ld, 8
305 DEBUGVAR(1,36,"program_config_element(): comment_field_bytes"));
306
307 for (i = 0; i < pce->comment_field_bytes; i++)
308 {
309 pce->comment_field_data[i] = (uint8_t)faad_getbits(ld, 8
310 DEBUGVAR(1,37,"program_config_element(): comment_field_data"));
311 }
312 pce->comment_field_data[i] = 0;
313
314 if (pce->channels > MAX_CHANNELS)
315 return 22;
316
317 return 0;
318 }
319
320 static void decode_sce_lfe(NeAACDecHandle hDecoder,
321 NeAACDecFrameInfo *hInfo, bitfile *ld,
322 uint8_t id_syn_ele)
323 {
324 uint8_t channels = hDecoder->fr_channels;
325 uint8_t tag = 0;
326
327 if (channels+1 > MAX_CHANNELS)
328 {
329 hInfo->error = 12;
330 return;
331 }
332 if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
333 {
334 hInfo->error = 13;
335 return;
336 }
337
338 /* for SCE hDecoder->element_output_channels[] is not set here because this
339 can become 2 when some form of Parametric Stereo coding is used
340 */
341
342 /* save the syntax element id */
343 hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele;
344
345 /* decode the element */
346 hInfo->error = single_lfe_channel_element(hDecoder, ld, channels, &tag);
347
348 /* map output channels position to internal data channels */
349 if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2)
350 {
351 /* this might be faulty when pce_set is true */
352 hDecoder->internal_channel[channels] = channels;
353 hDecoder->internal_channel[channels+1] = channels+1;
354 } else {
355 if (hDecoder->pce_set)
356 hDecoder->internal_channel[hDecoder->pce.sce_channel[tag]] = channels;
357 else
358 hDecoder->internal_channel[channels] = channels;
359 }
360
361 hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele];
362 hDecoder->fr_ch_ele++;
363 }
364
365 static void decode_cpe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
366 uint8_t id_syn_ele)
367 {
368 uint8_t channels = hDecoder->fr_channels;
369 uint8_t tag = 0;
370
371 if (channels+2 > MAX_CHANNELS)
372 {
373 hInfo->error = 12;
374 return;
375 }
376 if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
377 {
378 hInfo->error = 13;
379 return;
380 }
381
382 /* for CPE the number of output channels is always 2 */
383 if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
384 {
385 /* element_output_channels not set yet */
386 hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2;
387 } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != 2) {
388 /* element inconsistency */
389 hInfo->error = 21;
390 return;
391 }
392
393 /* save the syntax element id */
394 hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele;
395
396 /* decode the element */
397 hInfo->error = channel_pair_element(hDecoder, ld, channels, &tag);
398
399 /* map output channel position to internal data channels */
400 if (hDecoder->pce_set)
401 {
402 hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]] = channels;
403 hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]+1] = channels+1;
404 } else {
405 hDecoder->internal_channel[channels] = channels;
406 hDecoder->internal_channel[channels+1] = channels+1;
407 }
408
409 hDecoder->fr_channels += 2;
410 hDecoder->fr_ch_ele++;
411 }
412
413 void raw_data_block(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
414 bitfile *ld, program_config *pce, drc_info *drc)
415 {
416 uint8_t id_syn_ele;
417
418 hDecoder->fr_channels = 0;
419 hDecoder->fr_ch_ele = 0;
420 hDecoder->first_syn_ele = 25;
421 hDecoder->has_lfe = 0;
422
423 #ifdef ERROR_RESILIENCE
424 if (hDecoder->object_type < ER_OBJECT_START)
425 {
426 #endif
427 /* Table 4.4.3: raw_data_block() */
428 while ((id_syn_ele = (uint8_t)faad_getbits(ld, LEN_SE_ID
429 DEBUGVAR(1,4,"NeAACDecDecode(): id_syn_ele"))) != ID_END)
430 {
431 switch (id_syn_ele) {
432 case ID_SCE:
433 if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
434 decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele);
435 if (hInfo->error > 0)
436 return;
437 break;
438 case ID_CPE:
439 if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
440 decode_cpe(hDecoder, hInfo, ld, id_syn_ele);
441 if (hInfo->error > 0)
442 return;
443 break;
444 case ID_LFE:
445 hDecoder->has_lfe++;
446 decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele);
447 if (hInfo->error > 0)
448 return;
449 break;
450 case ID_CCE: /* not implemented yet, but skip the bits */
451 #ifdef COUPLING_DEC
452 hInfo->error = coupling_channel_element(hDecoder, ld);
453 #else
454 hInfo->error = 6;
455 #endif
456 if (hInfo->error > 0)
457 return;
458 break;
459 case ID_DSE:
460 data_stream_element(hDecoder, ld);
461 break;
462 case ID_PCE:
463 /* 14496-4: 5.6.4.1.2.1.3: */
464 /* program_configuration_element()'s in access units shall be ignored */
465 program_config_element(pce, ld);
466 //if ((hInfo->error = program_config_element(pce, ld)) > 0)
467 // return;
468 //hDecoder->pce_set = 1;
469 break;
470 case ID_FIL:
471 /* one sbr_info describes a channel_element not a channel! */
472 /* if we encounter SBR data here: error */
473 /* SBR data will be read directly in the SCE/LFE/CPE element */
474 if ((hInfo->error = fill_element(hDecoder, ld, drc
475 #ifdef SBR_DEC
476 , INVALID_SBR_ELEMENT
477 #endif
478 )) > 0)
479 return;
480 break;
481 }
482 }
483 #ifdef ERROR_RESILIENCE
484 } else {
485 /* Table 262: er_raw_data_block() */
486 switch (hDecoder->channelConfiguration)
487 {
488 case 1:
489 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
490 if (hInfo->error > 0)
491 return;
492 break;
493 case 2:
494 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
495 if (hInfo->error > 0)
496 return;
497 break;
498 case 3:
499 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
500 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
501 if (hInfo->error > 0)
502 return;
503 break;
504 case 4:
505 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
506 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
507 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
508 if (hInfo->error > 0)
509 return;
510 break;
511 case 5:
512 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
513 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
514 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
515 if (hInfo->error > 0)
516 return;
517 break;
518 case 6:
519 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
520 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
521 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
522 decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE);
523 if (hInfo->error > 0)
524 return;
525 break;
526 case 7: /* 8 channels */
527 decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
528 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
529 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
530 decode_cpe(hDecoder, hInfo, ld, ID_CPE);
531 decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE);
532 if (hInfo->error > 0)
533 return;
534 break;
535 default:
536 hInfo->error = 7;
537 return;
538 }
539 #if 0
540 cnt = bits_to_decode() / 8;
541 while (cnt >= 1)
542 {
543 cnt -= extension_payload(cnt);
544 }
545 #endif
546 }
547 #endif
548
549 /* new in corrigendum 14496-3:2002 */
550 #ifdef DRM
551 if (hDecoder->object_type != DRM_ER_LC && !hDecoder->latm_header_present)
552 #endif
553 {
554 faad_byte_align(ld);
555 }
556
557 return;
558 }
559
560 /* Table 4.4.4 and */
561 /* Table 4.4.9 */
562 static uint8_t single_lfe_channel_element(NeAACDecHandle hDecoder, bitfile *ld,
563 uint8_t channel, uint8_t *tag)
564 {
565 uint8_t retval = 0;
566 element sce = {0};
567 ic_stream *ics = &(sce.ics1);
568 ALIGN int16_t spec_data[1024] = {0};
569
570 sce.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
571 DEBUGVAR(1,38,"single_lfe_channel_element(): element_instance_tag"));
572
573 *tag = sce.element_instance_tag;
574 sce.channel = channel;
575 sce.paired_channel = -1;
576
577 retval = individual_channel_stream(hDecoder, &sce, ld, ics, 0, spec_data);
578 if (retval > 0)
579 return retval;
580
581 #ifdef SBR_DEC
582 /* check if next bitstream element is a fill element */
583 /* if so, read it now so SBR decoding can be done in case of a file with SBR */
584 if (faad_showbits(ld, LEN_SE_ID) == ID_FIL)
585 {
586 faad_flushbits(ld, LEN_SE_ID);
587
588 /* one sbr_info describes a channel_element not a channel! */
589 if ((retval = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0)
590 {
591 return retval;
592 }
593 }
594 #endif
595
596 /* noiseless coding is done, spectral reconstruction is done now */
597 retval = reconstruct_single_channel(hDecoder, ics, &sce, spec_data);
598 if (retval > 0)
599 return retval;
600
601 return 0;
602 }
603
604 /* Table 4.4.5 */
605 static uint8_t channel_pair_element(NeAACDecHandle hDecoder, bitfile *ld,
606 uint8_t channels, uint8_t *tag)
607 {
608 ALIGN int16_t spec_data1[1024] = {0};
609 ALIGN int16_t spec_data2[1024] = {0};
610 element cpe = {0};
611 ic_stream *ics1 = &(cpe.ics1);
612 ic_stream *ics2 = &(cpe.ics2);
613 uint8_t result;
614
615 cpe.channel = channels;
616 cpe.paired_channel = channels+1;
617
618 cpe.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
619 DEBUGVAR(1,39,"channel_pair_element(): element_instance_tag"));
620 *tag = cpe.element_instance_tag;
621
622 if ((cpe.common_window = faad_get1bit(ld
623 DEBUGVAR(1,40,"channel_pair_element(): common_window"))) & 1)
624 {
625 /* both channels have common ics information */
626 if ((result = ics_info(hDecoder, ics1, ld, cpe.common_window)) > 0)
627 return result;
628
629 ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2
630 DEBUGVAR(1,41,"channel_pair_element(): ms_mask_present"));
631 if (ics1->ms_mask_present == 1)
632 {
633 uint8_t g, sfb;
634 for (g = 0; g < ics1->num_window_groups; g++)
635 {
636 for (sfb = 0; sfb < ics1->max_sfb; sfb++)
637 {
638 ics1->ms_used[g][sfb] = faad_get1bit(ld
639 DEBUGVAR(1,42,"channel_pair_element(): faad_get1bit"));
640 }
641 }
642 }
643
644 #ifdef ERROR_RESILIENCE
645 if ((hDecoder->object_type >= ER_OBJECT_START) && (ics1->predictor_data_present))
646 {
647 if ((
648 #ifdef LTP_DEC
649 ics1->ltp.data_present =
650 #endif
651 faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
652 {
653 #ifdef LTP_DEC
654 if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp), ld)) > 0)
655 {
656 return result;
657 }
658 #else
659 return 26;
660 #endif
661 }
662 }
663 #endif
664
665 memcpy(ics2, ics1, sizeof(ic_stream));
666 } else {
667 ics1->ms_mask_present = 0;
668 }
669
670 if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics1,
671 0, spec_data1)) > 0)
672 {
673 return result;
674 }
675
676 #ifdef ERROR_RESILIENCE
677 if (cpe.common_window && (hDecoder->object_type >= ER_OBJECT_START) &&
678 (ics1->predictor_data_present))
679 {
680 if ((
681 #ifdef LTP_DEC
682 ics1->ltp2.data_present =
683 #endif
684 faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
685 {
686 #ifdef LTP_DEC
687 if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp2), ld)) > 0)
688 {
689 return result;
690 }
691 #else
692 return 26;
693 #endif
694 }
695 }
696 #endif
697
698 if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics2,
699 0, spec_data2)) > 0)
700 {
701 return result;
702 }
703
704 #ifdef SBR_DEC
705 /* check if next bitstream element is a fill element */
706 /* if so, read it now so SBR decoding can be done in case of a file with SBR */
707 if (faad_showbits(ld, LEN_SE_ID) == ID_FIL)
708 {
709 faad_flushbits(ld, LEN_SE_ID);
710
711 /* one sbr_info describes a channel_element not a channel! */
712 if ((result = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0)
713 {
714 return result;
715 }
716 }
717 #endif
718
719 /* noiseless coding is done, spectral reconstruction is done now */
720 if ((result = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe,
721 spec_data1, spec_data2)) > 0)
722 {
723 return result;
724 }
725
726 return 0;
727 }
728
729 /* Table 4.4.6 */
730 static uint8_t ics_info(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
731 uint8_t common_window)
732 {
733 uint8_t retval = 0;
734
735 /* ics->ics_reserved_bit = */ faad_get1bit(ld
736 DEBUGVAR(1,43,"ics_info(): ics_reserved_bit"));
737 ics->window_sequence = (uint8_t)faad_getbits(ld, 2
738 DEBUGVAR(1,44,"ics_info(): window_sequence"));
739 ics->window_shape = faad_get1bit(ld
740 DEBUGVAR(1,45,"ics_info(): window_shape"));
741
742 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
743 {
744 ics->max_sfb = (uint8_t)faad_getbits(ld, 4
745 DEBUGVAR(1,46,"ics_info(): max_sfb (short)"));
746 ics->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7
747 DEBUGVAR(1,47,"ics_info(): scale_factor_grouping"));
748 } else {
749 ics->max_sfb = (uint8_t)faad_getbits(ld, 6
750 DEBUGVAR(1,48,"ics_info(): max_sfb (long)"));
751 }
752
753 /* get the grouping information */
754 if ((retval = window_grouping_info(hDecoder, ics)) > 0)
755 return retval;
756
757 /* should be an error */
758 /* check the range of max_sfb */
759 if (ics->max_sfb > ics->num_swb)
760 return 16;
761
762 if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
763 {
764 if ((ics->predictor_data_present = faad_get1bit(ld
765 DEBUGVAR(1,49,"ics_info(): predictor_data_present"))) & 1)
766 {
767 if (hDecoder->object_type == MAIN) /* MPEG2 style AAC predictor */
768 {
769 uint8_t sfb;
770
771 uint8_t limit = min(ics->max_sfb, max_pred_sfb(hDecoder->sf_index));
772 #ifdef MAIN_DEC
773 ics->pred.limit = limit;
774 #endif
775
776 if ((
777 #ifdef MAIN_DEC
778 ics->pred.predictor_reset =
779 #endif
780 faad_get1bit(ld DEBUGVAR(1,53,"ics_info(): pred.predictor_reset"))) & 1)
781 {
782 #ifdef MAIN_DEC
783 ics->pred.predictor_reset_group_number =
784 #endif
785 (uint8_t)faad_getbits(ld, 5 DEBUGVAR(1,54,"ics_info(): pred.predictor_reset_group_number"));
786 }
787
788 for (sfb = 0; sfb < limit; sfb++)
789 {
790 #ifdef MAIN_DEC
791 ics->pred.prediction_used[sfb] =
792 #endif
793 faad_get1bit(ld DEBUGVAR(1,55,"ics_info(): pred.prediction_used"));
794 }
795 }
796 #ifdef LTP_DEC
797 else { /* Long Term Prediction */
798 if (hDecoder->object_type < ER_OBJECT_START)
799 {
800 if ((ics->ltp.data_present = faad_get1bit(ld
801 DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
802 {
803 if ((retval = ltp_data(hDecoder, ics, &(ics->ltp), ld)) > 0)
804 {
805 return retval;
806 }
807 }
808 if (common_window)
809 {
810 if ((ics->ltp2.data_present = faad_get1bit(ld
811 DEBUGVAR(1,51,"ics_info(): ltp2.data_present"))) & 1)
812 {
813 if ((retval = ltp_data(hDecoder, ics, &(ics->ltp2), ld)) > 0)
814 {
815 return retval;
816 }
817 }
818 }
819 }
820 #ifdef ERROR_RESILIENCE
821 if (!common_window && (hDecoder->object_type >= ER_OBJECT_START))
822 {
823 if ((ics->ltp.data_present = faad_get1bit(ld
824 DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
825 {
826 ltp_data(hDecoder, ics, &(ics->ltp), ld);
827 }
828 }
829 #endif
830 }
831 #endif
832 }
833 }
834
835 return retval;
836 }
837
838 /* Table 4.4.7 */
839 static uint8_t pulse_data(ic_stream *ics, pulse_info *pul, bitfile *ld)
840 {
841 uint8_t i;
842
843 pul->number_pulse = (uint8_t)faad_getbits(ld, 2
844 DEBUGVAR(1,56,"pulse_data(): number_pulse"));
845 pul->pulse_start_sfb = (uint8_t)faad_getbits(ld, 6
846 DEBUGVAR(1,57,"pulse_data(): pulse_start_sfb"));
847
848 /* check the range of pulse_start_sfb */
849 if (pul->pulse_start_sfb > ics->num_swb)
850 return 16;
851
852 for (i = 0; i < pul->number_pulse+1; i++)
853 {
854 pul->pulse_offset[i] = (uint8_t)faad_getbits(ld, 5
855 DEBUGVAR(1,58,"pulse_data(): pulse_offset"));
856 #if 0
857 printf("%d\n", pul->pulse_offset[i]);
858 #endif
859 pul->pulse_amp[i] = (uint8_t)faad_getbits(ld, 4
860 DEBUGVAR(1,59,"pulse_data(): pulse_amp"));
861 #if 0
862 printf("%d\n", pul->pulse_amp[i]);
863 #endif
864 }
865
866 return 0;
867 }
868
869 #ifdef COUPLING_DEC
870 /* Table 4.4.8: Currently just for skipping the bits... */
871 static uint8_t coupling_channel_element(NeAACDecHandle hDecoder, bitfile *ld)
872 {
873 uint8_t c, result = 0;
874 uint8_t ind_sw_cce_flag = 0;
875 uint8_t num_gain_element_lists = 0;
876 uint8_t num_coupled_elements = 0;
877
878 element el_empty = {0};
879 ic_stream ics_empty = {0};
880 int16_t sh_data[1024];
881
882 c = faad_getbits(ld, LEN_TAG
883 DEBUGVAR(1,900,"coupling_channel_element(): element_instance_tag"));
884
885 ind_sw_cce_flag = faad_get1bit(ld
886 DEBUGVAR(1,901,"coupling_channel_element(): ind_sw_cce_flag"));
887 num_coupled_elements = faad_getbits(ld, 3
888 DEBUGVAR(1,902,"coupling_channel_element(): num_coupled_elements"));
889
890 for (c = 0; c < num_coupled_elements + 1; c++)
891 {
892 uint8_t cc_target_is_cpe, cc_target_tag_select;
893
894 num_gain_element_lists++;
895
896 cc_target_is_cpe = faad_get1bit(ld
897 DEBUGVAR(1,903,"coupling_channel_element(): cc_target_is_cpe"));
898 cc_target_tag_select = faad_getbits(ld, 4
899 DEBUGVAR(1,904,"coupling_channel_element(): cc_target_tag_select"));
900
901 if (cc_target_is_cpe)
902 {
903 uint8_t cc_l = faad_get1bit(ld
904 DEBUGVAR(1,905,"coupling_channel_element(): cc_l"));
905 uint8_t cc_r = faad_get1bit(ld
906 DEBUGVAR(1,906,"coupling_channel_element(): cc_r"));
907
908 if (cc_l && cc_r)
909 num_gain_element_lists++;
910 }
911 }
912
913 faad_get1bit(ld
914 DEBUGVAR(1,907,"coupling_channel_element(): cc_domain"));
915 faad_get1bit(ld
916 DEBUGVAR(1,908,"coupling_channel_element(): gain_element_sign"));
917 faad_getbits(ld, 2
918 DEBUGVAR(1,909,"coupling_channel_element(): gain_element_scale"));
919
920 if ((result = individual_channel_stream(hDecoder, &el_empty, ld, &ics_empty,
921 0, sh_data)) > 0)
922 {
923 return result;
924 }
925
926 for (c = 1; c < num_gain_element_lists; c++)
927 {
928 uint8_t cge;
929
930 if (ind_sw_cce_flag)
931 {
932 cge = 1;
933 } else {
934 cge = faad_get1bit(ld
935 DEBUGVAR(1,910,"coupling_channel_element(): common_gain_element_present"));
936 }
937
938 if (cge)
939 {
940 huffman_scale_factor(ld);
941 } else {
942 uint8_t g, sfb;
943
944 for (g = 0; g < ics_empty.num_window_groups; g++)
945 {
946 for (sfb = 0; sfb < ics_empty.max_sfb; sfb++)
947 {
948 if (ics_empty.sfb_cb[g][sfb] != ZERO_HCB)
949 huffman_scale_factor(ld);
950 }
951 }
952 }
953 }
954
955 return 0;
956 }
957 #endif
958
959 /* Table 4.4.10 */
960 static uint16_t data_stream_element(NeAACDecHandle hDecoder, bitfile *ld)
961 {
962 uint8_t byte_aligned;
963 uint16_t i, count;
964
965 /* element_instance_tag = */ faad_getbits(ld, LEN_TAG
966 DEBUGVAR(1,60,"data_stream_element(): element_instance_tag"));
967 byte_aligned = faad_get1bit(ld
968 DEBUGVAR(1,61,"data_stream_element(): byte_aligned"));
969 count = (uint16_t)faad_getbits(ld, 8
970 DEBUGVAR(1,62,"data_stream_element(): count"));
971 if (count == 255)
972 {
973 count += (uint16_t)faad_getbits(ld, 8
974 DEBUGVAR(1,63,"data_stream_element(): extra count"));
975 }
976 if (byte_aligned)
977 faad_byte_align(ld);
978
979 for (i = 0; i < count; i++)
980 {
981 faad_getbits(ld, LEN_BYTE
982 DEBUGVAR(1,64,"data_stream_element(): data_stream_byte"));
983 }
984
985 return count;
986 }
987
988 /* Table 4.4.11 */
989 static uint8_t fill_element(NeAACDecHandle hDecoder, bitfile *ld, drc_info *drc
990 #ifdef SBR_DEC
991 ,uint8_t sbr_ele
992 #endif
993 )
994 {
995 uint16_t count;
996 #ifdef SBR_DEC
997 uint8_t bs_extension_type;
998 #endif
999
1000 count = (uint16_t)faad_getbits(ld, 4
1001 DEBUGVAR(1,65,"fill_element(): count"));
1002 if (count == 15)
1003 {
1004 count += (uint16_t)faad_getbits(ld, 8
1005 DEBUGVAR(1,66,"fill_element(): extra count")) - 1;
1006 }
1007
1008 if (count > 0)
1009 {
1010 #ifdef SBR_DEC
1011 bs_extension_type = (uint8_t)faad_showbits(ld, 4);
1012
1013 if ((bs_extension_type == EXT_SBR_DATA) ||
1014 (bs_extension_type == EXT_SBR_DATA_CRC))
1015 {
1016 if (sbr_ele == INVALID_SBR_ELEMENT)
1017 return 24;
1018
1019 if (!hDecoder->sbr[sbr_ele])
1020 {
1021 hDecoder->sbr[sbr_ele] = sbrDecodeInit(hDecoder->frameLength,
1022 hDecoder->element_id[sbr_ele], 2*get_sample_rate(hDecoder->sf_index),
1023 hDecoder->downSampledSBR
1024 #ifdef DRM
1025 , 0
1026 #endif
1027 );
1028 }
1029
1030 hDecoder->sbr_present_flag = 1;
1031
1032 /* parse the SBR data */
1033 hDecoder->sbr[sbr_ele]->ret = sbr_extension_data(ld, hDecoder->sbr[sbr_ele], count);
1034
1035 #if 0
1036 if (hDecoder->sbr[sbr_ele]->ret > 0)
1037 {
1038 printf("%s\n", NeAACDecGetErrorMessage(hDecoder->sbr[sbr_ele]->ret));
1039 }
1040 #endif
1041
1042 #if (defined(PS_DEC) || defined(DRM_PS))
1043 if (hDecoder->sbr[sbr_ele]->ps_used)
1044 {
1045 hDecoder->ps_used[sbr_ele] = 1;
1046
1047 /* set element independent flag to 1 as well */
1048 hDecoder->ps_used_global = 1;
1049 }
1050 #endif
1051 } else {
1052 #endif
1053 while (count > 0)
1054 {
1055 count -= extension_payload(ld, drc, count);
1056 }
1057 #ifdef SBR_DEC
1058 }
1059 #endif
1060 }
1061
1062 return 0;
1063 }
1064
1065 /* Table 4.4.12 */
1066 #ifdef SSR_DEC
1067 static void gain_control_data(bitfile *ld, ic_stream *ics)
1068 {
1069 uint8_t bd, wd, ad;
1070 ssr_info *ssr = &(ics->ssr);
1071
1072 ssr->max_band = (uint8_t)faad_getbits(ld, 2
1073 DEBUGVAR(1,1000,"gain_control_data(): max_band"));
1074
1075 if (ics->window_sequence == ONLY_LONG_SEQUENCE)
1076 {
1077 for (bd = 1; bd <= ssr->max_band; bd++)
1078 {
1079 for (wd = 0; wd < 1; wd++)
1080 {
1081 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
1082 DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
1083
1084 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
1085 {
1086 ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1087 DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
1088 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
1089 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1090 }
1091 }
1092 }
1093 } else if (ics->window_sequence == LONG_START_SEQUENCE) {
1094 for (bd = 1; bd <= ssr->max_band; bd++)
1095 {
1096 for (wd = 0; wd < 2; wd++)
1097 {
1098 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
1099 DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
1100
1101 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
1102 {
1103 ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1104 DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
1105 if (wd == 0)
1106 {
1107 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1108 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1109 } else {
1110 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
1111 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1112 }
1113 }
1114 }
1115 }
1116 } else if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) {
1117 for (bd = 1; bd <= ssr->max_band; bd++)
1118 {
1119 for (wd = 0; wd < 8; wd++)
1120 {
1121 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
1122 DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
1123
1124 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
1125 {
1126 ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1127 DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
1128 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
1129 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1130 }
1131 }
1132 }
1133 } else if (ics->window_sequence == LONG_STOP_SEQUENCE) {
1134 for (bd = 1; bd <= ssr->max_band; bd++)
1135 {
1136 for (wd = 0; wd < 2; wd++)
1137 {
1138 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
1139 DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
1140
1141 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
1142 {
1143 ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1144 DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
1145
1146 if (wd == 0)
1147 {
1148 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
1149 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1150 } else {
1151 ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
1152 DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
1153 }
1154 }
1155 }
1156 }
1157 }
1158 }
1159 #endif
1160
1161 #ifdef SCALABLE_DEC
1162 /* Table 4.4.13 ASME */
1163 void aac_scalable_main_element(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
1164 bitfile *ld, program_config *pce, drc_info *drc)
1165 {
1166 uint8_t retval = 0;
1167 uint8_t channels = hDecoder->fr_channels = 0;
1168 uint8_t ch;
1169 uint8_t this_layer_stereo = (hDecoder->channelConfiguration > 1) ? 1 : 0;
1170 element cpe = {0};
1171 ic_stream *ics1 = &(cpe.ics1);
1172 ic_stream *ics2 = &(cpe.ics2);
1173 int16_t *spec_data;
1174 ALIGN int16_t spec_data1[1024] = {0};
1175 ALIGN int16_t spec_data2[1024] = {0};
1176
1177 hDecoder->fr_ch_ele = 0;
1178
1179 hInfo->error = aac_scalable_main_header(hDecoder, ics1, ics2, ld, this_layer_stereo);
1180 if (hInfo->error > 0)
1181 return;
1182
1183 cpe.common_window = 1;
1184 if (this_layer_stereo)
1185 {
1186 hDecoder->element_id[0] = ID_CPE;
1187 if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
1188 hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2;
1189 } else {
1190 hDecoder->element_id[0] = ID_SCE;
1191 }
1192
1193 for (ch = 0; ch < (this_layer_stereo ? 2 : 1); ch++)
1194 {
1195 ic_stream *ics;
1196 if (ch == 0)
1197 {
1198 ics = ics1;
1199 spec_data = spec_data1;
1200 } else {
1201 ics = ics2;
1202 spec_data = spec_data2;
1203 }
1204
1205 hInfo->error = individual_channel_stream(hDecoder, &cpe, ld, ics, 1, spec_data);
1206 if (hInfo->error > 0)
1207 return;
1208 }
1209
1210 #ifdef DRM
1211 #ifdef SBR_DEC
1212 /* In case of DRM we need to read the SBR info before channel reconstruction */
1213 if ((hDecoder->sbr_present_flag == 1) && (hDecoder->object_type == DRM_ER_LC))
1214 {
1215 bitfile ld_sbr = {0};
1216 uint32_t i;
1217 uint16_t count = 0;
1218 uint8_t *revbuffer;
1219 uint8_t *prevbufstart;
1220 uint8_t *pbufend;
1221
1222 /* all forward bitreading should be finished at this point */
1223 uint32_t bitsconsumed = faad_get_processed_bits(ld);
1224 uint32_t buffer_size = faad_origbitbuffer_size(ld);
1225 uint8_t *buffer = (uint8_t*)faad_origbitbuffer(ld);
1226
1227 if (bitsconsumed + 8 > buffer_size*8)
1228 {
1229 hInfo->error = 14;
1230 return;
1231 }
1232
1233 if (!hDecoder->sbr[0])
1234 {
1235 hDecoder->sbr[0] = sbrDecodeInit(hDecoder->frameLength, hDecoder->element_id[0],
1236 2*get_sample_rate(hDecoder->sf_index), 0 /* ds SBR */, 1);
1237 }
1238
1239 /* Reverse bit reading of SBR data in DRM audio frame */
1240 revbuffer = (uint8_t*)faad_malloc(buffer_size*sizeof(uint8_t));
1241 prevbufstart = revbuffer;
1242 pbufend = &buffer[buffer_size - 1];
1243 for (i = 0; i < buffer_size; i++)
1244 *prevbufstart++ = tabFlipbits[*pbufend--];
1245
1246 /* Set SBR data */
1247 /* consider 8 bits from AAC-CRC */
1248 count = (uint16_t)bit2byte(buffer_size*8 - bitsconsumed);
1249 faad_initbits(&ld_sbr, revbuffer, count);
1250
1251 hDecoder->sbr[0]->sample_rate = get_sample_rate(hDecoder->sf_index);
1252 hDecoder->sbr[0]->sample_rate *= 2;
1253
1254 faad_getbits(&ld_sbr, 8); /* Skip 8-bit CRC */
1255
1256 hDecoder->sbr[0]->ret = sbr_extension_data(&ld_sbr, hDecoder->sbr[0], count);
1257 #if (defined(PS_DEC) || defined(DRM_PS))
1258 if (hDecoder->sbr[0]->ps_used)
1259 {
1260 hDecoder->ps_used[0] = 1;
1261 hDecoder->ps_used_global = 1;
1262 }
1263 #endif
1264
1265 /* check CRC */
1266 /* no need to check it if there was already an error */
1267 if (hDecoder->sbr[0]->ret == 0)
1268 hDecoder->sbr[0]->ret = (uint8_t)faad_check_CRC(&ld_sbr, (uint16_t)faad_get_processed_bits(&ld_sbr) - 8);
1269
1270 /* SBR data was corrupted, disable it until the next header */
1271 if (hDecoder->sbr[0]->ret != 0)
1272 {
1273 hDecoder->sbr[0]->header_count = 0;
1274 }
1275
1276 faad_endbits(&ld_sbr);
1277
1278 if (revbuffer)
1279 faad_free(revbuffer);
1280 }
1281 #endif
1282 #endif
1283
1284 if (this_layer_stereo)
1285 {
1286 hInfo->error = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe, spec_data1, spec_data2);
1287 if (hInfo->error > 0)
1288 return;
1289 } else {
1290 hInfo->error = reconstruct_single_channel(hDecoder, ics1, &cpe, spec_data1);
1291 if (hInfo->error > 0)
1292 return;
1293 }
1294
1295 /* map output channels position to internal data channels */
1296 if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2)
1297 {
1298 /* this might be faulty when pce_set is true */
1299 hDecoder->internal_channel[channels] = channels;
1300 hDecoder->internal_channel[channels+1] = channels+1;
1301 } else {
1302 hDecoder->internal_channel[channels] = channels;
1303 }
1304
1305 hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele];
1306 hDecoder->fr_ch_ele++;
1307
1308 return;
1309 }
1310
1311 /* Table 4.4.15 */
1312 static int8_t aac_scalable_main_header(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
1313 bitfile *ld, uint8_t this_layer_stereo)
1314 {
1315 uint8_t retval = 0;
1316 uint8_t ch;
1317 ic_stream *ics;
1318
1319 /* ics1->ics_reserved_bit = */ faad_get1bit(ld
1320 DEBUGVAR(1,300,"aac_scalable_main_header(): ics_reserved_bits"));
1321 ics1->window_sequence = (uint8_t)faad_getbits(ld, 2
1322 DEBUGVAR(1,301,"aac_scalable_main_header(): window_sequence"));
1323 ics1->window_shape = faad_get1bit(ld
1324 DEBUGVAR(1,302,"aac_scalable_main_header(): window_shape"));
1325
1326 if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE)
1327 {
1328 ics1->max_sfb = (uint8_t)faad_getbits(ld, 4
1329 DEBUGVAR(1,303,"aac_scalable_main_header(): max_sfb (short)"));
1330 ics1->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7
1331 DEBUGVAR(1,304,"aac_scalable_main_header(): scale_factor_grouping"));
1332 } else {
1333 ics1->max_sfb = (uint8_t)faad_getbits(ld, 6
1334 DEBUGVAR(1,305,"aac_scalable_main_header(): max_sfb (long)"));
1335 }
1336
1337 /* get the grouping information */
1338 if ((retval = window_grouping_info(hDecoder, ics1)) > 0)
1339 return retval;
1340
1341 /* should be an error */
1342 /* check the range of max_sfb */
1343 if (ics1->max_sfb > ics1->num_swb)
1344 return 16;
1345
1346 if (this_layer_stereo)
1347 {
1348 ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2
1349 DEBUGVAR(1,306,"aac_scalable_main_header(): ms_mask_present"));
1350 if (ics1->ms_mask_present == 1)
1351 {
1352 uint8_t g, sfb;
1353 for (g = 0; g < ics1->num_window_groups; g++)
1354 {
1355 for (sfb = 0; sfb < ics1->max_sfb; sfb++)
1356 {
1357 ics1->ms_used[g][sfb] = faad_get1bit(ld
1358 DEBUGVAR(1,307,"aac_scalable_main_header(): faad_get1bit"));
1359 }
1360 }
1361 }
1362
1363 memcpy(ics2, ics1, sizeof(ic_stream));
1364 } else {
1365 ics1->ms_mask_present = 0;
1366 }
1367
1368 if (0)
1369 {
1370 faad_get1bit(ld
1371 DEBUGVAR(1,308,"aac_scalable_main_header(): tns_channel_mono_layer"));
1372 }
1373
1374 for (ch = 0; ch < (this_layer_stereo ? 2 : 1); ch++)
1375 {
1376 if (ch == 0)
1377 ics = ics1;
1378 else
1379 ics = ics2;
1380
1381 if ( 1 /*!tvq_layer_pesent || (tns_aac_tvq_en[ch] == 1)*/)
1382 {
1383 if ((ics->tns_data_present = faad_get1bit(ld
1384 DEBUGVAR(1,309,"aac_scalable_main_header(): tns_data_present"))) & 1)
1385 {
1386 #ifdef DRM
1387 /* different order of data units in DRM */
1388 if (hDecoder->object_type != DRM_ER_LC)
1389 #endif
1390 {
1391 tns_data(ics, &(ics->tns), ld);
1392 }
1393 }
1394 }
1395 #if 0
1396 if (0 /*core_flag || tvq_layer_pesent*/)
1397 {
1398 if ((ch==0) || ((ch==1) && (core_stereo || tvq_stereo))
1399 diff_control_data();
1400 if (mono_stereo_flag)
1401 diff_control_data_lr();
1402 } else {
1403 #endif
1404 if ((
1405 #ifdef LTP_DEC
1406 ics->ltp.data_present =
1407 #endif
1408 faad_get1bit(ld DEBUGVAR(1,310,"aac_scalable_main_header(): ltp.data_present"))) & 1)
1409 {
1410 #ifdef LTP_DEC
1411 if ((retval = ltp_data(hDecoder, ics, &(ics->ltp), ld)) > 0)
1412 {
1413 return retval;
1414 }
1415 #else
1416 return 26;
1417 #endif
1418 }
1419 #if 0
1420 }
1421 #endif
1422 }
1423
1424 return 0;
1425 }
1426 #endif
1427
1428 /* Table 4.4.24 */
1429 static uint8_t individual_channel_stream(NeAACDecHandle hDecoder, element *ele,
1430 bitfile *ld, ic_stream *ics, uint8_t scal_flag,
1431 int16_t *spec_data)
1432 {
1433 uint8_t result;
1434
1435 ics->global_gain = (uint8_t)faad_getbits(ld, 8
1436 DEBUGVAR(1,67,"individual_channel_stream(): global_gain"));
1437
1438 if (!ele->common_window && !scal_flag)
1439 {
1440 if ((result = ics_info(hDecoder, ics, ld, ele->common_window)) > 0)
1441 return result;
1442 }
1443
1444 if ((result = section_data(hDecoder, ics, ld)) > 0)
1445 return result;
1446
1447 if ((result = scale_factor_data(hDecoder, ics, ld)) > 0)
1448 return result;
1449
1450 if (!scal_flag)
1451 {
1452 /**
1453 ** NOTE: It could be that pulse data is available in scalable AAC too,
1454 ** as said in Amendment 1, this could be only the case for ER AAC,
1455 ** though. (have to check this out later)
1456 **/
1457 /* get pulse data */
1458 if ((ics->pulse_data_present = faad_get1bit(ld
1459 DEBUGVAR(1,68,"individual_channel_stream(): pulse_data_present"))) & 1)
1460 {
1461 if ((result = pulse_data(ics, &(ics->pul), ld)) > 0)
1462 return result;
1463 }
1464
1465 /* get tns data */
1466 if ((ics->tns_data_present = faad_get1bit(ld
1467 DEBUGVAR(1,69,"individual_channel_stream(): tns_data_present"))) & 1)
1468 {
1469 #ifdef ERROR_RESILIENCE
1470 if (hDecoder->object_type < ER_OBJECT_START)
1471 #endif
1472 tns_data(ics, &(ics->tns), ld);
1473 }
1474
1475 /* get gain control data */
1476 if ((ics->gain_control_data_present = faad_get1bit(ld
1477 DEBUGVAR(1,70,"individual_channel_stream(): gain_control_data_present"))) & 1)
1478 {
1479 #ifdef SSR_DEC
1480 if (hDecoder->object_type != SSR)
1481 return 1;
1482 else
1483 gain_control_data(ld, ics);
1484 #else
1485 return 1;
1486 #endif
1487 }
1488 }
1489
1490 #ifdef ERROR_RESILIENCE
1491 if (hDecoder->aacSpectralDataResilienceFlag)
1492 {
1493 ics->length_of_reordered_spectral_data = (uint16_t)faad_getbits(ld, 14
1494 DEBUGVAR(1,147,"individual_channel_stream(): length_of_reordered_spectral_data"));
1495
1496 if (hDecoder->channelConfiguration == 2)
1497 {
1498 if (ics->length_of_reordered_spectral_data > 6144)
1499 ics->length_of_reordered_spectral_data = 6144;
1500 } else {
1501 if (ics->length_of_reordered_spectral_data > 12288)
1502 ics->length_of_reordered_spectral_data = 12288;
1503 }
1504
1505 ics->length_of_longest_codeword = (uint8_t)faad_getbits(ld, 6
1506 DEBUGVAR(1,148,"individual_channel_stream(): length_of_longest_codeword"));
1507 if (ics->length_of_longest_codeword >= 49)
1508 ics->length_of_longest_codeword = 49;
1509 }
1510
1511 /* RVLC spectral data is put here */
1512 if (hDecoder->aacScalefactorDataResilienceFlag)
1513 {
1514 if ((result = rvlc_decode_scale_factors(ics, ld)) > 0)
1515 return result;
1516 }
1517
1518 if (hDecoder->object_type >= ER_OBJECT_START)
1519 {
1520 if (ics->tns_data_present)
1521 tns_data(ics, &(ics->tns), ld);
1522 }
1523
1524 #ifdef DRM
1525 /* CRC check */
1526 if (hDecoder->object_type == DRM_ER_LC)
1527 if ((result = (uint8_t)faad_check_CRC(ld, (uint16_t)faad_get_processed_bits(ld) - 8)) > 0)
1528 return result;
1529 #endif
1530
1531 if (hDecoder->aacSpectralDataResilienceFlag)
1532 {
1533 /* error resilient spectral data decoding */
1534 if ((result = reordered_spectral_data(hDecoder, ics, ld, spec_data)) > 0)
1535 {
1536 return result;
1537 }
1538 } else {
1539 #endif
1540 /* decode the spectral data */
1541 if ((result = spectral_data(hDecoder, ics, ld, spec_data)) > 0)
1542 {
1543 return result;
1544 }
1545 #ifdef ERROR_RESILIENCE
1546 }
1547 #endif
1548
1549 /* pulse coding reconstruction */
1550 if (ics->pulse_data_present)
1551 {
1552 if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
1553 {
1554 if ((result = pulse_decode(ics, spec_data, hDecoder->frameLength)) > 0)
1555 return result;
1556 } else {
1557 return 2; /* pulse coding not allowed for short blocks */
1558 }
1559 }
1560
1561 return 0;
1562 }
1563
1564 /* Table 4.4.25 */
1565 static uint8_t section_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld)
1566 {
1567 uint8_t g;
1568 uint8_t sect_esc_val, sect_bits;
1569
1570 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
1571 sect_bits = 3;
1572 else
1573 sect_bits = 5;
1574 sect_esc_val = (1<<sect_bits) - 1;
1575
1576 #if 0
1577 printf("\ntotal sfb %d\n", ics->max_sfb);
1578 printf(" sect top cb\n");
1579 #endif
1580
1581 for (g = 0; g < ics->num_window_groups; g++)
1582 {
1583 uint8_t k = 0;
1584 uint8_t i = 0;
1585
1586 while (k < ics->max_sfb)
1587 {
1588 #ifdef ERROR_RESILIENCE
1589 uint8_t vcb11 = 0;
1590 #endif
1591 uint8_t sfb;
1592 uint8_t sect_len_incr;
1593 uint16_t sect_len = 0;
1594 uint8_t sect_cb_bits = 4;
1595
1596 /* if "faad_getbits" detects error and returns "0", "k" is never
1597 incremented and we cannot leave the while loop */
1598 if ((ld->error != 0) || (ld->no_more_reading))
1599 return 14;
1600
1601 #ifdef ERROR_RESILIENCE
1602 if (hDecoder->aacSectionDataResilienceFlag)
1603 sect_cb_bits = 5;
1604 #endif
1605
1606 ics->sect_cb[g][i] = (uint8_t)faad_getbits(ld, sect_cb_bits
1607 DEBUGVAR(1,71,"section_data(): sect_cb"));
1608
1609 #if 0
1610 printf("%d\n", ics->sect_cb[g][i]);
1611 #endif
1612
1613 if (ics->sect_cb[g][i] == NOISE_HCB)
1614 ics->noise_used = 1;
1615
1616 #ifdef ERROR_RESILIENCE
1617 if (hDecoder->aacSectionDataResilienceFlag)
1618 {
1619 if ((ics->sect_cb[g][i] == 11) ||
1620 ((ics->sect_cb[g][i] >= 16) && (ics->sect_cb[g][i] <= 32)))
1621 {
1622 vcb11 = 1;
1623 }
1624 }
1625 if (vcb11)
1626 {
1627 sect_len_incr = 1;
1628 } else {
1629 #endif
1630 sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
1631 DEBUGVAR(1,72,"section_data(): sect_len_incr"));
1632 #ifdef ERROR_RESILIENCE
1633 }
1634 #endif
1635 while ((sect_len_incr == sect_esc_val) /* &&
1636 (k+sect_len < ics->max_sfb)*/)
1637 {
1638 sect_len += sect_len_incr;
1639 sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
1640 DEBUGVAR(1,72,"section_data(): sect_len_incr"));
1641 }
1642
1643 sect_len += sect_len_incr;
1644
1645 ics->sect_start[g][i] = k;
1646 ics->sect_end[g][i] = k + sect_len;
1647
1648 #if 0
1649 printf("%d\n", ics->sect_start[g][i]);
1650 #endif
1651 #if 0
1652 printf("%d\n", ics->sect_end[g][i]);
1653 #endif
1654
1655 if (k + sect_len >= 8*15)
1656 return 15;
1657 if (i >= 8*15)
1658 return 15;
1659
1660 for (sfb = k; sfb < k + sect_len; sfb++)
1661 {
1662 ics->sfb_cb[g][sfb] = ics->sect_cb[g][i];
1663 #if 0
1664 printf("%d\n", ics->sfb_cb[g][sfb]);
1665 #endif
1666 }
1667
1668 #if 0
1669 printf(" %6d %6d %6d\n",
1670 i,
1671 ics->sect_end[g][i],
1672 ics->sect_cb[g][i]);
1673 #endif
1674
1675 k += sect_len;
1676 i++;
1677 }
1678 ics->num_sec[g] = i;
1679 #if 0
1680 printf("%d\n", ics->num_sec[g]);
1681 #endif
1682 }
1683
1684 #if 0
1685 printf("\n");
1686 #endif
1687
1688 return 0;
1689 }
1690
1691 /*
1692 * decode_scale_factors()
1693 * decodes the scalefactors from the bitstream
1694 */
1695 /*
1696 * All scalefactors (and also the stereo positions and pns energies) are
1697 * transmitted using Huffman coded DPCM relative to the previous active
1698 * scalefactor (respectively previous stereo position or previous pns energy,
1699 * see subclause 4.6.2 and 4.6.3). The first active scalefactor is
1700 * differentially coded relative to the global gain.
1701 */
1702 static uint8_t decode_scale_factors(ic_stream *ics, bitfile *ld)
1703 {
1704 uint8_t g, sfb;
1705 int16_t t;
1706 int8_t noise_pcm_flag = 1;
1707
1708 int16_t scale_factor = ics->global_gain;
1709 int16_t is_position = 0;
1710 int16_t noise_energy = ics->global_gain - 90;
1711
1712 for (g = 0; g < ics->num_window_groups; g++)
1713 {
1714 for (sfb = 0; sfb < ics->max_sfb; sfb++)
1715 {
1716 switch (ics->sfb_cb[g][sfb])
1717 {
1718 case ZERO_HCB: /* zero book */
1719 ics->scale_factors[g][sfb] = 0;
1720 //#define SF_PRINT
1721 #ifdef SF_PRINT
1722 printf("%d\n", ics->scale_factors[g][sfb]);
1723 #endif
1724 break;
1725 case INTENSITY_HCB: /* intensity books */
1726 case INTENSITY_HCB2:
1727
1728 /* decode intensity position */
1729 t = huffman_scale_factor(ld);
1730 is_position += (t - 60);
1731 ics->scale_factors[g][sfb] = is_position;
1732 #ifdef SF_PRINT
1733 printf("%d\n", ics->scale_factors[g][sfb]);
1734 #endif
1735
1736 break;
1737 case NOISE_HCB: /* noise books */
1738
1739 /* decode noise energy */
1740 if (noise_pcm_flag)
1741 {
1742 noise_pcm_flag = 0;
1743 t = (int16_t)faad_getbits(ld, 9
1744 DEBUGVAR(1,73,"scale_factor_data(): first noise")) - 256;
1745 } else {
1746 t = huffman_scale_factor(ld);
1747 t -= 60;
1748 }
1749 noise_energy += t;
1750 ics->scale_factors[g][sfb] = noise_energy;
1751 #ifdef SF_PRINT
1752 printf("%d\n", ics->scale_factors[g][sfb]);
1753 #endif
1754
1755 break;
1756 default: /* spectral books */
1757
1758 /* ics->scale_factors[g][sfb] must be between 0 and 255 */
1759
1760 ics->scale_factors[g][sfb] = 0;
1761
1762 /* decode scale factor */
1763 t = huffman_scale_factor(ld);
1764 scale_factor += (t - 60);
1765 if (scale_factor < 0 || scale_factor > 255)
1766 return 4;
1767 ics->scale_factors[g][sfb] = scale_factor;
1768 #ifdef SF_PRINT
1769 printf("%d\n", ics->scale_factors[g][sfb]);
1770 #endif
1771
1772 break;
1773 }
1774 }
1775 }
1776
1777 return 0;
1778 }
1779
1780 /* Table 4.4.26 */
1781 static uint8_t scale_factor_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld)
1782 {
1783 uint8_t ret = 0;
1784 #ifdef PROFILE
1785 int64_t count = faad_get_ts();
1786 #endif
1787
1788 #ifdef ERROR_RESILIENCE
1789 if (!hDecoder->aacScalefactorDataResilienceFlag)
1790 {
1791 #endif
1792 ret = decode_scale_factors(ics, ld);
1793 #ifdef ERROR_RESILIENCE
1794 } else {
1795 /* In ER AAC the parameters for RVLC are seperated from the actual
1796 data that holds the scale_factors.
1797 Strangely enough, 2 parameters for HCR are put inbetween them.
1798 */
1799 ret = rvlc_scale_factor_data(ics, ld);
1800 }
1801 #endif
1802
1803 #ifdef PROFILE
1804 count = faad_get_ts() - count;
1805 hDecoder->scalefac_cycles += count;
1806 #endif
1807
1808 return ret;
1809 }
1810
1811 /* Table 4.4.27 */
1812 static void tns_data(ic_stream *ics, tns_info *tns, bitfile *ld)
1813 {
1814 uint8_t w, filt, i, start_coef_bits, coef_bits;
1815 uint8_t n_filt_bits = 2;
1816 uint8_t length_bits = 6;
1817 uint8_t order_bits = 5;
1818
1819 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
1820 {
1821 n_filt_bits = 1;
1822 length_bits = 4;
1823 order_bits = 3;
1824 }
1825
1826 for (w = 0; w < ics->num_windows; w++)
1827 {
1828 tns->n_filt[w] = (uint8_t)faad_getbits(ld, n_filt_bits
1829 DEBUGVAR(1,74,"tns_data(): n_filt"));
1830 #if 0
1831 printf("%d\n", tns->n_filt[w]);
1832 #endif
1833
1834 if (tns->n_filt[w])
1835 {
1836 if ((tns->coef_res[w] = faad_get1bit(ld
1837 DEBUGVAR(1,75,"tns_data(): coef_res"))) & 1)
1838 {
1839 start_coef_bits = 4;
1840 } else {
1841 start_coef_bits = 3;
1842 }
1843 #if 0
1844 printf("%d\n", tns->coef_res[w]);
1845 #endif
1846 }
1847
1848 for (filt = 0; filt < tns->n_filt[w]; filt++)
1849 {
1850 tns->length[w][filt] = (uint8_t)faad_getbits(ld, length_bits
1851 DEBUGVAR(1,76,"tns_data(): length"));
1852 #if 0
1853 printf("%d\n", tns->length[w][filt]);
1854 #endif
1855 tns->order[w][filt] = (uint8_t)faad_getbits(ld, order_bits
1856 DEBUGVAR(1,77,"tns_data(): order"));
1857 #if 0
1858 printf("%d\n", tns->order[w][filt]);
1859 #endif
1860 if (tns->order[w][filt])
1861 {
1862 tns->direction[w][filt] = faad_get1bit(ld
1863 DEBUGVAR(1,78,"tns_data(): direction"));
1864 #if 0
1865 printf("%d\n", tns->direction[w][filt]);
1866 #endif
1867 tns->coef_compress[w][filt] = faad_get1bit(ld
1868 DEBUGVAR(1,79,"tns_data(): coef_compress"));
1869 #if 0
1870 printf("%d\n", tns->coef_compress[w][filt]);
1871 #endif
1872
1873 coef_bits = start_coef_bits - tns->coef_compress[w][filt];
1874 for (i = 0; i < tns->order[w][filt]; i++)
1875 {
1876 tns->coef[w][filt][i] = (uint8_t)faad_getbits(ld, coef_bits
1877 DEBUGVAR(1,80,"tns_data(): coef"));
1878 #if 0
1879 printf("%d\n", tns->coef[w][filt][i]);
1880 #endif
1881 }
1882 }
1883 }
1884 }
1885 }
1886
1887 #ifdef LTP_DEC
1888 /* Table 4.4.28 */
1889 static uint8_t ltp_data(NeAACDecHandle hDecoder, ic_stream *ics, ltp_info *ltp, bitfile *ld)
1890 {
1891 uint8_t sfb, w;
1892
1893 ltp->lag = 0;
1894
1895 #ifdef LD_DEC
1896 if (hDecoder->object_type == LD)
1897 {
1898 ltp->lag_update = (uint8_t)faad_getbits(ld, 1
1899 DEBUGVAR(1,142,"ltp_data(): lag_update"));
1900
1901 if (ltp->lag_update)
1902 {
1903 ltp->lag = (uint16_t)faad_getbits(ld, 10
1904 DEBUGVAR(1,81,"ltp_data(): lag"));
1905 }
1906 } else {
1907 #endif
1908 ltp->lag = (uint16_t)faad_getbits(ld, 11
1909 DEBUGVAR(1,81,"ltp_data(): lag"));
1910 #ifdef LD_DEC
1911 }
1912 #endif
1913
1914 /* Check length of lag */
1915 if (ltp->lag > (hDecoder->frameLength << 1))
1916 return 18;
1917
1918 ltp->coef = (uint8_t)faad_getbits(ld, 3
1919 DEBUGVAR(1,82,"ltp_data(): coef"));
1920
1921 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
1922 {
1923 for (w = 0; w < ics->num_windows; w++)
1924 {
1925 if ((ltp->short_used[w] = faad_get1bit(ld
1926 DEBUGVAR(1,83,"ltp_data(): short_used"))) & 1)
1927 {
1928 ltp->short_lag_present[w] = faad_get1bit(ld
1929 DEBUGVAR(1,84,"ltp_data(): short_lag_present"));
1930 if (ltp->short_lag_present[w])
1931 {
1932 ltp->short_lag[w] = (uint8_t)faad_getbits(ld, 4
1933 DEBUGVAR(1,85,"ltp_data(): short_lag"));
1934 }
1935 }
1936 }
1937 } else {
1938 ltp->last_band = (ics->max_sfb < MAX_LTP_SFB ? ics->max_sfb : MAX_LTP_SFB);
1939
1940 for (sfb = 0; sfb < ltp->last_band; sfb++)
1941 {
1942 ltp->long_used[sfb] = faad_get1bit(ld
1943 DEBUGVAR(1,86,"ltp_data(): long_used"));
1944 }
1945 }
1946
1947 return 0;
1948 }
1949 #endif
1950
1951 /* Table 4.4.29 */
1952 static uint8_t spectral_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
1953 int16_t *spectral_data)
1954 {
1955 int8_t i;
1956 uint8_t g;
1957 uint16_t inc, k, p = 0;
1958 uint8_t groups = 0;
1959 uint8_t sect_cb;
1960 uint8_t result;
1961 uint16_t nshort = hDecoder->frameLength/8;
1962
1963 #ifdef PROFILE
1964 int64_t count = faad_get_ts();
1965 #endif
1966
1967 for(g = 0; g < ics->num_window_groups; g++)
1968 {
1969 p = groups*nshort;
1970
1971 for (i = 0; i < ics->num_sec[g]; i++)
1972 {
1973 sect_cb = ics->sect_cb[g][i];
1974
1975 inc = (sect_cb >= FIRST_PAIR_HCB) ? 2 : 4;
1976
1977 switch (sect_cb)
1978 {
1979 case ZERO_HCB:
1980 case NOISE_HCB:
1981 case INTENSITY_HCB:
1982 case INTENSITY_HCB2:
1983 //#define SD_PRINT
1984 #ifdef SD_PRINT
1985 {
1986 int j;
1987 for (j = ics->sect_sfb_offset[g][ics->sect_start[g][i]]; j < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; j++)
1988 {
1989 printf("%d\n", 0);
1990 }
1991 }
1992 #endif
1993 //#define SFBO_PRINT
1994 #ifdef SFBO_PRINT
1995 printf("%d\n", ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
1996 #endif
1997 p += (ics->sect_sfb_offset[g][ics->sect_end[g][i]] -
1998 ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
1999 break;
2000 default:
2001 #ifdef SFBO_PRINT
2002 printf("%d\n", ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
2003 #endif
2004 for (k = ics->sect_sfb_offset[g][ics->sect_start[g][i]];
2005 k < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; k += inc)
2006 {
2007 if ((result = huffman_spectral_data(sect_cb, ld, &spectral_data[p])) > 0)
2008 return result;
2009 #ifdef SD_PRINT
2010 {
2011 int j;
2012 for (j = p; j < p+inc; j++)
2013 {
2014 printf("%d\n", spectral_data[j]);
2015 }
2016 }
2017 #endif
2018 p += inc;
2019 }
2020 break;
2021 }
2022 }
2023 groups += ics->window_group_length[g];
2024 }
2025
2026 #ifdef PROFILE
2027 count = faad_get_ts() - count;
2028 hDecoder->spectral_cycles += count;
2029 #endif
2030
2031 return 0;
2032 }
2033
2034 /* Table 4.4.30 */
2035 static uint16_t extension_payload(bitfile *ld, drc_info *drc, uint16_t count)
2036 {
2037 uint16_t i, n, dataElementLength;
2038 uint8_t dataElementLengthPart;
2039 uint8_t align = 4, data_element_version, loopCounter;
2040
2041 uint8_t extension_type = (uint8_t)faad_getbits(ld, 4
2042 DEBUGVAR(1,87,"extension_payload(): extension_type"));
2043
2044 switch (extension_type)
2045 {
2046 case EXT_DYNAMIC_RANGE:
2047 drc->present = 1;
2048 n = dynamic_range_info(ld, drc);
2049 return n;
2050 case EXT_FILL_DATA:
2051 /* fill_nibble = */ faad_getbits(ld, 4
2052 DEBUGVAR(1,136,"extension_payload(): fill_nibble")); /* must be ‘0000’ */
2053 for (i = 0; i < count-1; i++)
2054 {
2055 /* fill_byte[i] = */ faad_getbits(ld, 8
2056 DEBUGVAR(1,88,"extension_payload(): fill_byte")); /* must be ‘10100101’ */
2057 }
2058 return count;
2059 case EXT_DATA_ELEMENT:
2060 data_element_version = (uint8_t)faad_getbits(ld, 4
2061 DEBUGVAR(1,400,"extension_payload(): data_element_version"));
2062 switch (data_element_version)
2063 {
2064 case ANC_DATA:
2065 loopCounter = 0;
2066 dataElementLength = 0;
2067 do {
2068 dataElementLengthPart = (uint8_t)faad_getbits(ld, 8
2069 DEBUGVAR(1,401,"extension_payload(): dataElementLengthPart"));
2070 dataElementLength += dataElementLengthPart;
2071 loopCounter++;
2072 } while (dataElementLengthPart == 255);
2073
2074 for (i = 0; i < dataElementLength; i++)
2075 {
2076 /* data_element_byte[i] = */ faad_getbits(ld, 8
2077 DEBUGVAR(1,402,"extension_payload(): data_element_byte"));
2078 return (dataElementLength+loopCounter+1);
2079 }
2080 default:
2081 align = 0;
2082 }
2083 case EXT_FIL:
2084 default:
2085 faad_getbits(ld, align
2086 DEBUGVAR(1,88,"extension_payload(): fill_nibble"));
2087 for (i = 0; i < count-1; i++)
2088 {
2089 /* other_bits[i] = */ faad_getbits(ld, 8
2090 DEBUGVAR(1,89,"extension_payload(): fill_bit"));
2091 }
2092 return count;
2093 }
2094 }
2095
2096 /* Table 4.4.31 */
2097 static uint8_t dynamic_range_info(bitfile *ld, drc_info *drc)
2098 {
2099 uint8_t i, n = 1;
2100 uint8_t band_incr;
2101
2102 drc->num_bands = 1;
2103
2104 if (faad_get1bit(ld
2105 DEBUGVAR(1,90,"dynamic_range_info(): has instance_tag")) & 1)
2106 {
2107 drc->pce_instance_tag = (uint8_t)faad_getbits(ld, 4
2108 DEBUGVAR(1,91,"dynamic_range_info(): pce_instance_tag"));
2109 /* drc->drc_tag_reserved_bits = */ faad_getbits(ld, 4
2110 DEBUGVAR(1,92,"dynamic_range_info(): drc_tag_reserved_bits"));
2111 n++;
2112 }
2113
2114 drc->excluded_chns_present = faad_get1bit(ld
2115 DEBUGVAR(1,93,"dynamic_range_info(): excluded_chns_present"));
2116 if (drc->excluded_chns_present == 1)
2117 {
2118 n += excluded_channels(ld, drc);
2119 }
2120
2121 if (faad_get1bit(ld
2122 DEBUGVAR(1,94,"dynamic_range_info(): has bands data")) & 1)
2123 {
2124 band_incr = (uint8_t)faad_getbits(ld, 4
2125 DEBUGVAR(1,95,"dynamic_range_info(): band_incr"));
2126 /* drc->drc_bands_reserved_bits = */ faad_getbits(ld, 4
2127 DEBUGVAR(1,96,"dynamic_range_info(): drc_bands_reserved_bits"));
2128 n++;
2129 drc->num_bands += band_incr;
2130
2131 for (i = 0; i < drc->num_bands; i++);
2132 {
2133 drc->band_top[i] = (uint8_t)faad_getbits(ld, 8
2134 DEBUGVAR(1,97,"dynamic_range_info(): band_top"));
2135 n++;
2136 }
2137 }
2138
2139 if (faad_get1bit(ld
2140 DEBUGVAR(1,98,"dynamic_range_info(): has prog_ref_level")) & 1)
2141 {
2142 drc->prog_ref_level = (uint8_t)faad_getbits(ld, 7
2143 DEBUGVAR(1,99,"dynamic_range_info(): prog_ref_level"));
2144 /* drc->prog_ref_level_reserved_bits = */ faad_get1bit(ld
2145 DEBUGVAR(1,100,"dynamic_range_info(): prog_ref_level_reserved_bits"));
2146 n++;
2147 }
2148
2149 for (i = 0; i < drc->num_bands; i++)
2150 {
2151 drc->dyn_rng_sgn[i] = faad_get1bit(ld
2152 DEBUGVAR(1,101,"dynamic_range_info(): dyn_rng_sgn"));
2153 drc->dyn_rng_ctl[i] = (uint8_t)faad_getbits(ld, 7
2154 DEBUGVAR(1,102,"dynamic_range_info(): dyn_rng_ctl"));
2155 n++;
2156 }
2157
2158 return n;
2159 }
2160
2161 /* Table 4.4.32 */
2162 static uint8_t excluded_channels(bitfile *ld, drc_info *drc)
2163 {
2164 uint8_t i, n = 0;
2165 uint8_t num_excl_chan = 7;
2166
2167 for (i = 0; i < 7; i++)
2168 {
2169 drc->exclude_mask[i] = faad_get1bit(ld
2170 DEBUGVAR(1,103,"excluded_channels(): exclude_mask"));
2171 }
2172 n++;
2173
2174 while ((drc->additional_excluded_chns[n-1] = faad_get1bit(ld
2175 DEBUGVAR(1,104,"excluded_channels(): additional_excluded_chns"))) == 1)
2176 {
2177 for (i = num_excl_chan; i < num_excl_chan+7; i++)
2178 {
2179 drc->exclude_mask[i] = faad_get1bit(ld
2180 DEBUGVAR(1,105,"excluded_channels(): exclude_mask"));
2181 }
2182 n++;
2183 num_excl_chan += 7;
2184 }
2185
2186 return n;
2187 }
2188
2189 /* Annex A: Audio Interchange Formats */
2190
2191 /* Table 1.A.2 */
2192 void get_adif_header(adif_header *adif, bitfile *ld)
2193 {
2194 uint8_t i;
2195
2196 /* adif_id[0] = */ faad_getbits(ld, 8
2197 DEBUGVAR(1,106,"get_adif_header(): adif_id[0]"));
2198 /* adif_id[1] = */ faad_getbits(ld, 8
2199 DEBUGVAR(1,107,"get_adif_header(): adif_id[1]"));
2200 /* adif_id[2] = */ faad_getbits(ld, 8
2201 DEBUGVAR(1,108,"get_adif_header(): adif_id[2]"));
2202 /* adif_id[3] = */ faad_getbits(ld, 8
2203 DEBUGVAR(1,109,"get_adif_header(): adif_id[3]"));
2204 adif->copyright_id_present = faad_get1bit(ld
2205 DEBUGVAR(1,110,"get_adif_header(): copyright_id_present"));
2206 if(adif->copyright_id_present)
2207 {
2208 for (i = 0; i < 72/8; i++)
2209 {
2210 adif->copyright_id[i] = (int8_t)faad_getbits(ld, 8
2211 DEBUGVAR(1,111,"get_adif_header(): copyright_id"));
2212 }
2213 adif->copyright_id[i] = 0;
2214 }
2215 adif->original_copy = faad_get1bit(ld
2216 DEBUGVAR(1,112,"get_adif_header(): original_copy"));
2217 adif->home = faad_get1bit(ld
2218 DEBUGVAR(1,113,"get_adif_header(): home"));
2219 adif->bitstream_type = faad_get1bit(ld
2220 DEBUGVAR(1,114,"get_adif_header(): bitstream_type"));
2221 adif->bitrate = faad_getbits(ld, 23
2222 DEBUGVAR(1,115,"get_adif_header(): bitrate"));
2223 adif->num_program_config_elements = (uint8_t)faad_getbits(ld, 4
2224 DEBUGVAR(1,116,"get_adif_header(): num_program_config_elements"));
2225
2226 for (i = 0; i < adif->num_program_config_elements + 1; i++)
2227 {
2228 if(adif->bitstream_type == 0)
2229 {
2230 adif->adif_buffer_fullness = faad_getbits(ld, 20
2231 DEBUGVAR(1,117,"get_adif_header(): adif_buffer_fullness"));
2232 } else {
2233 adif->adif_buffer_fullness = 0;
2234 }
2235
2236 program_config_element(&adif->pce[i], ld);
2237 }
2238 }
2239
2240 /* Table 1.A.5 */
2241 uint8_t adts_frame(adts_header *adts, bitfile *ld)
2242 {
2243 /* faad_byte_align(ld); */
2244 if (adts_fixed_header(adts, ld))
2245 return 5;
2246 adts_variable_header(adts, ld);
2247 adts_error_check(adts, ld);
2248
2249 return 0;
2250 }
2251
2252 /* Table 1.A.6 */
2253 static uint8_t adts_fixed_header(adts_header *adts, bitfile *ld)
2254 {
2255 uint16_t i;
2256 uint8_t sync_err = 1;
2257
2258 /* try to recover from sync errors */
2259 for (i = 0; i < 768; i++)
2260 {
2261 adts->syncword = (uint16_t)faad_showbits(ld, 12);
2262 if (adts->syncword != 0xFFF)
2263 {
2264 faad_getbits(ld, 8
2265 DEBUGVAR(0,0,""));
2266 } else {
2267 sync_err = 0;
2268 faad_getbits(ld, 12
2269 DEBUGVAR(1,118,"adts_fixed_header(): syncword"));
2270 break;
2271 }
2272 }
2273 if (sync_err)
2274 return 5;
2275
2276 adts->id = faad_get1bit(ld
2277 DEBUGVAR(1,119,"adts_fixed_header(): id"));
2278 adts->layer = (uint8_t)faad_getbits(ld, 2
2279 DEBUGVAR(1,120,"adts_fixed_header(): layer"));
2280 adts->protection_absent = faad_get1bit(ld
2281 DEBUGVAR(1,121,"adts_fixed_header(): protection_absent"));
2282 adts->profile = (uint8_t)faad_getbits(ld, 2
2283 DEBUGVAR(1,122,"adts_fixed_header(): profile"));
2284 adts->sf_index = (uint8_t)faad_getbits(ld, 4
2285 DEBUGVAR(1,123,"adts_fixed_header(): sf_index"));
2286 adts->private_bit = faad_get1bit(ld
2287 DEBUGVAR(1,124,"adts_fixed_header(): private_bit"));
2288 adts->channel_configuration = (uint8_t)faad_getbits(ld, 3
2289 DEBUGVAR(1,125,"adts_fixed_header(): channel_configuration"));
2290 adts->original = faad_get1bit(ld
2291 DEBUGVAR(1,126,"adts_fixed_header(): original"));
2292 adts->home = faad_get1bit(ld
2293 DEBUGVAR(1,127,"adts_fixed_header(): home"));
2294
2295 if (adts->old_format == 1)
2296 {
2297 /* Removed in corrigendum 14496-3:2002 */
2298 if (adts->id == 0)
2299 {
2300 adts->emphasis = (uint8_t)faad_getbits(ld, 2
2301 DEBUGVAR(1,128,"adts_fixed_header(): emphasis"));
2302 }
2303 }
2304
2305 return 0;
2306 }
2307
2308 /* Table 1.A.7 */
2309 static void adts_variable_header(adts_header *adts, bitfile *ld)
2310 {
2311 adts->copyright_identification_bit = faad_get1bit(ld
2312 DEBUGVAR(1,129,"adts_variable_header(): copyright_identification_bit"));
2313 adts->copyright_identification_start = faad_get1bit(ld
2314 DEBUGVAR(1,130,"adts_variable_header(): copyright_identification_start"));
2315 adts->aac_frame_length = (uint16_t)faad_getbits(ld, 13
2316 DEBUGVAR(1,131,"adts_variable_header(): aac_frame_length"));
2317 adts->adts_buffer_fullness = (uint16_t)faad_getbits(ld, 11
2318 DEBUGVAR(1,132,"adts_variable_header(): adts_buffer_fullness"));
2319 adts->no_raw_data_blocks_in_frame = (uint8_t)faad_getbits(ld, 2
2320 DEBUGVAR(1,133,"adts_variable_header(): no_raw_data_blocks_in_frame"));
2321 }
2322
2323 /* Table 1.A.8 */
2324 static void adts_error_check(adts_header *adts, bitfile *ld)
2325 {
2326 if (adts->protection_absent == 0)
2327 {
2328 adts->crc_check = (uint16_t)faad_getbits(ld, 16
2329 DEBUGVAR(1,134,"adts_error_check(): crc_check"));
2330 }
2331 }
2332
2333 /* LATM parsing functions */
2334
2335 static uint32_t latm_get_value(bitfile *ld)
2336 {
2337 uint32_t l, value;
2338 uint8_t bytesForValue;
2339
2340 bytesForValue = (uint8_t)faad_getbits(ld, 2);
2341 value = 0;
2342 for(l=0; l<bytesForValue; l++)
2343 value = (value << 8) | (uint8_t)faad_getbits(ld, 8);
2344
2345 return value;
2346 }
2347
2348
2349 static uint32_t latmParsePayload(latm_header *latm, bitfile *ld)
2350 {
2351 //assuming there's only one program with a single layer and 1 subFrame,
2352 //allStreamsSametimeframing is set,
2353 uint32_t framelen;
2354 uint8_t tmp;
2355
2356 //this should be the payload length field for the current configuration
2357 framelen = 0;
2358 if(latm->framelen_type==0)
2359 {
2360 do
2361 {
2362 tmp = (uint8_t)faad_getbits(ld, 8);
2363 framelen += tmp;
2364 } while(tmp==0xff);
2365 }
2366 else if(latm->framelen_type==1)
2367 framelen=latm->frameLength;
2368
2369 return framelen;
2370 }
2371
2372
2373 static uint32_t latmAudioMuxElement(latm_header *latm, bitfile *ld)
2374 {
2375 uint32_t ascLen, asc_bits=0;
2376 uint32_t x1, y1, m, n, i;
2377 program_config pce;
2378 mp4AudioSpecificConfig mp4ASC;
2379
2380 latm->useSameStreamMux = (uint8_t)faad_getbits(ld, 1);
2381 if(!latm->useSameStreamMux)
2382 {
2383 //parseSameStreamMuxConfig
2384 latm->version = (uint8_t) faad_getbits(ld, 1);
2385 if(latm->version)
2386 latm->versionA = (uint8_t) faad_getbits(ld, 1);
2387 if(latm->versionA)
2388 {
2389 //dunno the payload format for versionA
2390 fprintf(stderr, "versionA not supported\n");
2391 return 0;
2392 }
2393 if(latm->version) //read taraBufferFullness
2394 latm_get_value(ld);
2395 latm->allStreamsSameTimeFraming = (uint8_t)faad_getbits(ld, 1);
2396 latm->numSubFrames = (uint8_t)faad_getbits(ld, 6) + 1;
2397 latm->numPrograms = (uint8_t)faad_getbits(ld, 4) + 1;
2398 latm->numLayers = faad_getbits(ld, 3) + 1;
2399 if(latm->numPrograms>1 || !latm->allStreamsSameTimeFraming || latm->numSubFrames>1 || latm->numLayers>1)
2400 {
2401 fprintf(stderr, "\r\nUnsupported LATM configuration: %d programs/ %d subframes, %d layers, allstreams: %d\n",
2402 latm->numPrograms, latm->numSubFrames, latm->numLayers, latm->allStreamsSameTimeFraming);
2403 return 0;
2404 }
2405 ascLen = 0;
2406 if(latm->version)
2407 ascLen = latm_get_value(ld);
2408
2409 x1 = faad_get_processed_bits(ld);
2410 if(AudioSpecificConfigFromBitfile(ld, &mp4ASC, &pce, 0, 1) < 0)
2411 return 0;
2412
2413 //horrid hack to unread the ASC bits and store them in latm->ASC
2414 //the correct code would rely on an ideal faad_ungetbits()
2415 y1 = faad_get_processed_bits(ld);
2416 if((y1-x1) <= MAX_ASC_BYTES*8)
2417 {
2418 faad_rewindbits(ld);
2419 m = x1;
2420 while(m>0)
2421 {
2422 n = min(m, 32);
2423 faad_getbits(ld, n);
2424 m -= n;
2425 }
2426
2427 i = 0;
2428 m = latm->ASCbits = y1 - x1;
2429 while(m > 0)
2430 {
2431 n = min(m, 8);
2432 latm->ASC[i++] = (uint8_t) faad_getbits(ld, n);
2433 m -= n;
2434 }
2435 }
2436
2437 asc_bits = y1-x1;
2438
2439 if(ascLen>asc_bits)
2440 faad_getbits(ld, ascLen-asc_bits);
2441
2442 latm->framelen_type = (uint8_t) faad_getbits(ld, 3);
2443 if(latm->framelen_type == 0)
2444 {
2445 latm->frameLength = 0;
2446 faad_getbits(ld, 8); //buffer fullness for frame_len_type==0, useless
2447 }
2448 else if(latm->framelen_type == 1)
2449 {
2450 latm->frameLength = faad_getbits(ld, 9);
2451 if(latm->frameLength==0)
2452 {
2453 fprintf(stderr, "Invalid frameLength: 0\r\n");
2454 return 0;
2455 }
2456 latm->frameLength = (latm->frameLength+20)*8;
2457 }
2458 else
2459 { //hellish CELP or HCVX stuff, discard
2460 fprintf(stderr, "Unsupported CELP/HCVX framelentype: %d\n", latm->framelen_type);
2461 return 0;
2462 }
2463
2464 latm->otherDataLenBits = 0;
2465 if(faad_getbits(ld, 1))
2466 { //other data present
2467 int esc, tmp;
2468 if(latm->version)
2469 latm->otherDataLenBits = latm_get_value(ld);
2470 else do
2471 {
2472 esc = faad_getbits(ld, 1);
2473 tmp = faad_getbits(ld, 8);
2474 latm->otherDataLenBits = (latm->otherDataLenBits << 8) + tmp;
2475 } while(esc);
2476 }
2477 if(faad_getbits(ld, 1)) //crc
2478 faad_getbits(ld, 8);
2479 latm->inited = 1;
2480 }
2481
2482 //read payload
2483 if(latm->inited)
2484 return latmParsePayload(latm, ld);
2485 else
2486 return 0;
2487 }
2488
2489
2490 uint32_t faad_latm_frame(latm_header *latm, bitfile *ld)
2491 {
2492 uint16_t len;
2493 uint32_t initpos, endpos, firstpos, ret;
2494
2495 firstpos = faad_get_processed_bits(ld);
2496 while(!ld->error && !ld->no_more_reading)
2497 {
2498 faad_byte_align(ld);
2499 if(faad_showbits(ld, 11) != 0x2B7)
2500 {
2501 faad_getbits(ld, 8);
2502 continue;
2503 }
2504 faad_getbits(ld, 11);
2505 len = faad_getbits(ld, 13);
2506 if(!len)
2507 continue;
2508 initpos = faad_get_processed_bits(ld);
2509 ret = latmAudioMuxElement(latm, ld);
2510 endpos = faad_get_processed_bits(ld);
2511 if(ret>0)
2512 return (len*8)-(endpos-initpos);
2513 //faad_getbits(ld, initpos-endpos); //go back to initpos, but is valid a getbits(-N) ?
2514 }
2515 return -1U;
2516 }
mplayer with SMedia Glamo drivers