开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
syntax.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：78k
源码类别：

多媒体编程

开发平台：

Visual C++

syntax.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 M. Bakker, Ahead Software AG, http://www.nero.com
  4. **  
  5. ** This program is free software; you can redistribute it and/or modify
  6. ** it under the terms of the GNU General Public License as published by
  7. ** the Free Software Foundation; either version 2 of the License, or
  8. ** (at your option) any later version.
  9. ** 
  10. ** This program is distributed in the hope that it will be useful,
  11. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ** GNU General Public License for more details.
  14. ** 
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software 
  17. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. **
  19. ** Any non-GPL usage of this software or parts of this software is strictly
  20. ** forbidden.
  21. **
  22. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: syntax.c,v 1.2 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. /*
  34.    Reads the AAC bitstream as defined in 14496-3 (MPEG-4 Audio)
  35. */
  37. #include "common.h"
  38. #include "structs.h"
  40. #include <stdlib.h>
  41. #include <string.h>
  43. #include "decoder.h"
  44. #include "syntax.h"
  45. #include "specrec.h"
  46. #include "huffman.h"
  47. #include "bits.h"
  48. #include "pulse.h"
  49. #include "analysis.h"
  50. #include "drc.h"
  51. #ifdef ERROR_RESILIENCE
  52. #include "rvlc.h"
  53. #endif
  54. #ifdef SBR_DEC
  55. #include "sbr_syntax.h"
  56. #endif
  59. /* static function declarations */
  60. static void decode_sce_lfe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
  61.                            uint8_t id_syn_ele);
  62. static void decode_cpe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
  63.                        uint8_t id_syn_ele);
  64. static uint8_t single_lfe_channel_element(NeAACDecHandle hDecoder, bitfile *ld,
  65.                                           uint8_t channel, uint8_t *tag);
  66. static uint8_t channel_pair_element(NeAACDecHandle hDecoder, bitfile *ld,
  67.                                     uint8_t channel, uint8_t *tag);
  68. #ifdef COUPLING_DEC
  69. static uint8_t coupling_channel_element(NeAACDecHandle hDecoder, bitfile *ld);
  70. #endif
  71. static uint16_t data_stream_element(NeAACDecHandle hDecoder, bitfile *ld);
  72. static uint8_t program_config_element(program_config *pce, bitfile *ld);
  73. static uint8_t fill_element(NeAACDecHandle hDecoder, bitfile *ld, drc_info *drc
  74. #ifdef SBR_DEC
  75.                             ,uint8_t sbr_ele
  76. #endif
  77.                             );
  78. static uint8_t individual_channel_stream(NeAACDecHandle hDecoder, element *ele,
  79.                                          bitfile *ld, ic_stream *ics, uint8_t scal_flag,
  80.                                          int16_t *spec_data);
  81. static uint8_t ics_info(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
  82.                         uint8_t common_window);
  83. static uint8_t section_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld);
  84. static uint8_t scale_factor_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld);
  85. #ifdef SSR_DEC
  86. static void gain_control_data(bitfile *ld, ic_stream *ics);
  87. #endif
  88. static uint8_t spectral_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
  89.                              int16_t *spectral_data);
  90. static uint16_t extension_payload(bitfile *ld, drc_info *drc, uint16_t count);
  91. static uint8_t pulse_data(ic_stream *ics, pulse_info *pul, bitfile *ld);
  92. static void tns_data(ic_stream *ics, tns_info *tns, bitfile *ld);
  93. #ifdef LTP_DEC
  94. static uint8_t ltp_data(NeAACDecHandle hDecoder, ic_stream *ics, ltp_info *ltp, bitfile *ld);
  95. #endif
  96. static uint8_t adts_fixed_header(adts_header *adts, bitfile *ld);
  97. static void adts_variable_header(adts_header *adts, bitfile *ld);
  98. static void adts_error_check(adts_header *adts, bitfile *ld);
  99. static uint8_t dynamic_range_info(bitfile *ld, drc_info *drc);
  100. static uint8_t excluded_channels(bitfile *ld, drc_info *drc);
  101. static uint8_t side_info(NeAACDecHandle hDecoder, element *ele,
  102.                          bitfile *ld, ic_stream *ics, uint8_t scal_flag);
  103. #ifdef DRM
  104. static int8_t DRM_aac_scalable_main_header(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
  105.                                            bitfile *ld, uint8_t this_layer_stereo);
  106. #endif
  109. /* Table 4.4.1 */
  110. int8_t GASpecificConfig(bitfile *ld, mp4AudioSpecificConfig *mp4ASC,
  111.                         program_config *pce_out)
  112. {
  113.     program_config pce;
  115.     /* 1024 or 960 */
  116.     mp4ASC->frameLengthFlag = faad_get1bit(ld
  117.         DEBUGVAR(1,138,"GASpecificConfig(): FrameLengthFlag"));
  118. #ifndef ALLOW_SMALL_FRAMELENGTH
  119.     if (mp4ASC->frameLengthFlag == 1)
  120.         return -3;
  121. #endif
  123.     mp4ASC->dependsOnCoreCoder = faad_get1bit(ld
  124.         DEBUGVAR(1,139,"GASpecificConfig(): DependsOnCoreCoder"));
  125.     if (mp4ASC->dependsOnCoreCoder == 1)
  126.     {
  127.         mp4ASC->coreCoderDelay = (uint16_t)faad_getbits(ld, 14
  128.             DEBUGVAR(1,140,"GASpecificConfig(): CoreCoderDelay"));
  129.     }
  131.     mp4ASC->extensionFlag = faad_get1bit(ld DEBUGVAR(1,141,"GASpecificConfig(): ExtensionFlag"));
  132.     if (mp4ASC->channelsConfiguration == 0)
  133.     {
  134.         if (program_config_element(&pce, ld))
  135.             return -3;
  136.         //mp4ASC->channelsConfiguration = pce.channels;
  138.         if (pce_out != NULL)
  139.             memcpy(pce_out, &pce, sizeof(program_config));
  141.         /*
  142.         if (pce.num_valid_cc_elements)
  143.             return -3;
  144.         */
  145.     }
  147. #ifdef ERROR_RESILIENCE
  148.     if (mp4ASC->extensionFlag == 1)
  149.     {
  150.         /* Error resilience not supported yet */
  151.         if (mp4ASC->objectTypeIndex >= ER_OBJECT_START)
  152.         {
  153.             mp4ASC->aacSectionDataResilienceFlag = faad_get1bit(ld
  154.                 DEBUGVAR(1,144,"GASpecificConfig(): aacSectionDataResilienceFlag"));
  155.             mp4ASC->aacScalefactorDataResilienceFlag = faad_get1bit(ld
  156.                 DEBUGVAR(1,145,"GASpecificConfig(): aacScalefactorDataResilienceFlag"));
  157.             mp4ASC->aacSpectralDataResilienceFlag = faad_get1bit(ld
  158.                 DEBUGVAR(1,146,"GASpecificConfig(): aacSpectralDataResilienceFlag"));
  160.             /* 1 bit: extensionFlag3 */
  161.         }
  162.     }
  163. #endif
  165.     return 0;
  166. }
  168. /* Table 4.4.2 */
  169. /* An MPEG-4 Audio decoder is only required to follow the Program
  170.    Configuration Element in GASpecificConfig(). The decoder shall ignore
  171.    any Program Configuration Elements that may occur in raw data blocks.
  172.    PCEs transmitted in raw data blocks cannot be used to convey decoder
  173.    configuration information.
  174. */
  175. static uint8_t program_config_element(program_config *pce, bitfile *ld)
  176. {
  177.     uint8_t i;
  179.     memset(pce, 0, sizeof(program_config));
  181.     pce->channels = 0;
  183.     pce->element_instance_tag = (uint8_t)faad_getbits(ld, 4
  184.         DEBUGVAR(1,10,"program_config_element(): element_instance_tag"));
  186.     pce->object_type = (uint8_t)faad_getbits(ld, 2
  187.         DEBUGVAR(1,11,"program_config_element(): object_type"));
  188.     pce->sf_index = (uint8_t)faad_getbits(ld, 4
  189.         DEBUGVAR(1,12,"program_config_element(): sf_index"));
  190.     pce->num_front_channel_elements = (uint8_t)faad_getbits(ld, 4
  191.         DEBUGVAR(1,13,"program_config_element(): num_front_channel_elements"));
  192.     pce->num_side_channel_elements = (uint8_t)faad_getbits(ld, 4
  193.         DEBUGVAR(1,14,"program_config_element(): num_side_channel_elements"));
  194.     pce->num_back_channel_elements = (uint8_t)faad_getbits(ld, 4
  195.         DEBUGVAR(1,15,"program_config_element(): num_back_channel_elements"));
  196.     pce->num_lfe_channel_elements = (uint8_t)faad_getbits(ld, 2
  197.         DEBUGVAR(1,16,"program_config_element(): num_lfe_channel_elements"));
  198.     pce->num_assoc_data_elements = (uint8_t)faad_getbits(ld, 3
  199.         DEBUGVAR(1,17,"program_config_element(): num_assoc_data_elements"));
  200.     pce->num_valid_cc_elements = (uint8_t)faad_getbits(ld, 4
  201.         DEBUGVAR(1,18,"program_config_element(): num_valid_cc_elements"));
  203.     pce->mono_mixdown_present = faad_get1bit(ld
  204.         DEBUGVAR(1,19,"program_config_element(): mono_mixdown_present"));
  205.     if (pce->mono_mixdown_present == 1)
  206.     {
  207.         pce->mono_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
  208.             DEBUGVAR(1,20,"program_config_element(): mono_mixdown_element_number"));
  209.     }
  211.     pce->stereo_mixdown_present = faad_get1bit(ld
  212.         DEBUGVAR(1,21,"program_config_element(): stereo_mixdown_present"));
  213.     if (pce->stereo_mixdown_present == 1)
  214.     {
  215.         pce->stereo_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
  216.             DEBUGVAR(1,22,"program_config_element(): stereo_mixdown_element_number"));
  217.     }
  219.     pce->matrix_mixdown_idx_present = faad_get1bit(ld
  220.         DEBUGVAR(1,23,"program_config_element(): matrix_mixdown_idx_present"));
  221.     if (pce->matrix_mixdown_idx_present == 1)
  222.     {
  223.         pce->matrix_mixdown_idx = (uint8_t)faad_getbits(ld, 2
  224.             DEBUGVAR(1,24,"program_config_element(): matrix_mixdown_idx"));
  225.         pce->pseudo_surround_enable = faad_get1bit(ld
  226.             DEBUGVAR(1,25,"program_config_element(): pseudo_surround_enable"));
  227.     }
  229.     for (i = 0; i < pce->num_front_channel_elements; i++)
  230.     {
  231.         pce->front_element_is_cpe[i] = faad_get1bit(ld
  232.             DEBUGVAR(1,26,"program_config_element(): front_element_is_cpe"));
  233.         pce->front_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  234.             DEBUGVAR(1,27,"program_config_element(): front_element_tag_select"));
  236.         if (pce->front_element_is_cpe[i] & 1)
  237.         {
  238.             pce->cpe_channel[pce->front_element_tag_select[i]] = pce->channels;
  239.             pce->num_front_channels += 2;
  240.             pce->channels += 2;
  241.         } else {
  242.             pce->sce_channel[pce->front_element_tag_select[i]] = pce->channels;
  243.             pce->num_front_channels++;
  244.             pce->channels++;
  245.         }
  246.     }
  248.     for (i = 0; i < pce->num_side_channel_elements; i++)
  249.     {
  250.         pce->side_element_is_cpe[i] = faad_get1bit(ld
  251.             DEBUGVAR(1,28,"program_config_element(): side_element_is_cpe"));
  252.         pce->side_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  253.             DEBUGVAR(1,29,"program_config_element(): side_element_tag_select"));
  255.         if (pce->side_element_is_cpe[i] & 1)
  256.         {
  257.             pce->cpe_channel[pce->side_element_tag_select[i]] = pce->channels;
  258.             pce->num_side_channels += 2;
  259.             pce->channels += 2;
  260.         } else {
  261.             pce->sce_channel[pce->side_element_tag_select[i]] = pce->channels;
  262.             pce->num_side_channels++;
  263.             pce->channels++;
  264.         }
  265.     }
  267.     for (i = 0; i < pce->num_back_channel_elements; i++)
  268.     {
  269.         pce->back_element_is_cpe[i] = faad_get1bit(ld
  270.             DEBUGVAR(1,30,"program_config_element(): back_element_is_cpe"));
  271.         pce->back_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  272.             DEBUGVAR(1,31,"program_config_element(): back_element_tag_select"));
  274.         if (pce->back_element_is_cpe[i] & 1)
  275.         {
  276.             pce->cpe_channel[pce->back_element_tag_select[i]] = pce->channels;
  277.             pce->channels += 2;
  278.             pce->num_back_channels += 2;
  279.         } else {
  280.             pce->sce_channel[pce->back_element_tag_select[i]] = pce->channels;
  281.             pce->num_back_channels++;
  282.             pce->channels++;
  283.         }
  284.     }
  286.     for (i = 0; i < pce->num_lfe_channel_elements; i++)
  287.     {
  288.         pce->lfe_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  289.             DEBUGVAR(1,32,"program_config_element(): lfe_element_tag_select"));
  291.         pce->sce_channel[pce->lfe_element_tag_select[i]] = pce->channels;
  292.         pce->num_lfe_channels++;
  293.         pce->channels++;
  294.     }
  296.     for (i = 0; i < pce->num_assoc_data_elements; i++)
  297.         pce->assoc_data_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  298.         DEBUGVAR(1,33,"program_config_element(): assoc_data_element_tag_select"));
  300.     for (i = 0; i < pce->num_valid_cc_elements; i++)
  301.     {
  302.         pce->cc_element_is_ind_sw[i] = faad_get1bit(ld
  303.             DEBUGVAR(1,34,"program_config_element(): cc_element_is_ind_sw"));
  304.         pce->valid_cc_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
  305.             DEBUGVAR(1,35,"program_config_element(): valid_cc_element_tag_select"));
  306.     }
  308.     faad_byte_align(ld);
  310.     pce->comment_field_bytes = (uint8_t)faad_getbits(ld, 8
  311.         DEBUGVAR(1,36,"program_config_element(): comment_field_bytes"));
  313.     for (i = 0; i < pce->comment_field_bytes; i++)
  314.     {
  315.         pce->comment_field_data[i] = (uint8_t)faad_getbits(ld, 8
  316.             DEBUGVAR(1,37,"program_config_element(): comment_field_data"));
  317.     }
  318.     pce->comment_field_data[i] = 0;
  320.     if (pce->channels > MAX_CHANNELS)
  321.         return 22;
  323.     return 0;
  324. }
  326. static void decode_sce_lfe(NeAACDecHandle hDecoder,
  327.                            NeAACDecFrameInfo *hInfo, bitfile *ld,
  328.                            uint8_t id_syn_ele)
  329. {
  330.     uint8_t channels = hDecoder->fr_channels;
  331.     uint8_t tag = 0;
  333.     if (channels+1 > MAX_CHANNELS)
  334.     {
  335.         hInfo->error = 12;
  336.         return;
  337.     }
  338.     if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
  339.     {
  340.         hInfo->error = 13;
  341.         return;
  342.     }
  344.     /* for SCE hDecoder->element_output_channels[] is not set here because this
  345.        can become 2 when some form of Parametric Stereo coding is used
  346.     */
  348.     /* save the syntax element id */
  349.     hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele;
  351.     /* decode the element */
  352.     hInfo->error = single_lfe_channel_element(hDecoder, ld, channels, &tag);
  354.     /* map output channels position to internal data channels */
  355.     if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2)
  356.     {
  357.         /* this might be faulty when pce_set is true */
  358.         hDecoder->internal_channel[channels] = channels;
  359.         hDecoder->internal_channel[channels+1] = channels+1;
  360.     } else {
  361.         if (hDecoder->pce_set)
  362.             hDecoder->internal_channel[hDecoder->pce.sce_channel[tag]] = channels;
  363.         else
  364.             hDecoder->internal_channel[channels] = channels;
  365.     }
  367.     hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele];
  368.     hDecoder->fr_ch_ele++;
  369. }
  371. static void decode_cpe(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo, bitfile *ld,
  372.                        uint8_t id_syn_ele)
  373. {
  374.     uint8_t channels = hDecoder->fr_channels;
  375.     uint8_t tag = 0;
  377.     if (channels+2 > MAX_CHANNELS)
  378.     {
  379.         hInfo->error = 12;
  380.         return;
  381.     }
  382.     if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
  383.     {
  384.         hInfo->error = 13;
  385.         return;
  386.     }
  388.     /* for CPE the number of output channels is always 2 */
  389.     if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
  390.     {
  391.         /* element_output_channels not set yet */
  392.         hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2;
  393.     } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != 2) {
  394.         /* element inconsistency */
  395.         hInfo->error = 21;
  396.         return;
  397.     }
  399.     /* save the syntax element id */
  400.     hDecoder->element_id[hDecoder->fr_ch_ele] = id_syn_ele;
  402.     /* decode the element */
  403.     hInfo->error = channel_pair_element(hDecoder, ld, channels, &tag);
  405.     /* map output channel position to internal data channels */
  406.     if (hDecoder->pce_set)
  407.     {
  408.         hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]] = channels;
  409.         hDecoder->internal_channel[hDecoder->pce.cpe_channel[tag]+1] = channels+1;
  410.     } else {
  411.         hDecoder->internal_channel[channels] = channels;
  412.         hDecoder->internal_channel[channels+1] = channels+1;
  413.     }
  415.     hDecoder->fr_channels += 2;
  416.     hDecoder->fr_ch_ele++;
  417. }
  419. void raw_data_block(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
  420.                     bitfile *ld, program_config *pce, drc_info *drc)
  421. {
  422.     uint8_t id_syn_ele;
  423.     uint8_t ele_this_frame = 0;
  425.     hDecoder->fr_channels = 0;
  426.     hDecoder->fr_ch_ele = 0;
  427.     hDecoder->first_syn_ele = 25;
  428.     hDecoder->has_lfe = 0;
  430. #ifdef ERROR_RESILIENCE
  431.     if (hDecoder->object_type < ER_OBJECT_START)
  432.     {
  433. #endif
  434.         /* Table 4.4.3: raw_data_block() */
  435.         while ((id_syn_ele = (uint8_t)faad_getbits(ld, LEN_SE_ID
  436.             DEBUGVAR(1,4,"NeAACDecDecode(): id_syn_ele"))) != ID_END)
  437.         {
  438.             switch (id_syn_ele) {
  439.             case ID_SCE:
  440.                 ele_this_frame++;
  441.                 if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
  442.                 decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele);
  443.                 if (hInfo->error > 0)
  444.                     return;
  445.                 break;
  446.             case ID_CPE:
  447.                 ele_this_frame++;
  448.                 if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
  449.                 decode_cpe(hDecoder, hInfo, ld, id_syn_ele);
  450.                 if (hInfo->error > 0)
  451.                     return;
  452.                 break;
  453.             case ID_LFE:
  454. #ifdef DRM
  455.                 hInfo->error = 32;
  456. #else
  457.                 ele_this_frame++;
  458.                 hDecoder->has_lfe++;
  459.                 decode_sce_lfe(hDecoder, hInfo, ld, id_syn_ele);
  460. #endif
  461.                 if (hInfo->error > 0)
  462.                     return;
  463.                 break;
  464.             case ID_CCE: /* not implemented yet, but skip the bits */
  465. #ifdef DRM
  466.                 hInfo->error = 32;
  467. #else
  468.                 ele_this_frame++;
  469. #ifdef COUPLING_DEC
  470.                 hInfo->error = coupling_channel_element(hDecoder, ld);
  471. #else
  472.                 hInfo->error = 6;
  473. #endif
  474. #endif
  475.                 if (hInfo->error > 0)
  476.                     return;
  477.                 break;
  478.             case ID_DSE:
  479.                 ele_this_frame++;
  480.                 data_stream_element(hDecoder, ld);
  481.                 break;
  482.             case ID_PCE:
  483.                 if (ele_this_frame != 0)
  484.                 {
  485.                     hInfo->error = 31;
  486.                     return;
  487.                 }
  488.                 ele_this_frame++;
  489.                 /* 14496-4: 5.6.4.1.2.1.3: */
  490.                 /* program_configuration_element()'s in access units shall be ignored */
  491.                 program_config_element(pce, ld);
  492.                 //if ((hInfo->error = program_config_element(pce, ld)) > 0)
  493.                 //    return;
  494.                 //hDecoder->pce_set = 1;
  495.                 break;
  496.             case ID_FIL:
  497.                 ele_this_frame++;
  498.                 /* one sbr_info describes a channel_element not a channel! */
  499.                 /* if we encounter SBR data here: error */
  500.                 /* SBR data will be read directly in the SCE/LFE/CPE element */
  501.                 if ((hInfo->error = fill_element(hDecoder, ld, drc
  502. #ifdef SBR_DEC
  503.                     , INVALID_SBR_ELEMENT
  504. #endif
  505.                     )) > 0)
  506.                     return;
  507.                 break;
  508.             }
  509.         }
  510. #ifdef ERROR_RESILIENCE
  511.     } else {
  512.         /* Table 262: er_raw_data_block() */
  513.         switch (hDecoder->channelConfiguration)
  514.         {
  515.         case 1:
  516.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  517.             if (hInfo->error > 0)
  518.                 return;
  519.             break;
  520.         case 2:
  521.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  522.             if (hInfo->error > 0)
  523.                 return;
  524.             break;
  525.         case 3:
  526.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  527.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  528.             if (hInfo->error > 0)
  529.                 return;
  530.             break;
  531.         case 4:
  532.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  533.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  534.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  535.             if (hInfo->error > 0)
  536.                 return;
  537.             break;
  538.         case 5:
  539.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  540.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  541.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  542.             if (hInfo->error > 0)
  543.                 return;
  544.             break;
  545.         case 6:
  546.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  547.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  548.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  549.             decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE);
  550.             if (hInfo->error > 0)
  551.                 return;
  552.             break;
  553.         case 7: /* 8 channels */
  554.             decode_sce_lfe(hDecoder, hInfo, ld, ID_SCE);
  555.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  556.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  557.             decode_cpe(hDecoder, hInfo, ld, ID_CPE);
  558.             decode_sce_lfe(hDecoder, hInfo, ld, ID_LFE);
  559.             if (hInfo->error > 0)
  560.                 return;
  561.             break;
  562.         default:
  563.             hInfo->error = 7;
  564.             return;
  565.         }
  566. #if 0
  567.         cnt = bits_to_decode() / 8;
  568.         while (cnt >= 1)
  569.         {
  570.             cnt -= extension_payload(cnt);
  571.         }
  572. #endif
  573.     }
  574. #endif
  576.     /* new in corrigendum 14496-3:2002 */
  577. #ifdef DRM
  578.     if (hDecoder->object_type != DRM_ER_LC)
  579. #endif
  580.     {
  581.         faad_byte_align(ld);
  582.     }
  584.     return;
  585. }
  587. /* Table 4.4.4 and */
  588. /* Table 4.4.9 */
  589. static uint8_t single_lfe_channel_element(NeAACDecHandle hDecoder, bitfile *ld,
  590.                                           uint8_t channel, uint8_t *tag)
  591. {
  592.     uint8_t retval = 0;
  593.     element sce = {0};
  594.     ic_stream *ics = &(sce.ics1);
  595.     ALIGN int16_t spec_data[1024] = {0};
  597.     sce.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
  598.         DEBUGVAR(1,38,"single_lfe_channel_element(): element_instance_tag"));
  600.     *tag = sce.element_instance_tag;
  601.     sce.channel = channel;
  602.     sce.paired_channel = -1;
  604.     retval = individual_channel_stream(hDecoder, &sce, ld, ics, 0, spec_data);
  605.     if (retval > 0)
  606.         return retval;
  608.     /* IS not allowed in single channel */
  609.     if (ics->is_used)
  610.         return 32;
  612. #ifdef SBR_DEC
  613.     /* check if next bitstream element is a fill element */
  614.     /* if so, read it now so SBR decoding can be done in case of a file with SBR */
  615.     if (faad_showbits(ld, LEN_SE_ID) == ID_FIL)
  616.     {
  617.         faad_flushbits(ld, LEN_SE_ID);
  619.         /* one sbr_info describes a channel_element not a channel! */
  620.         if ((retval = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0)
  621.         {
  622.             return retval;
  623.         }
  624.     }
  625. #endif
  627.     /* noiseless coding is done, spectral reconstruction is done now */
  628.     retval = reconstruct_single_channel(hDecoder, ics, &sce, spec_data);
  629.     if (retval > 0)
  630.         return retval;
  632.     return 0;
  633. }
  635. /* Table 4.4.5 */
  636. static uint8_t channel_pair_element(NeAACDecHandle hDecoder, bitfile *ld,
  637.                                     uint8_t channels, uint8_t *tag)
  638. {
  639.     ALIGN int16_t spec_data1[1024] = {0};
  640.     ALIGN int16_t spec_data2[1024] = {0};
  641.     element cpe = {0};
  642.     ic_stream *ics1 = &(cpe.ics1);
  643.     ic_stream *ics2 = &(cpe.ics2);
  644.     uint8_t result;
  646.     cpe.channel        = channels;
  647.     cpe.paired_channel = channels+1;
  649.     cpe.element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
  650.         DEBUGVAR(1,39,"channel_pair_element(): element_instance_tag"));
  651.     *tag = cpe.element_instance_tag;
  653.     if ((cpe.common_window = faad_get1bit(ld
  654.         DEBUGVAR(1,40,"channel_pair_element(): common_window"))) & 1)
  655.     {
  656.         /* both channels have common ics information */
  657.         if ((result = ics_info(hDecoder, ics1, ld, cpe.common_window)) > 0)
  658.             return result;
  660.         ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2
  661.             DEBUGVAR(1,41,"channel_pair_element(): ms_mask_present"));
  662.         if (ics1->ms_mask_present == 3)
  663.         {
  664.             /* bitstream error */
  665.             return 32;
  666.         }
  667.         if (ics1->ms_mask_present == 1)
  668.         {
  669.             uint8_t g, sfb;
  670.             for (g = 0; g < ics1->num_window_groups; g++)
  671.             {
  672.                 for (sfb = 0; sfb < ics1->max_sfb; sfb++)
  673.                 {
  674.                     ics1->ms_used[g][sfb] = faad_get1bit(ld
  675.                         DEBUGVAR(1,42,"channel_pair_element(): faad_get1bit"));
  676.                 }
  677.             }
  678.         }
  680. #ifdef ERROR_RESILIENCE
  681.         if ((hDecoder->object_type >= ER_OBJECT_START) && (ics1->predictor_data_present))
  682.         {
  683.             if ((
  684. #ifdef LTP_DEC
  685.                 ics1->ltp.data_present =
  686. #endif
  687.                 faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
  688.             {
  689. #ifdef LTP_DEC
  690.                 if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp), ld)) > 0)
  691.                 {
  692.                     return result;
  693.                 }
  694. #else
  695.                 return 26;
  696. #endif
  697.             }
  698.         }
  699. #endif
  701.         memcpy(ics2, ics1, sizeof(ic_stream));
  702.     } else {
  703.         ics1->ms_mask_present = 0;
  704.     }
  706.     if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics1,
  707.         0, spec_data1)) > 0)
  708.     {
  709.         return result;
  710.     }
  712. #ifdef ERROR_RESILIENCE
  713.     if (cpe.common_window && (hDecoder->object_type >= ER_OBJECT_START) &&
  714.         (ics1->predictor_data_present))
  715.     {
  716.         if ((
  717. #ifdef LTP_DEC
  718.             ics1->ltp2.data_present =
  719. #endif
  720.             faad_get1bit(ld DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
  721.         {
  722. #ifdef LTP_DEC
  723.             if ((result = ltp_data(hDecoder, ics1, &(ics1->ltp2), ld)) > 0)
  724.             {
  725.                 return result;
  726.             }
  727. #else
  728.             return 26;
  729. #endif
  730.         }
  731.     }
  732. #endif
  734.     if ((result = individual_channel_stream(hDecoder, &cpe, ld, ics2,
  735.         0, spec_data2)) > 0)
  736.     {
  737.         return result;
  738.     }
  740. #ifdef SBR_DEC
  741.     /* check if next bitstream element is a fill element */
  742.     /* if so, read it now so SBR decoding can be done in case of a file with SBR */
  743.     if (faad_showbits(ld, LEN_SE_ID) == ID_FIL)
  744.     {
  745.         faad_flushbits(ld, LEN_SE_ID);
  747.         /* one sbr_info describes a channel_element not a channel! */
  748.         if ((result = fill_element(hDecoder, ld, hDecoder->drc, hDecoder->fr_ch_ele)) > 0)
  749.         {
  750.             return result;
  751.         }
  752.     }
  753. #endif
  755.     /* noiseless coding is done, spectral reconstruction is done now */
  756.     if ((result = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe,
  757.         spec_data1, spec_data2)) > 0)
  758.     {
  759.         return result;
  760.     }
  762.     return 0;
  763. }
  765. /* Table 4.4.6 */
  766. static uint8_t ics_info(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
  767.                         uint8_t common_window)
  768. {
  769.     uint8_t retval = 0;
  770.     uint8_t ics_reserved_bit;
  772.     ics_reserved_bit = faad_get1bit(ld
  773.         DEBUGVAR(1,43,"ics_info(): ics_reserved_bit"));
  774.     if (ics_reserved_bit != 0)
  775.         return 32;
  776.     ics->window_sequence = (uint8_t)faad_getbits(ld, 2
  777.         DEBUGVAR(1,44,"ics_info(): window_sequence"));
  778.     ics->window_shape = faad_get1bit(ld
  779.         DEBUGVAR(1,45,"ics_info(): window_shape"));
  781. #ifdef LD_DEC
  782.     /* No block switching in LD */
  783.     if ((hDecoder->object_type == LD) && (ics->window_sequence != ONLY_LONG_SEQUENCE))
  784.         return 32;
  785. #endif
  787.     if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  788.     {
  789.         ics->max_sfb = (uint8_t)faad_getbits(ld, 4
  790.             DEBUGVAR(1,46,"ics_info(): max_sfb (short)"));
  791.         ics->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7
  792.             DEBUGVAR(1,47,"ics_info(): scale_factor_grouping"));
  793.     } else {
  794.         ics->max_sfb = (uint8_t)faad_getbits(ld, 6
  795.             DEBUGVAR(1,48,"ics_info(): max_sfb (long)"));
  796.     }
  798.     /* get the grouping information */
  799.     if ((retval = window_grouping_info(hDecoder, ics)) > 0)
  800.         return retval;
  803.     /* should be an error */
  804.     /* check the range of max_sfb */
  805.     if (ics->max_sfb > ics->num_swb)
  806.         return 16;
  808.     if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
  809.     {
  810.         if ((ics->predictor_data_present = faad_get1bit(ld
  811.             DEBUGVAR(1,49,"ics_info(): predictor_data_present"))) & 1)
  812.         {
  813.             if (hDecoder->object_type == MAIN) /* MPEG2 style AAC predictor */
  814.             {
  815.                 uint8_t sfb;
  817.                 uint8_t limit = min(ics->max_sfb, max_pred_sfb(hDecoder->sf_index));
  818. #ifdef MAIN_DEC
  819.                 ics->pred.limit = limit;
  820. #endif
  822.                 if ((
  823. #ifdef MAIN_DEC
  824.                     ics->pred.predictor_reset =
  825. #endif
  826.                     faad_get1bit(ld DEBUGVAR(1,53,"ics_info(): pred.predictor_reset"))) & 1)
  827.                 {
  828. #ifdef MAIN_DEC
  829.                     ics->pred.predictor_reset_group_number =
  830. #endif
  831.                         (uint8_t)faad_getbits(ld, 5 DEBUGVAR(1,54,"ics_info(): pred.predictor_reset_group_number"));
  832.                 }
  834.                 for (sfb = 0; sfb < limit; sfb++)
  835.                 {
  836. #ifdef MAIN_DEC
  837.                     ics->pred.prediction_used[sfb] =
  838. #endif
  839.                         faad_get1bit(ld DEBUGVAR(1,55,"ics_info(): pred.prediction_used"));
  840.                 }
  841.             }
  842. #ifdef LTP_DEC
  843.             else { /* Long Term Prediction */
  844.                 if (hDecoder->object_type < ER_OBJECT_START)
  845.                 {
  846.                     if ((ics->ltp.data_present = faad_get1bit(ld
  847.                         DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
  848.                     {
  849.                         if ((retval = ltp_data(hDecoder, ics, &(ics->ltp), ld)) > 0)
  850.                         {
  851.                             return retval;
  852.                         }
  853.                     }
  854.                     if (common_window)
  855.                     {
  856.                         if ((ics->ltp2.data_present = faad_get1bit(ld
  857.                             DEBUGVAR(1,51,"ics_info(): ltp2.data_present"))) & 1)
  858.                         {
  859.                             if ((retval = ltp_data(hDecoder, ics, &(ics->ltp2), ld)) > 0)
  860.                             {
  861.                                 return retval;
  862.                             }
  863.                         }
  864.                     }
  865.                 }
  866. #ifdef ERROR_RESILIENCE
  867.                 if (!common_window && (hDecoder->object_type >= ER_OBJECT_START))
  868.                 {
  869.                     if ((ics->ltp.data_present = faad_get1bit(ld
  870.                         DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
  871.                     {
  872.                         ltp_data(hDecoder, ics, &(ics->ltp), ld);
  873.                     }
  874.                 }
  875. #endif
  876.             }
  877. #endif
  878.         }
  879.     }
  881.     return retval;
  882. }
  884. /* Table 4.4.7 */
  885. static uint8_t pulse_data(ic_stream *ics, pulse_info *pul, bitfile *ld)
  886. {
  887.     uint8_t i;
  889.     pul->number_pulse = (uint8_t)faad_getbits(ld, 2
  890.         DEBUGVAR(1,56,"pulse_data(): number_pulse"));
  891.     pul->pulse_start_sfb = (uint8_t)faad_getbits(ld, 6
  892.         DEBUGVAR(1,57,"pulse_data(): pulse_start_sfb"));
  894.     /* check the range of pulse_start_sfb */
  895.     if (pul->pulse_start_sfb > ics->num_swb)
  896.         return 16;
  898.     for (i = 0; i < pul->number_pulse+1; i++)
  899.     {
  900.         pul->pulse_offset[i] = (uint8_t)faad_getbits(ld, 5
  901.             DEBUGVAR(1,58,"pulse_data(): pulse_offset"));
  902. #if 0
  903.         printf("%dn", pul->pulse_offset[i]);
  904. #endif
  905.         pul->pulse_amp[i] = (uint8_t)faad_getbits(ld, 4
  906.             DEBUGVAR(1,59,"pulse_data(): pulse_amp"));
  907. #if 0
  908.         printf("%dn", pul->pulse_amp[i]);
  909. #endif
  910.     }
  912.     return 0;
  913. }
  915. #ifdef COUPLING_DEC
  916. /* Table 4.4.8: Currently just for skipping the bits... */
  917. static uint8_t coupling_channel_element(NeAACDecHandle hDecoder, bitfile *ld)
  918. {
  919.     uint8_t c, result = 0;
  920.     uint8_t ind_sw_cce_flag = 0;
  921.     uint8_t num_gain_element_lists = 0;
  922.     uint8_t num_coupled_elements = 0;
  924.     element el_empty = {0};
  925.     ic_stream ics_empty = {0};
  926.     int16_t sh_data[1024];
  928.     c = faad_getbits(ld, LEN_TAG
  929.         DEBUGVAR(1,900,"coupling_channel_element(): element_instance_tag"));
  931.     ind_sw_cce_flag = faad_get1bit(ld
  932.         DEBUGVAR(1,901,"coupling_channel_element(): ind_sw_cce_flag"));
  933.     num_coupled_elements = faad_getbits(ld, 3
  934.         DEBUGVAR(1,902,"coupling_channel_element(): num_coupled_elements"));
  936.     for (c = 0; c < num_coupled_elements + 1; c++)
  937.     {
  938.         uint8_t cc_target_is_cpe, cc_target_tag_select;
  940.         num_gain_element_lists++;
  942.         cc_target_is_cpe = faad_get1bit(ld
  943.             DEBUGVAR(1,903,"coupling_channel_element(): cc_target_is_cpe"));
  944.         cc_target_tag_select = faad_getbits(ld, 4
  945.             DEBUGVAR(1,904,"coupling_channel_element(): cc_target_tag_select"));
  947.         if (cc_target_is_cpe)
  948.         {
  949.             uint8_t cc_l = faad_get1bit(ld
  950.                 DEBUGVAR(1,905,"coupling_channel_element(): cc_l"));
  951.             uint8_t cc_r = faad_get1bit(ld
  952.                 DEBUGVAR(1,906,"coupling_channel_element(): cc_r"));
  954.             if (cc_l && cc_r)
  955.                 num_gain_element_lists++;
  956.         }
  957.     }
  959.     faad_get1bit(ld
  960.         DEBUGVAR(1,907,"coupling_channel_element(): cc_domain"));
  961.     faad_get1bit(ld
  962.         DEBUGVAR(1,908,"coupling_channel_element(): gain_element_sign"));
  963.     faad_getbits(ld, 2
  964.         DEBUGVAR(1,909,"coupling_channel_element(): gain_element_scale"));
  966.     if ((result = individual_channel_stream(hDecoder, &el_empty, ld, &ics_empty,
  967.         0, sh_data)) > 0)
  968.     {
  969.         return result;
  970.     }
  972.     /* IS not allowed in single channel */
  973.     if (ics->is_used)
  974.         return 32;
  976.     for (c = 1; c < num_gain_element_lists; c++)
  977.     {
  978.         uint8_t cge;
  980.         if (ind_sw_cce_flag)
  981.         {
  982.             cge = 1;
  983.         } else {
  984.             cge = faad_get1bit(ld
  985.                 DEBUGVAR(1,910,"coupling_channel_element(): common_gain_element_present"));
  986.         }
  988.         if (cge)
  989.         {
  990.             huffman_scale_factor(ld);
  991.         } else {
  992.             uint8_t g, sfb;
  994.             for (g = 0; g < ics_empty.num_window_groups; g++)
  995.             {
  996.                 for (sfb = 0; sfb < ics_empty.max_sfb; sfb++)
  997.                 {
  998.                     if (ics_empty.sfb_cb[g][sfb] != ZERO_HCB)
  999.                         huffman_scale_factor(ld);
  1000.                 }
  1001.             }
  1002.         }
  1003.     }
  1005.     return 0;
  1006. }
  1007. #endif
  1009. /* Table 4.4.10 */
  1010. static uint16_t data_stream_element(NeAACDecHandle hDecoder, bitfile *ld)
  1011. {
  1012.     uint8_t byte_aligned;
  1013.     uint16_t i, count;
  1015.     /* element_instance_tag = */ faad_getbits(ld, LEN_TAG
  1016.         DEBUGVAR(1,60,"data_stream_element(): element_instance_tag"));
  1017.     byte_aligned = faad_get1bit(ld
  1018.         DEBUGVAR(1,61,"data_stream_element(): byte_aligned"));
  1019.     count = (uint16_t)faad_getbits(ld, 8
  1020.         DEBUGVAR(1,62,"data_stream_element(): count"));
  1021.     if (count == 255)
  1022.     {
  1023.         count += (uint16_t)faad_getbits(ld, 8
  1024.             DEBUGVAR(1,63,"data_stream_element(): extra count"));
  1025.     }
  1026.     if (byte_aligned)
  1027.         faad_byte_align(ld);
  1029.     for (i = 0; i < count; i++)
  1030.     {
  1031.         faad_getbits(ld, LEN_BYTE
  1032.             DEBUGVAR(1,64,"data_stream_element(): data_stream_byte"));
  1033.     }
  1035.     return count;
  1036. }
  1038. /* Table 4.4.11 */
  1039. static uint8_t fill_element(NeAACDecHandle hDecoder, bitfile *ld, drc_info *drc
  1040. #ifdef SBR_DEC
  1041.                             ,uint8_t sbr_ele
  1042. #endif
  1043.                             )
  1044. {
  1045.     uint16_t count;
  1046. #ifdef SBR_DEC
  1047.     uint8_t bs_extension_type;
  1048. #endif
  1050.     count = (uint16_t)faad_getbits(ld, 4
  1051.         DEBUGVAR(1,65,"fill_element(): count"));
  1052.     if (count == 15)
  1053.     {
  1054.         count += (uint16_t)faad_getbits(ld, 8
  1055.             DEBUGVAR(1,66,"fill_element(): extra count")) - 1;
  1056.     }
  1058.     if (count > 0)
  1059.     {
  1060. #ifdef SBR_DEC
  1061.         bs_extension_type = (uint8_t)faad_showbits(ld, 4);
  1063.         if ((bs_extension_type == EXT_SBR_DATA) ||
  1064.             (bs_extension_type == EXT_SBR_DATA_CRC))
  1065.         {
  1066.             if (sbr_ele == INVALID_SBR_ELEMENT)
  1067.                 return 24;
  1069.             if (!hDecoder->sbr[sbr_ele])
  1070.             {
  1071.                 hDecoder->sbr[sbr_ele] = sbrDecodeInit(hDecoder->frameLength,
  1072.                     hDecoder->element_id[sbr_ele], 2*get_sample_rate(hDecoder->sf_index),
  1073.                     hDecoder->downSampledSBR
  1074. #ifdef DRM
  1075.                     , 0
  1076. #endif
  1077.                     );
  1078.             }
  1080.             hDecoder->sbr_present_flag = 1;
  1082.             /* parse the SBR data */
  1083.             hDecoder->sbr[sbr_ele]->ret = sbr_extension_data(ld, hDecoder->sbr[sbr_ele], count);
  1085. #if 0
  1086.             if (hDecoder->sbr[sbr_ele]->ret > 0)
  1087.             {
  1088.                 printf("%sn", NeAACDecGetErrorMessage(hDecoder->sbr[sbr_ele]->ret));
  1089.             }
  1090. #endif
  1092. #if (defined(PS_DEC) || defined(DRM_PS))
  1093.             if (hDecoder->sbr[sbr_ele]->ps_used)
  1094.             {
  1095.                 hDecoder->ps_used[sbr_ele] = 1;
  1097.                 /* set element independent flag to 1 as well */
  1098.                 hDecoder->ps_used_global = 1;
  1099.             }
  1100. #endif
  1101.         } else {
  1102. #endif
  1103. #ifndef DRM
  1104.             while (count > 0)
  1105.             {
  1106.                 count -= extension_payload(ld, drc, count);
  1107.             }
  1108. #else
  1109.             return 30;
  1110. #endif
  1111. #ifdef SBR_DEC
  1112.         }
  1113. #endif
  1114.     }
  1116.     return 0;
  1117. }
  1119. /* Table 4.4.12 */
  1120. #ifdef SSR_DEC
  1121. static void gain_control_data(bitfile *ld, ic_stream *ics)
  1122. {
  1123.     uint8_t bd, wd, ad;
  1124.     ssr_info *ssr = &(ics->ssr);
  1126.     ssr->max_band = (uint8_t)faad_getbits(ld, 2
  1127.         DEBUGVAR(1,1000,"gain_control_data(): max_band"));
  1129.     if (ics->window_sequence == ONLY_LONG_SEQUENCE)
  1130.     {
  1131.         for (bd = 1; bd <= ssr->max_band; bd++)
  1132.         {
  1133.             for (wd = 0; wd < 1; wd++)
  1134.             {
  1135.                 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
  1136.                     DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
  1138.                 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
  1139.                 {
  1140.                     ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1141.                         DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
  1142.                     ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
  1143.                         DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1144.                 }
  1145.             }
  1146.         }
  1147.     } else if (ics->window_sequence == LONG_START_SEQUENCE) {
  1148.         for (bd = 1; bd <= ssr->max_band; bd++)
  1149.         {
  1150.             for (wd = 0; wd < 2; wd++)
  1151.             {
  1152.                 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
  1153.                     DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
  1155.                 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
  1156.                 {
  1157.                     ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1158.                         DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
  1159.                     if (wd == 0)
  1160.                     {
  1161.                         ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1162.                             DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1163.                     } else {
  1164.                         ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
  1165.                             DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1166.                     }
  1167.                 }
  1168.             }
  1169.         }
  1170.     } else if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) {
  1171.         for (bd = 1; bd <= ssr->max_band; bd++)
  1172.         {
  1173.             for (wd = 0; wd < 8; wd++)
  1174.             {
  1175.                 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
  1176.                     DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
  1178.                 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
  1179.                 {
  1180.                     ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1181.                         DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
  1182.                     ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
  1183.                         DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1184.                 }
  1185.             }
  1186.         }
  1187.     } else if (ics->window_sequence == LONG_STOP_SEQUENCE) {
  1188.         for (bd = 1; bd <= ssr->max_band; bd++)
  1189.         {
  1190.             for (wd = 0; wd < 2; wd++)
  1191.             {
  1192.                 ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
  1193.                     DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
  1195.                 for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
  1196.                 {
  1197.                     ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1198.                         DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
  1200.                     if (wd == 0)
  1201.                     {
  1202.                         ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
  1203.                             DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1204.                     } else {
  1205.                         ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
  1206.                             DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
  1207.                     }
  1208.                 }
  1209.             }
  1210.         }
  1211.     }
  1212. }
  1213. #endif
  1215. #ifdef DRM
  1216. /* Table 4.4.13 ASME */
  1217. void DRM_aac_scalable_main_element(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
  1218.                                    bitfile *ld, program_config *pce, drc_info *drc)
  1219. {
  1220.     uint8_t retval = 0;
  1221.     uint8_t channels = hDecoder->fr_channels = 0;
  1222.     uint8_t ch;
  1223.     uint8_t this_layer_stereo = (hDecoder->channelConfiguration > 1) ? 1 : 0;
  1224.     element cpe = {0};
  1225.     ic_stream *ics1 = &(cpe.ics1);
  1226.     ic_stream *ics2 = &(cpe.ics2);
  1227.     int16_t *spec_data;
  1228.     ALIGN int16_t spec_data1[1024] = {0};
  1229.     ALIGN int16_t spec_data2[1024] = {0};
  1231.     hDecoder->fr_ch_ele = 0;
  1233.     hInfo->error = DRM_aac_scalable_main_header(hDecoder, ics1, ics2, ld, this_layer_stereo);
  1234.     if (hInfo->error > 0)
  1235.         return;
  1237.     cpe.common_window = 1;
  1238.     if (this_layer_stereo)
  1239.     {
  1240.         hDecoder->element_id[0] = ID_CPE;
  1241.         if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
  1242.             hDecoder->element_output_channels[hDecoder->fr_ch_ele] = 2;
  1243.     } else {
  1244.         hDecoder->element_id[0] = ID_SCE;
  1245.     }
  1247.     if (this_layer_stereo)
  1248.     {
  1249.         cpe.channel        = 0;
  1250.         cpe.paired_channel = 1;
  1251.     }
  1254.     /* Stereo2 / Mono1 */
  1255.     ics1->tns_data_present = faad_get1bit(ld);
  1257. #if defined(LTP_DEC)
  1258.     ics1->ltp.data_present = faad_get1bit(ld);
  1259. #elif defined (DRM)
  1260.     if(faad_get1bit(ld)) {
  1261.          hInfo->error = 26;
  1262.          return;
  1263.     }
  1264. #else
  1265.     faad_get1bit(ld);
  1266. #endif    
  1268.     hInfo->error = side_info(hDecoder, &cpe, ld, ics1, 1);
  1269.     if (hInfo->error > 0)
  1270.         return;
  1271.     if (this_layer_stereo)
  1272.     {
  1273.         /* Stereo3 */
  1274.         ics2->tns_data_present = faad_get1bit(ld);
  1275. #ifdef LTP_DEC
  1276.         ics1->ltp.data_present =
  1277. #endif
  1278.             faad_get1bit(ld);
  1279.         hInfo->error = side_info(hDecoder, &cpe, ld, ics2, 1);
  1280.         if (hInfo->error > 0)
  1281.             return;
  1282.     }
  1283.     /* Stereo4 / Mono2 */
  1284.     if (ics1->tns_data_present)
  1285.         tns_data(ics1, &(ics1->tns), ld);
  1286.     if (this_layer_stereo)
  1287.     {
  1288.         /* Stereo5 */
  1289.         if (ics2->tns_data_present)
  1290.             tns_data(ics2, &(ics2->tns), ld);
  1291.     }
  1293. #ifdef DRM
  1294.     /* CRC check */
  1295.     if (hDecoder->object_type == DRM_ER_LC)
  1296.     {
  1297.         if ((hInfo->error = (uint8_t)faad_check_CRC(ld, (uint16_t)faad_get_processed_bits(ld) - 8)) > 0)
  1298.             return;
  1299.     }
  1300. #endif
  1302.     /* Stereo6 / Mono3 */
  1303.     /* error resilient spectral data decoding */
  1304.     if ((hInfo->error = reordered_spectral_data(hDecoder, ics1, ld, spec_data1)) > 0)
  1305.     {
  1306.         return;
  1307.     }
  1308.     if (this_layer_stereo)
  1309.     {
  1310.         /* Stereo7 */
  1311.         /* error resilient spectral data decoding */
  1312.         if ((hInfo->error = reordered_spectral_data(hDecoder, ics2, ld, spec_data2)) > 0)
  1313.         {
  1314.             return;
  1315.         }
  1316.     }
  1319. #ifdef DRM
  1320. #ifdef SBR_DEC
  1321.     /* In case of DRM we need to read the SBR info before channel reconstruction */
  1322.     if ((hDecoder->sbr_present_flag == 1) && (hDecoder->object_type == DRM_ER_LC))
  1323.     {
  1324.         bitfile ld_sbr = {0};
  1325.         uint32_t i;
  1326.         uint16_t count = 0;
  1327.         uint8_t *revbuffer;
  1328.         uint8_t *prevbufstart;
  1329.         uint8_t *pbufend;
  1331.         /* all forward bitreading should be finished at this point */
  1332.         uint32_t bitsconsumed = faad_get_processed_bits(ld);
  1333.         uint32_t buffer_size = faad_origbitbuffer_size(ld);
  1334.         uint8_t *buffer = (uint8_t*)faad_origbitbuffer(ld);
  1336.         if (bitsconsumed + 8 > buffer_size*8)
  1337.         {
  1338.             hInfo->error = 14;
  1339.             return;
  1340.         }
  1342.         if (!hDecoder->sbr[0])
  1343.         {
  1344.             hDecoder->sbr[0] = sbrDecodeInit(hDecoder->frameLength, hDecoder->element_id[0],
  1345.                 2*get_sample_rate(hDecoder->sf_index), 0 /* ds SBR */, 1);
  1346.         }
  1348.         /* Reverse bit reading of SBR data in DRM audio frame */
  1349.         revbuffer = (uint8_t*)faad_malloc(buffer_size*sizeof(uint8_t));
  1350.         prevbufstart = revbuffer;
  1351.         pbufend = &buffer[buffer_size - 1];
  1352.         for (i = 0; i < buffer_size; i++)
  1353.             *prevbufstart++ = tabFlipbits[*pbufend--];
  1355.         /* Set SBR data */
  1356.         /* consider 8 bits from AAC-CRC */
  1357.         /* SBR buffer size is original buffer size minus AAC buffer size */
  1358.         count = (uint16_t)bit2byte(buffer_size*8 - bitsconsumed);
  1359.         faad_initbits(&ld_sbr, revbuffer, count);
  1361.         hDecoder->sbr[0]->sample_rate = get_sample_rate(hDecoder->sf_index);
  1362.         hDecoder->sbr[0]->sample_rate *= 2;
  1364.         faad_getbits(&ld_sbr, 8); /* Skip 8-bit CRC */
  1366.         hDecoder->sbr[0]->ret = sbr_extension_data(&ld_sbr, hDecoder->sbr[0], count);
  1367. #if (defined(PS_DEC) || defined(DRM_PS))
  1368.         if (hDecoder->sbr[0]->ps_used)
  1369.         {
  1370.             hDecoder->ps_used[0] = 1;
  1371.             hDecoder->ps_used_global = 1;
  1372.         }
  1373. #endif
  1375.         if (ld_sbr.error)
  1376.         {
  1377.             hDecoder->sbr[0]->ret = 1;
  1378.         }
  1380.         /* check CRC */
  1381.         /* no need to check it if there was already an error */
  1382.         if (hDecoder->sbr[0]->ret == 0)
  1383.             hDecoder->sbr[0]->ret = (uint8_t)faad_check_CRC(&ld_sbr, (uint16_t)faad_get_processed_bits(&ld_sbr) - 8);
  1385.         /* SBR data was corrupted, disable it until the next header */
  1386.         if (hDecoder->sbr[0]->ret != 0)
  1387.         {
  1388.             hDecoder->sbr[0]->header_count = 0;
  1389.         }
  1391.         faad_endbits(&ld_sbr);
  1393.         if (revbuffer)
  1394.             faad_free(revbuffer);
  1395.     }
  1396. #endif
  1397. #endif
  1399.     if (this_layer_stereo)
  1400.     {
  1401.         hInfo->error = reconstruct_channel_pair(hDecoder, ics1, ics2, &cpe, spec_data1, spec_data2);
  1402.         if (hInfo->error > 0)
  1403.             return;
  1404.     } else {
  1405.         hInfo->error = reconstruct_single_channel(hDecoder, ics1, &cpe, spec_data1);
  1406.         if (hInfo->error > 0)
  1407.             return;
  1408.     }
  1410.     /* map output channels position to internal data channels */
  1411.     if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2)
  1412.     {
  1413.         /* this might be faulty when pce_set is true */
  1414.         hDecoder->internal_channel[channels] = channels;
  1415.         hDecoder->internal_channel[channels+1] = channels+1;
  1416.     } else {
  1417.         hDecoder->internal_channel[channels] = channels;
  1418.     }
  1420.     hDecoder->fr_channels += hDecoder->element_output_channels[hDecoder->fr_ch_ele];
  1421.     hDecoder->fr_ch_ele++;
  1423.     return;
  1424. }
  1426. /* Table 4.4.15 */
  1427. static int8_t DRM_aac_scalable_main_header(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
  1428.                                            bitfile *ld, uint8_t this_layer_stereo)
  1429. {
  1430.     uint8_t retval = 0;
  1431.     uint8_t ch;
  1432.     ic_stream *ics;
  1433.     uint8_t ics_reserved_bit;
  1435.     ics_reserved_bit = faad_get1bit(ld
  1436.         DEBUGVAR(1,300,"aac_scalable_main_header(): ics_reserved_bits"));
  1437.     if (ics_reserved_bit != 0)
  1438.         return 32;
  1439.     ics1->window_sequence = (uint8_t)faad_getbits(ld, 2
  1440.         DEBUGVAR(1,301,"aac_scalable_main_header(): window_sequence"));
  1441.     ics1->window_shape = faad_get1bit(ld
  1442.         DEBUGVAR(1,302,"aac_scalable_main_header(): window_shape"));
  1444.     if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE)
  1445.     {
  1446.         ics1->max_sfb = (uint8_t)faad_getbits(ld, 4
  1447.             DEBUGVAR(1,303,"aac_scalable_main_header(): max_sfb (short)"));
  1448.         ics1->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7
  1449.             DEBUGVAR(1,304,"aac_scalable_main_header(): scale_factor_grouping"));
  1450.     } else {
  1451.         ics1->max_sfb = (uint8_t)faad_getbits(ld, 6
  1452.             DEBUGVAR(1,305,"aac_scalable_main_header(): max_sfb (long)"));
  1453.     }
  1455.     /* get the grouping information */
  1456.     if ((retval = window_grouping_info(hDecoder, ics1)) > 0)
  1457.         return retval;
  1459.     /* should be an error */
  1460.     /* check the range of max_sfb */
  1461.     if (ics1->max_sfb > ics1->num_swb)
  1462.         return 16;
  1464.     if (this_layer_stereo)
  1465.     {
  1466.         ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2
  1467.             DEBUGVAR(1,306,"aac_scalable_main_header(): ms_mask_present"));
  1468.         if (ics1->ms_mask_present == 3)
  1469.         {
  1470.             /* bitstream error */
  1471.             return 32;
  1472.         }
  1473.         if (ics1->ms_mask_present == 1)
  1474.         {
  1475.             uint8_t g, sfb;
  1476.             for (g = 0; g < ics1->num_window_groups; g++)
  1477.             {
  1478.                 for (sfb = 0; sfb < ics1->max_sfb; sfb++)
  1479.                 {
  1480.                     ics1->ms_used[g][sfb] = faad_get1bit(ld
  1481.                         DEBUGVAR(1,307,"aac_scalable_main_header(): faad_get1bit"));
  1482.                 }
  1483.             }
  1484.         }
  1486.         memcpy(ics2, ics1, sizeof(ic_stream));
  1487.     } else {
  1488.         ics1->ms_mask_present = 0;
  1489.     }
  1491.     return 0;
  1492. }
  1493. #endif
  1495. static uint8_t side_info(NeAACDecHandle hDecoder, element *ele,
  1496.                          bitfile *ld, ic_stream *ics, uint8_t scal_flag)
  1497. {
  1498.     uint8_t result;
  1500.     ics->global_gain = (uint8_t)faad_getbits(ld, 8
  1501.         DEBUGVAR(1,67,"individual_channel_stream(): global_gain"));
  1503.     if (!ele->common_window && !scal_flag)
  1504.     {
  1505.         if ((result = ics_info(hDecoder, ics, ld, ele->common_window)) > 0)
  1506.             return result;
  1507.     }
  1509.     if ((result = section_data(hDecoder, ics, ld)) > 0)
  1510.         return result;
  1512.     if ((result = scale_factor_data(hDecoder, ics, ld)) > 0)
  1513.         return result;
  1515.     if (!scal_flag)
  1516.     {
  1517.         /**
  1518.          **  NOTE: It could be that pulse data is available in scalable AAC too,
  1519.          **        as said in Amendment 1, this could be only the case for ER AAC,
  1520.          **        though. (have to check this out later)
  1521.          **/
  1522.         /* get pulse data */
  1523.         if ((ics->pulse_data_present = faad_get1bit(ld
  1524.             DEBUGVAR(1,68,"individual_channel_stream(): pulse_data_present"))) & 1)
  1525.         {
  1526.             if ((result = pulse_data(ics, &(ics->pul), ld)) > 0)
  1527.                 return result;
  1528.         }
  1530.         /* get tns data */
  1531.         if ((ics->tns_data_present = faad_get1bit(ld
  1532.             DEBUGVAR(1,69,"individual_channel_stream(): tns_data_present"))) & 1)
  1533.         {
  1534. #ifdef ERROR_RESILIENCE
  1535.             if (hDecoder->object_type < ER_OBJECT_START)
  1536. #endif
  1537.                 tns_data(ics, &(ics->tns), ld);
  1538.         }
  1540.         /* get gain control data */
  1541.         if ((ics->gain_control_data_present = faad_get1bit(ld
  1542.             DEBUGVAR(1,70,"individual_channel_stream(): gain_control_data_present"))) & 1)
  1543.         {
  1544. #ifdef SSR_DEC
  1545.             if (hDecoder->object_type != SSR)
  1546.                 return 1;
  1547.             else
  1548.                 gain_control_data(ld, ics);
  1549. #else
  1550.             return 1;
  1551. #endif
  1552.         }
  1553.     }
  1555. #ifdef ERROR_RESILIENCE
  1556.     if (hDecoder->aacSpectralDataResilienceFlag)
  1557.     {
  1558.         ics->length_of_reordered_spectral_data = (uint16_t)faad_getbits(ld, 14
  1559.             DEBUGVAR(1,147,"individual_channel_stream(): length_of_reordered_spectral_data"));
  1561.         if (hDecoder->channelConfiguration == 2)
  1562.         {
  1563.             if (ics->length_of_reordered_spectral_data > 6144)
  1564.                 ics->length_of_reordered_spectral_data = 6144;
  1565.         } else {
  1566.             if (ics->length_of_reordered_spectral_data > 12288)
  1567.                 ics->length_of_reordered_spectral_data = 12288;
  1568.         }
  1570.         ics->length_of_longest_codeword = (uint8_t)faad_getbits(ld, 6
  1571.             DEBUGVAR(1,148,"individual_channel_stream(): length_of_longest_codeword"));
  1572.         if (ics->length_of_longest_codeword >= 49)
  1573.             ics->length_of_longest_codeword = 49;
  1574.     }
  1576.     /* RVLC spectral data is put here */
  1577.     if (hDecoder->aacScalefactorDataResilienceFlag)
  1578.     {
  1579.         if ((result = rvlc_decode_scale_factors(ics, ld)) > 0)
  1580.             return result;
  1581.     }
  1582. #endif
  1584.     return 0;
  1585. }
  1587. /* Table 4.4.24 */
  1588. static uint8_t individual_channel_stream(NeAACDecHandle hDecoder, element *ele,
  1589.                                          bitfile *ld, ic_stream *ics, uint8_t scal_flag,
  1590.                                          int16_t *spec_data)
  1591. {
  1592.     uint8_t result;
  1594.     result = side_info(hDecoder, ele, ld, ics, scal_flag);
  1595.     if (result > 0)
  1596.         return result;
  1598.     if (hDecoder->object_type >= ER_OBJECT_START) 
  1599.     {
  1600.         if (ics->tns_data_present)
  1601.             tns_data(ics, &(ics->tns), ld);
  1602.     }
  1604. #ifdef DRM
  1605.     /* CRC check */
  1606.     if (hDecoder->object_type == DRM_ER_LC)
  1607.     {
  1608.         if ((result = (uint8_t)faad_check_CRC(ld, (uint16_t)faad_get_processed_bits(ld) - 8)) > 0)
  1609.             return result;
  1610.     }
  1611. #endif
  1613. #ifdef ERROR_RESILIENCE
  1614.     if (hDecoder->aacSpectralDataResilienceFlag)
  1615.     {
  1616.         /* error resilient spectral data decoding */
  1617.         if ((result = reordered_spectral_data(hDecoder, ics, ld, spec_data)) > 0)
  1618.         {
  1619.             return result;
  1620.         }
  1621.     } else {
  1622. #endif
  1623.         /* decode the spectral data */
  1624.         if ((result = spectral_data(hDecoder, ics, ld, spec_data)) > 0)
  1625.         {
  1626.             return result;
  1627.         }
  1628. #ifdef ERROR_RESILIENCE
  1629.     }
  1630. #endif
  1632.     /* pulse coding reconstruction */
  1633.     if (ics->pulse_data_present)
  1634.     {
  1635.         if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
  1636.         {
  1637.             if ((result = pulse_decode(ics, spec_data, hDecoder->frameLength)) > 0)
  1638.                 return result;
  1639.         } else {
  1640.             return 2; /* pulse coding not allowed for short blocks */
  1641.         }
  1642.     }
  1644.     return 0;
  1645. }
  1647. /* Table 4.4.25 */
  1648. static uint8_t section_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld)
  1649. {
  1650.     uint8_t g;
  1651.     uint8_t sect_esc_val, sect_bits;
  1653.     if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  1654.         sect_bits = 3;
  1655.     else
  1656.         sect_bits = 5;
  1657.     sect_esc_val = (1<<sect_bits) - 1;
  1659. #if 0
  1660.     printf("ntotal sfb %dn", ics->max_sfb);
  1661.     printf("   sect    top     cbn");
  1662. #endif
  1664.     for (g = 0; g < ics->num_window_groups; g++)
  1665.     {
  1666.         uint8_t k = 0;
  1667.         uint8_t i = 0;
  1669.         while (k < ics->max_sfb)
  1670.         {
  1671. #ifdef ERROR_RESILIENCE
  1672.             uint8_t vcb11 = 0;
  1673. #endif
  1674.             uint8_t sfb;
  1675.             uint8_t sect_len_incr;
  1676.             uint16_t sect_len = 0;
  1677.             uint8_t sect_cb_bits = 4;
  1679.             /* if "faad_getbits" detects error and returns "0", "k" is never
  1680.                incremented and we cannot leave the while loop */
  1681.             if ((ld->error != 0) || (ld->no_more_reading))
  1682.                 return 14;
  1684. #ifdef ERROR_RESILIENCE
  1685.             if (hDecoder->aacSectionDataResilienceFlag)
  1686.                 sect_cb_bits = 5;
  1687. #endif
  1689.             ics->sect_cb[g][i] = (uint8_t)faad_getbits(ld, sect_cb_bits
  1690.                 DEBUGVAR(1,71,"section_data(): sect_cb"));
  1692.             if (ics->sect_cb[g][i] == 12)
  1693.                 return 32;
  1695. #if 0
  1696.             printf("%dn", ics->sect_cb[g][i]);
  1697. #endif
  1699. #ifndef DRM
  1700.             if (ics->sect_cb[g][i] == NOISE_HCB)
  1701.                 ics->noise_used = 1;
  1702. #else
  1703.             /* PNS not allowed in DRM */
  1704.             if (ics->sect_cb[g][i] == NOISE_HCB)
  1705.                 return 29;
  1706. #endif
  1707.             if (ics->sect_cb[g][i] == INTENSITY_HCB2 || ics->sect_cb[g][i] == INTENSITY_HCB)
  1708.                 ics->is_used = 1;
  1710. #ifdef ERROR_RESILIENCE
  1711.             if (hDecoder->aacSectionDataResilienceFlag)
  1712.             {
  1713.                 if ((ics->sect_cb[g][i] == 11) ||
  1714.                     ((ics->sect_cb[g][i] >= 16) && (ics->sect_cb[g][i] <= 32)))
  1715.                 {
  1716.                     vcb11 = 1;
  1717.                 }
  1718.             }
  1719.             if (vcb11)
  1720.             {
  1721.                 sect_len_incr = 1;
  1722.             } else {
  1723. #endif
  1724.                 sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
  1725.                     DEBUGVAR(1,72,"section_data(): sect_len_incr"));
  1726. #ifdef ERROR_RESILIENCE
  1727.             }
  1728. #endif
  1729.             while ((sect_len_incr == sect_esc_val) /* &&
  1730.                 (k+sect_len < ics->max_sfb)*/)
  1731.             {
  1732.                 sect_len += sect_len_incr;
  1733.                 sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
  1734.                     DEBUGVAR(1,72,"section_data(): sect_len_incr"));
  1735.             }
  1737.             sect_len += sect_len_incr;
  1739.             ics->sect_start[g][i] = k;
  1740.             ics->sect_end[g][i] = k + sect_len;
  1742. #if 0
  1743.             printf("%dn", ics->sect_start[g][i]);
  1744. #endif
  1745. #if 0
  1746.             printf("%dn", ics->sect_end[g][i]);
  1747. #endif
  1749.             if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  1750.             {
  1751.                 if (k + sect_len >= 8*15)
  1752.                     return 15;
  1753.                 if (i >= 8*15)
  1754.                     return 15;
  1755.             } else {
  1756.                 if (k + sect_len >= MAX_SFB)
  1757.                     return 15;
  1758.                 if (i >= MAX_SFB)
  1759.                     return 15;
  1760.             }
  1762.             for (sfb = k; sfb < k + sect_len; sfb++)
  1763.             {
  1764.                 ics->sfb_cb[g][sfb] = ics->sect_cb[g][i];
  1765. #if 0
  1766.                 printf("%dn", ics->sfb_cb[g][sfb]);
  1767. #endif
  1768.             }
  1770. #if 0
  1771.             printf(" %6d %6d %6dn",
  1772.                 i,
  1773.                 ics->sect_end[g][i],
  1774.                 ics->sect_cb[g][i]);
  1775. #endif
  1777.             k += sect_len;
  1778.             i++;
  1779.         }
  1780.         ics->num_sec[g] = i;
  1782.         /* the sum of all sect_len_incr elements for a given window
  1783.          * group shall equal max_sfb */
  1784.         if (k != ics->max_sfb)
  1785.         {
  1786.             return 32;
  1787.         }
  1788. #if 0
  1789.         printf("%dn", ics->num_sec[g]);
  1790. #endif
  1791.     }
  1793. #if 0
  1794.     printf("n");
  1795. #endif
  1797.     return 0;
  1798. }
  1800. /*
  1801.  *  decode_scale_factors()
  1802.  *   decodes the scalefactors from the bitstream
  1803.  */
  1804. /*
  1805.  * All scalefactors (and also the stereo positions and pns energies) are
  1806.  * transmitted using Huffman coded DPCM relative to the previous active
  1807.  * scalefactor (respectively previous stereo position or previous pns energy,
  1808.  * see subclause 4.6.2 and 4.6.3). The first active scalefactor is
  1809.  * differentially coded relative to the global gain.
  1810.  */
  1811. static uint8_t decode_scale_factors(ic_stream *ics, bitfile *ld)
  1812. {
  1813.     uint8_t g, sfb;
  1814.     int16_t t;
  1815.     int8_t noise_pcm_flag = 1;
  1817.     int16_t scale_factor = ics->global_gain;
  1818.     int16_t is_position = 0;
  1819.     int16_t noise_energy = ics->global_gain - 90;
  1821.     for (g = 0; g < ics->num_window_groups; g++)
  1822.     {
  1823.         for (sfb = 0; sfb < ics->max_sfb; sfb++)
  1824.         {
  1825.             switch (ics->sfb_cb[g][sfb])
  1826.             {
  1827.             case ZERO_HCB: /* zero book */
  1828.                 ics->scale_factors[g][sfb] = 0;
  1829. //#define SF_PRINT
  1830. #ifdef SF_PRINT
  1831.                 printf("%dn", ics->scale_factors[g][sfb]);
  1832. #endif
  1833.                 break;
  1834.             case INTENSITY_HCB: /* intensity books */
  1835.             case INTENSITY_HCB2:
  1837.                 /* decode intensity position */
  1838.                 t = huffman_scale_factor(ld);
  1839.                 is_position += (t - 60);
  1840.                 ics->scale_factors[g][sfb] = is_position;
  1841. #ifdef SF_PRINT
  1842.                 printf("%dn", ics->scale_factors[g][sfb]);
  1843. #endif
  1845.                 break;
  1846.             case NOISE_HCB: /* noise books */
  1848. #ifndef DRM
  1849.                 /* decode noise energy */
  1850.                 if (noise_pcm_flag)
  1851.                 {
  1852.                     noise_pcm_flag = 0;
  1853.                     t = (int16_t)faad_getbits(ld, 9
  1854.                         DEBUGVAR(1,73,"scale_factor_data(): first noise")) - 256;
  1855.                 } else {
  1856.                     t = huffman_scale_factor(ld);
  1857.                     t -= 60;
  1858.                 }
  1859.                 noise_energy += t;
  1860.                 ics->scale_factors[g][sfb] = noise_energy;
  1861. #ifdef SF_PRINT
  1862.                 printf("%dn", ics->scale_factors[g][sfb]);
  1863. #endif
  1864. #else
  1865.                 /* PNS not allowed in DRM */
  1866.                 return 29;
  1867. #endif
  1869.                 break;
  1870.             default: /* spectral books */
  1872.                 /* ics->scale_factors[g][sfb] must be between 0 and 255 */
  1874.                 ics->scale_factors[g][sfb] = 0;
  1876.                 /* decode scale factor */
  1877.                 t = huffman_scale_factor(ld);
  1878.                 scale_factor += (t - 60);
  1879.                 if (scale_factor < 0 || scale_factor > 255)
  1880.                     return 4;
  1881.                 ics->scale_factors[g][sfb] = scale_factor;
  1882. #ifdef SF_PRINT
  1883.                 printf("%dn", ics->scale_factors[g][sfb]);
  1884. #endif
  1886.                 break;
  1887.             }
  1888.         }
  1889.     }
  1891.     return 0;
  1892. }
  1894. /* Table 4.4.26 */
  1895. static uint8_t scale_factor_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld)
  1896. {
  1897.     uint8_t ret = 0;
  1898. #ifdef PROFILE
  1899.     int64_t count = faad_get_ts();
  1900. #endif
  1902. #ifdef ERROR_RESILIENCE
  1903.     if (!hDecoder->aacScalefactorDataResilienceFlag)
  1904.     {
  1905. #endif
  1906.         ret = decode_scale_factors(ics, ld);
  1907. #ifdef ERROR_RESILIENCE
  1908.     } else {
  1909.         /* In ER AAC the parameters for RVLC are seperated from the actual
  1910.            data that holds the scale_factors.
  1911.            Strangely enough, 2 parameters for HCR are put inbetween them.
  1912.         */
  1913.         ret = rvlc_scale_factor_data(ics, ld);
  1914.     }
  1915. #endif
  1917. #ifdef PROFILE
  1918.     count = faad_get_ts() - count;
  1919.     hDecoder->scalefac_cycles += count;
  1920. #endif
  1922.     return ret;
  1923. }
  1925. /* Table 4.4.27 */
  1926. static void tns_data(ic_stream *ics, tns_info *tns, bitfile *ld)
  1927. {
  1928.     uint8_t w, filt, i, start_coef_bits, coef_bits;
  1929.     uint8_t n_filt_bits = 2;
  1930.     uint8_t length_bits = 6;
  1931.     uint8_t order_bits = 5;
  1933.     if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  1934.     {
  1935.         n_filt_bits = 1;
  1936.         length_bits = 4;
  1937.         order_bits = 3;
  1938.     }
  1940.     for (w = 0; w < ics->num_windows; w++)
  1941.     {
  1942.         tns->n_filt[w] = (uint8_t)faad_getbits(ld, n_filt_bits
  1943.             DEBUGVAR(1,74,"tns_data(): n_filt"));
  1944. #if 0
  1945.         printf("%dn", tns->n_filt[w]);
  1946. #endif
  1948.         if (tns->n_filt[w])
  1949.         {
  1950.             if ((tns->coef_res[w] = faad_get1bit(ld
  1951.                 DEBUGVAR(1,75,"tns_data(): coef_res"))) & 1)
  1952.             {
  1953.                 start_coef_bits = 4;
  1954.             } else {
  1955.                 start_coef_bits = 3;
  1956.             }
  1957. #if 0
  1958.             printf("%dn", tns->coef_res[w]);
  1959. #endif
  1960.         }
  1962.         for (filt = 0; filt < tns->n_filt[w]; filt++)
  1963.         {
  1964.             tns->length[w][filt] = (uint8_t)faad_getbits(ld, length_bits
  1965.                 DEBUGVAR(1,76,"tns_data(): length"));
  1966. #if 0
  1967.             printf("%dn", tns->length[w][filt]);
  1968. #endif
  1969.             tns->order[w][filt]  = (uint8_t)faad_getbits(ld, order_bits
  1970.                 DEBUGVAR(1,77,"tns_data(): order"));
  1971. #if 0
  1972.             printf("%dn", tns->order[w][filt]);
  1973. #endif
  1974.             if (tns->order[w][filt])
  1975.             {
  1976.                 tns->direction[w][filt] = faad_get1bit(ld
  1977.                     DEBUGVAR(1,78,"tns_data(): direction"));
  1978. #if 0
  1979.                 printf("%dn", tns->direction[w][filt]);
  1980. #endif
  1981.                 tns->coef_compress[w][filt] = faad_get1bit(ld
  1982.                     DEBUGVAR(1,79,"tns_data(): coef_compress"));
  1983. #if 0
  1984.                 printf("%dn", tns->coef_compress[w][filt]);
  1985. #endif
  1987.                 coef_bits = start_coef_bits - tns->coef_compress[w][filt];
  1988.                 for (i = 0; i < tns->order[w][filt]; i++)
  1989.                 {
  1990.                     tns->coef[w][filt][i] = (uint8_t)faad_getbits(ld, coef_bits
  1991.                         DEBUGVAR(1,80,"tns_data(): coef"));
  1992. #if 0
  1993.                     printf("%dn", tns->coef[w][filt][i]);
  1994. #endif
  1995.                 }
  1996.             }
  1997.         }
  1998.     }
  1999. }
  2001. #ifdef LTP_DEC
  2002. /* Table 4.4.28 */
  2003. static uint8_t ltp_data(NeAACDecHandle hDecoder, ic_stream *ics, ltp_info *ltp, bitfile *ld)
  2004. {
  2005.     uint8_t sfb, w;
  2007.     ltp->lag = 0;
  2009. #ifdef LD_DEC
  2010.     if (hDecoder->object_type == LD)
  2011.     {
  2012.         ltp->lag_update = (uint8_t)faad_getbits(ld, 1
  2013.             DEBUGVAR(1,142,"ltp_data(): lag_update"));
  2015.         if (ltp->lag_update)
  2016.         {
  2017.             ltp->lag = (uint16_t)faad_getbits(ld, 10
  2018.                 DEBUGVAR(1,81,"ltp_data(): lag"));
  2019.         }
  2020.     } else {
  2021. #endif
  2022.         ltp->lag = (uint16_t)faad_getbits(ld, 11
  2023.             DEBUGVAR(1,81,"ltp_data(): lag"));
  2024. #ifdef LD_DEC
  2025.     }
  2026. #endif
  2028.     /* Check length of lag */
  2029.     if (ltp->lag > (hDecoder->frameLength << 1))
  2030.         return 18;
  2032.     ltp->coef = (uint8_t)faad_getbits(ld, 3
  2033.         DEBUGVAR(1,82,"ltp_data(): coef"));
  2035.     if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  2036.     {
  2037.         for (w = 0; w < ics->num_windows; w++)
  2038.         {
  2039.             if ((ltp->short_used[w] = faad_get1bit(ld
  2040.                 DEBUGVAR(1,83,"ltp_data(): short_used"))) & 1)
  2041.             {
  2042.                 ltp->short_lag_present[w] = faad_get1bit(ld
  2043.                     DEBUGVAR(1,84,"ltp_data(): short_lag_present"));
  2044.                 if (ltp->short_lag_present[w])
  2045.                 {
  2046.                     ltp->short_lag[w] = (uint8_t)faad_getbits(ld, 4
  2047.                         DEBUGVAR(1,85,"ltp_data(): short_lag"));
  2048.                 }
  2049.             }
  2050.         }
  2051.     } else {
  2052.         ltp->last_band = (ics->max_sfb < MAX_LTP_SFB ? ics->max_sfb : MAX_LTP_SFB);
  2054.         for (sfb = 0; sfb < ltp->last_band; sfb++)
  2055.         {
  2056.             ltp->long_used[sfb] = faad_get1bit(ld
  2057.                 DEBUGVAR(1,86,"ltp_data(): long_used"));
  2058.         }
  2059.     }
  2061.     return 0;
  2062. }
  2063. #endif
  2065. /* Table 4.4.29 */
  2066. static uint8_t spectral_data(NeAACDecHandle hDecoder, ic_stream *ics, bitfile *ld,
  2067.                              int16_t *spectral_data)
  2068. {
  2069.     int8_t i;
  2070.     uint8_t g;
  2071.     uint16_t inc, k, p = 0;
  2072.     uint8_t groups = 0;
  2073.     uint8_t sect_cb;
  2074.     uint8_t result;
  2075.     uint16_t nshort = hDecoder->frameLength/8;
  2077. #ifdef PROFILE
  2078.     int64_t count = faad_get_ts();
  2079. #endif
  2081.     for(g = 0; g < ics->num_window_groups; g++)
  2082.     {
  2083.         p = groups*nshort;
  2085.         for (i = 0; i < ics->num_sec[g]; i++)
  2086.         {
  2087.             sect_cb = ics->sect_cb[g][i];
  2089.             inc = (sect_cb >= FIRST_PAIR_HCB) ? 2 : 4;
  2091.             switch (sect_cb)
  2092.             {
  2093.             case ZERO_HCB:
  2094.             case NOISE_HCB:
  2095.             case INTENSITY_HCB:
  2096.             case INTENSITY_HCB2:
  2097. //#define SD_PRINT
  2098. #ifdef SD_PRINT
  2099.                 {
  2100.                     int j;
  2101.                     for (j = ics->sect_sfb_offset[g][ics->sect_start[g][i]]; j < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; j++)
  2102.                     {
  2103.                         printf("%dn", 0);
  2104.                     }
  2105.                 }
  2106. #endif
  2107. //#define SFBO_PRINT
  2108. #ifdef SFBO_PRINT
  2109.                 printf("%dn", ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
  2110. #endif
  2111.                 p += (ics->sect_sfb_offset[g][ics->sect_end[g][i]] -
  2112.                     ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
  2113.                 break;
  2114.             default:
  2115. #ifdef SFBO_PRINT
  2116.                 printf("%dn", ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
  2117. #endif
  2118.                 for (k = ics->sect_sfb_offset[g][ics->sect_start[g][i]];
  2119.                      k < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; k += inc)
  2120.                 {
  2121.                     if ((result = huffman_spectral_data(sect_cb, ld, &spectral_data[p])) > 0)
  2122.                         return result;
  2123. #ifdef SD_PRINT
  2124.                     {
  2125.                         int j;
  2126.                         for (j = p; j < p+inc; j++)
  2127.                         {
  2128.                             printf("%dn", spectral_data[j]);
  2129.                         }
  2130.                     }
  2131. #endif
  2132.                     p += inc;
  2133.                 }
  2134.                 break;
  2135.             }
  2136.         }
  2137.         groups += ics->window_group_length[g];
  2138.     }
  2140. #ifdef PROFILE
  2141.     count = faad_get_ts() - count;
  2142.     hDecoder->spectral_cycles += count;
  2143. #endif
  2145.     return 0;
  2146. }
  2148. /* Table 4.4.30 */
  2149. static uint16_t extension_payload(bitfile *ld, drc_info *drc, uint16_t count)
  2150. {
  2151.     uint16_t i, n, dataElementLength;
  2152.     uint8_t dataElementLengthPart;
  2153.     uint8_t align = 4, data_element_version, loopCounter;
  2155.     uint8_t extension_type = (uint8_t)faad_getbits(ld, 4
  2156.         DEBUGVAR(1,87,"extension_payload(): extension_type"));
  2158.     switch (extension_type)
  2159.     {
  2160.     case EXT_DYNAMIC_RANGE:
  2161.         drc->present = 1;
  2162.         n = dynamic_range_info(ld, drc);
  2163.         return n;
  2164.     case EXT_FILL_DATA:
  2165.         /* fill_nibble = */ faad_getbits(ld, 4
  2166.             DEBUGVAR(1,136,"extension_payload(): fill_nibble")); /* must be