apps/codecs/libfaad/syntax.c

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