src/lib/doslib/ext/faad/syntax.c

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