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

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

多媒体编程

开发平台：

Visual C++

decoder.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: decoder.c,v 1.2 2005/11/01 21:41:43 gabest Exp $
  31. **/
  33. #include "common.h"
  34. #include "structs.h"
  36. #include <stdlib.h>
  37. #include <string.h>
  39. #include "decoder.h"
  40. #include "mp4.h"
  41. #include "syntax.h"
  42. #include "error.h"
  43. #include "output.h"
  44. #include "filtbank.h"
  45. #include "drc.h"
  46. #ifdef SBR_DEC
  47. #include "sbr_dec.h"
  48. #include "sbr_syntax.h"
  49. #endif
  50. #ifdef SSR_DEC
  51. #include "ssr.h"
  52. #endif
  54. #ifdef ANALYSIS
  55. uint16_t dbg_count;
  56. #endif
  58. /* static function declarations */
  59. static void* aac_frame_decode(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
  60.                               uint8_t *buffer, uint32_t buffer_size,
  61.                               void **sample_buffer, uint32_t sample_buffer_size);
  62. static void create_channel_config(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo);
  65. char* NEAACDECAPI NeAACDecGetErrorMessage(uint8_t errcode)
  66. {
  67.     if (errcode >= NUM_ERROR_MESSAGES)
  68.         return NULL;
  69.     return err_msg[errcode];
  70. }
  72. uint32_t NEAACDECAPI NeAACDecGetCapabilities(void)
  73. {
  74.     uint32_t cap = 0;
  76.     /* can't do without it */
  77.     cap += LC_DEC_CAP;
  79. #ifdef MAIN_DEC
  80.     cap += MAIN_DEC_CAP;
  81. #endif
  82. #ifdef LTP_DEC
  83.     cap += LTP_DEC_CAP;
  84. #endif
  85. #ifdef LD_DEC
  86.     cap += LD_DEC_CAP;
  87. #endif
  88. #ifdef ERROR_RESILIENCE
  89.     cap += ERROR_RESILIENCE_CAP;
  90. #endif
  91. #ifdef FIXED_POINT
  92.     cap += FIXED_POINT_CAP;
  93. #endif
  95.     return cap;
  96. }
  98. NeAACDecHandle NEAACDECAPI NeAACDecOpen(void)
  99. {
  100.     uint8_t i;
  101.     NeAACDecHandle hDecoder = NULL;
  103.     if ((hDecoder = (NeAACDecHandle)faad_malloc(sizeof(NeAACDecStruct))) == NULL)
  104.         return NULL;
  106.     memset(hDecoder, 0, sizeof(NeAACDecStruct));
  108.     hDecoder->config.outputFormat  = FAAD_FMT_16BIT;
  109.     hDecoder->config.defObjectType = MAIN;
  110.     hDecoder->config.defSampleRate = 44100; /* Default: 44.1kHz */
  111.     hDecoder->config.downMatrix = 0;
  112.     hDecoder->adts_header_present = 0;
  113.     hDecoder->adif_header_present = 0;
  114. #ifdef ERROR_RESILIENCE
  115.     hDecoder->aacSectionDataResilienceFlag = 0;
  116.     hDecoder->aacScalefactorDataResilienceFlag = 0;
  117.     hDecoder->aacSpectralDataResilienceFlag = 0;
  118. #endif
  119.     hDecoder->frameLength = 1024;
  121.     hDecoder->frame = 0;
  122.     hDecoder->sample_buffer = NULL;
  124.     for (i = 0; i < MAX_CHANNELS; i++)
  125.     {
  126.         hDecoder->window_shape_prev[i] = 0;
  127.         hDecoder->time_out[i] = NULL;
  128.         hDecoder->fb_intermed[i] = NULL;
  129. #ifdef SSR_DEC
  130.         hDecoder->ssr_overlap[i] = NULL;
  131.         hDecoder->prev_fmd[i] = NULL;
  132. #endif
  133. #ifdef MAIN_DEC
  134.         hDecoder->pred_stat[i] = NULL;
  135. #endif
  136. #ifdef LTP_DEC
  137.         hDecoder->ltp_lag[i] = 0;
  138.         hDecoder->lt_pred_stat[i] = NULL;
  139. #endif
  140.     }
  142. #ifdef SBR_DEC
  143.     for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++)
  144.     {
  145.         hDecoder->sbr[i] = NULL;
  146.     }
  147. #endif
  149.     hDecoder->drc = drc_init(REAL_CONST(1.0), REAL_CONST(1.0));
  151.     return hDecoder;
  152. }
  154. NeAACDecConfigurationPtr NEAACDECAPI NeAACDecGetCurrentConfiguration(NeAACDecHandle hDecoder)
  155. {
  156.     if (hDecoder)
  157.     {
  158.         NeAACDecConfigurationPtr config = &(hDecoder->config);
  160.         return config;
  161.     }
  163.     return NULL;
  164. }
  166. uint8_t NEAACDECAPI NeAACDecSetConfiguration(NeAACDecHandle hDecoder,
  167.                                              NeAACDecConfigurationPtr config)
  168. {
  169.     if (hDecoder && config)
  170.     {
  171.         /* check if we can decode this object type */
  172.         if (can_decode_ot(config->defObjectType) < 0)
  173.             return 0;
  174.         hDecoder->config.defObjectType = config->defObjectType;
  176.         /* samplerate: anything but 0 should be possible */
  177.         if (config->defSampleRate == 0)
  178.             return 0;
  179.         hDecoder->config.defSampleRate = config->defSampleRate;
  181.         /* check output format */
  182. #ifdef FIXED_POINT
  183.         if ((config->outputFormat < 1) || (config->outputFormat > 4))
  184.             return 0;
  185. #else
  186.         if ((config->outputFormat < 1) || (config->outputFormat > 5))
  187.             return 0;
  188. #endif
  189.         hDecoder->config.outputFormat = config->outputFormat;
  191.         if (config->downMatrix > 1)
  192.             return 0;
  193.         hDecoder->config.downMatrix = config->downMatrix;
  195.         /* OK */
  196.         return 1;
  197.     }
  199.     return 0;
  200. }
  202. int32_t NEAACDECAPI NeAACDecInit(NeAACDecHandle hDecoder, uint8_t *buffer,
  203.                                  uint32_t buffer_size,
  204.                                  uint32_t *samplerate, uint8_t *channels)
  205. {
  206.     uint32_t bits = 0;
  207.     bitfile ld;
  208.     adif_header adif;
  209.     adts_header adts;
  211.     if ((hDecoder == NULL) || (samplerate == NULL) || (channels == NULL))
  212.         return -1;
  214.     hDecoder->sf_index = get_sr_index(hDecoder->config.defSampleRate);
  215.     hDecoder->object_type = hDecoder->config.defObjectType;
  216.     *samplerate = get_sample_rate(hDecoder->sf_index);
  217.     *channels = 1;
  219.     if (buffer != NULL)
  220.     {
  221.         faad_initbits(&ld, buffer, buffer_size);
  223.         /* Check if an ADIF header is present */
  224.         if ((buffer[0] == 'A') && (buffer[1] == 'D') &&
  225.             (buffer[2] == 'I') && (buffer[3] == 'F'))
  226.         {
  227.             hDecoder->adif_header_present = 1;
  229.             get_adif_header(&adif, &ld);
  230.             faad_byte_align(&ld);
  232.             hDecoder->sf_index = adif.pce[0].sf_index;
  233.             hDecoder->object_type = adif.pce[0].object_type + 1;
  235.             *samplerate = get_sample_rate(hDecoder->sf_index);
  236.             *channels = adif.pce[0].channels;
  238.             memcpy(&(hDecoder->pce), &(adif.pce[0]), sizeof(program_config));
  239.             hDecoder->pce_set = 1;
  241.             bits = bit2byte(faad_get_processed_bits(&ld));
  243.         /* Check if an ADTS header is present */
  244.         } else if (faad_showbits(&ld, 12) == 0xfff) {
  245.             hDecoder->adts_header_present = 1;
  247.             adts.old_format = hDecoder->config.useOldADTSFormat;
  248.             adts_frame(&adts, &ld);
  250.             hDecoder->sf_index = adts.sf_index;
  251.             hDecoder->object_type = adts.profile + 1;
  253.             *samplerate = get_sample_rate(hDecoder->sf_index);
  254.             *channels = (adts.channel_configuration > 6) ?
  255.                 2 : adts.channel_configuration;
  256.         }
  258.         if (ld.error)
  259.         {
  260.             faad_endbits(&ld);
  261.             return -1;
  262.         }
  263.         faad_endbits(&ld);
  264.     }
  265.     hDecoder->channelConfiguration = *channels;
  267. #if (defined(PS_DEC) || defined(DRM_PS))
  268.     /* check if we have a mono file */
  269.     if (*channels == 1)
  270.     {
  271.         /* upMatrix to 2 channels for implicit signalling of PS */
  272.         *channels = 2;
  273.     }
  274. #endif
  276. #ifdef SBR_DEC
  277.     /* implicit signalling */
  278.     if (*samplerate <= 24000 && !(hDecoder->config.dontUpSampleImplicitSBR))
  279.     {
  280.         *samplerate *= 2;
  281.         hDecoder->forceUpSampling = 1;
  282.     } else if (*samplerate > 24000 && !(hDecoder->config.dontUpSampleImplicitSBR)) {
  283.         hDecoder->downSampledSBR = 1;
  284.     }
  285. #endif
  287.     /* must be done before frameLength is divided by 2 for LD */
  288. #ifdef SSR_DEC
  289.     if (hDecoder->object_type == SSR)
  290.         hDecoder->fb = ssr_filter_bank_init(hDecoder->frameLength/SSR_BANDS);
  291.     else
  292. #endif
  293.         hDecoder->fb = filter_bank_init(hDecoder->frameLength);
  295. #ifdef LD_DEC
  296.     if (hDecoder->object_type == LD)
  297.         hDecoder->frameLength >>= 1;
  298. #endif
  300.     if (can_decode_ot(hDecoder->object_type) < 0)
  301.         return -1;
  303.     return bits;
  304. }
  306. /* Init the library using a DecoderSpecificInfo */
  307. int8_t NEAACDECAPI NeAACDecInit2(NeAACDecHandle hDecoder, uint8_t *pBuffer,
  308.                                  uint32_t SizeOfDecoderSpecificInfo,
  309.                                  uint32_t *samplerate, uint8_t *channels)
  310. {
  311.     int8_t rc;
  312.     mp4AudioSpecificConfig mp4ASC;
  314.     if((hDecoder == NULL)
  315.         || (pBuffer == NULL)
  316.         || (SizeOfDecoderSpecificInfo < 2)
  317.         || (samplerate == NULL)
  318.         || (channels == NULL))
  319.     {
  320.         return -1;
  321.     }
  323.     hDecoder->adif_header_present = 0;
  324.     hDecoder->adts_header_present = 0;
  326.     /* decode the audio specific config */
  327.     rc = AudioSpecificConfig2(pBuffer, SizeOfDecoderSpecificInfo, &mp4ASC,
  328.         &(hDecoder->pce));
  330.     /* copy the relevant info to the decoder handle */
  331.     *samplerate = mp4ASC.samplingFrequency;
  332.     if (mp4ASC.channelsConfiguration)
  333.     {
  334.         *channels = mp4ASC.channelsConfiguration;
  335.     } else {
  336.         *channels = hDecoder->pce.channels;
  337.         hDecoder->pce_set = 1;
  338.     }
  339. #if (defined(PS_DEC) || defined(DRM_PS))
  340.     /* check if we have a mono file */
  341.     if (*channels == 1)
  342.     {
  343.         /* upMatrix to 2 channels for implicit signalling of PS */
  344.         *channels = 2;
  345.     }
  346. #endif
  347.     hDecoder->sf_index = mp4ASC.samplingFrequencyIndex;
  348.     hDecoder->object_type = mp4ASC.objectTypeIndex;
  349. #ifdef ERROR_RESILIENCE
  350.     hDecoder->aacSectionDataResilienceFlag = mp4ASC.aacSectionDataResilienceFlag;
  351.     hDecoder->aacScalefactorDataResilienceFlag = mp4ASC.aacScalefactorDataResilienceFlag;
  352.     hDecoder->aacSpectralDataResilienceFlag = mp4ASC.aacSpectralDataResilienceFlag;
  353. #endif
  354. #ifdef SBR_DEC
  355.     hDecoder->sbr_present_flag = mp4ASC.sbr_present_flag;
  356.     hDecoder->downSampledSBR = mp4ASC.downSampledSBR;
  357.     if (hDecoder->config.dontUpSampleImplicitSBR == 0)
  358.         hDecoder->forceUpSampling = mp4ASC.forceUpSampling;
  359.     else
  360.         hDecoder->forceUpSampling = 0;
  362.     /* AAC core decoder samplerate is 2 times as low */
  363.     if (((hDecoder->sbr_present_flag == 1)&&(!hDecoder->downSampledSBR)) || hDecoder->forceUpSampling == 1)
  364.     {
  365.         hDecoder->sf_index = get_sr_index(mp4ASC.samplingFrequency / 2);
  366.     }
  367. #endif
  369.     if (rc != 0)
  370.     {
  371.         return rc;
  372.     }
  373.     hDecoder->channelConfiguration = mp4ASC.channelsConfiguration;
  374.     if (mp4ASC.frameLengthFlag)
  375. #ifdef ALLOW_SMALL_FRAMELENGTH
  376.         hDecoder->frameLength = 960;
  377. #else
  378.         return -1;
  379. #endif
  381.     /* must be done before frameLength is divided by 2 for LD */
  382. #ifdef SSR_DEC
  383.     if (hDecoder->object_type == SSR)
  384.         hDecoder->fb = ssr_filter_bank_init(hDecoder->frameLength/SSR_BANDS);
  385.     else
  386. #endif
  387.         hDecoder->fb = filter_bank_init(hDecoder->frameLength);
  389. #ifdef LD_DEC
  390.     if (hDecoder->object_type == LD)
  391.         hDecoder->frameLength >>= 1;
  392. #endif
  394.     return 0;
  395. }
  397. #ifdef DRM
  398. int8_t NEAACDECAPI NeAACDecInitDRM(NeAACDecHandle *hDecoder, uint32_t samplerate,
  399.                                    uint8_t channels)
  400. {
  401.     if (hDecoder == NULL)
  402.         return 1; /* error */
  404.     NeAACDecClose(*hDecoder);
  406.     *hDecoder = NeAACDecOpen();
  408.     /* Special object type defined for DRM */
  409.     (*hDecoder)->config.defObjectType = DRM_ER_LC;
  411.     (*hDecoder)->config.defSampleRate = samplerate;
  412. #ifdef ERROR_RESILIENCE // This shoudl always be defined for DRM
  413.     (*hDecoder)->aacSectionDataResilienceFlag = 1; /* VCB11 */
  414.     (*hDecoder)->aacScalefactorDataResilienceFlag = 0; /* no RVLC */
  415.     (*hDecoder)->aacSpectralDataResilienceFlag = 1; /* HCR */
  416. #endif
  417.     (*hDecoder)->frameLength = 960;
  418.     (*hDecoder)->sf_index = get_sr_index((*hDecoder)->config.defSampleRate);
  419.     (*hDecoder)->object_type = (*hDecoder)->config.defObjectType;
  421.     if ((channels == DRMCH_STEREO) || (channels == DRMCH_SBR_STEREO))
  422.         (*hDecoder)->channelConfiguration = 2;
  423.     else
  424.         (*hDecoder)->channelConfiguration = 1;
  426. #ifdef SBR_DEC
  427.     if ((channels == DRMCH_MONO) || (channels == DRMCH_STEREO))
  428.         (*hDecoder)->sbr_present_flag = 0;
  429.     else
  430.         (*hDecoder)->sbr_present_flag = 1;    
  431. #endif        
  433.     (*hDecoder)->fb = filter_bank_init((*hDecoder)->frameLength);
  435.     return 0;
  436. }
  437. #endif
  439. void NEAACDECAPI NeAACDecClose(NeAACDecHandle hDecoder)
  440. {
  441.     uint8_t i;
  443.     if (hDecoder == NULL)
  444.         return;
  446. #ifdef PROFILE
  447.     printf("AAC decoder total:  %I64d cyclesn", hDecoder->cycles);
  448.     printf("requant:            %I64d cyclesn", hDecoder->requant_cycles);
  449.     printf("spectral_data:      %I64d cyclesn", hDecoder->spectral_cycles);
  450.     printf("scalefactors:       %I64d cyclesn", hDecoder->scalefac_cycles);
  451.     printf("output:             %I64d cyclesn", hDecoder->output_cycles);
  452. #endif
  454.     for (i = 0; i < MAX_CHANNELS; i++)
  455.     {
  456.         if (hDecoder->time_out[i]) faad_free(hDecoder->time_out[i]);
  457.         if (hDecoder->fb_intermed[i]) faad_free(hDecoder->fb_intermed[i]);
  458. #ifdef SSR_DEC
  459.         if (hDecoder->ssr_overlap[i]) faad_free(hDecoder->ssr_overlap[i]);
  460.         if (hDecoder->prev_fmd[i]) faad_free(hDecoder->prev_fmd[i]);
  461. #endif
  462. #ifdef MAIN_DEC
  463.         if (hDecoder->pred_stat[i]) faad_free(hDecoder->pred_stat[i]);
  464. #endif
  465. #ifdef LTP_DEC
  466.         if (hDecoder->lt_pred_stat[i]) faad_free(hDecoder->lt_pred_stat[i]);
  467. #endif
  468.     }
  470. #ifdef SSR_DEC
  471.     if (hDecoder->object_type == SSR)
  472.         ssr_filter_bank_end(hDecoder->fb);
  473.     else
  474. #endif
  475.         filter_bank_end(hDecoder->fb);
  477.     drc_end(hDecoder->drc);
  479.     if (hDecoder->sample_buffer) faad_free(hDecoder->sample_buffer);
  481. #ifdef SBR_DEC
  482.     for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++)
  483.     {
  484.         if (hDecoder->sbr[i])
  485.             sbrDecodeEnd(hDecoder->sbr[i]);
  486.     }
  487. #endif
  489.     if (hDecoder) faad_free(hDecoder);
  490. }
  492. void NEAACDECAPI NeAACDecPostSeekReset(NeAACDecHandle hDecoder, int32_t frame)
  493. {
  494.     if (hDecoder)
  495.     {
  496.         hDecoder->postSeekResetFlag = 1;
  498.         if (frame != -1)
  499.             hDecoder->frame = frame;
  500.     }
  501. }
  503. static void create_channel_config(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo)
  504. {
  505.     hInfo->num_front_channels = 0;
  506.     hInfo->num_side_channels = 0;
  507.     hInfo->num_back_channels = 0;
  508.     hInfo->num_lfe_channels = 0;
  509.     memset(hInfo->channel_position, 0, MAX_CHANNELS*sizeof(uint8_t));
  511.     if (hDecoder->downMatrix)
  512.     {
  513.         hInfo->num_front_channels = 2;
  514.         hInfo->channel_position[0] = FRONT_CHANNEL_LEFT;
  515.         hInfo->channel_position[1] = FRONT_CHANNEL_RIGHT;
  516.         return;
  517.     }
  519.     /* check if there is a PCE */
  520.     if (hDecoder->pce_set)
  521.     {
  522.         uint8_t i, chpos = 0;
  523.         uint8_t chdir, back_center = 0;
  525.         hInfo->num_front_channels = hDecoder->pce.num_front_channels;
  526.         hInfo->num_side_channels = hDecoder->pce.num_side_channels;
  527.         hInfo->num_back_channels = hDecoder->pce.num_back_channels;
  528.         hInfo->num_lfe_channels = hDecoder->pce.num_lfe_channels;
  530.         chdir = hInfo->num_front_channels;
  531.         if (chdir & 1)
  532.         {
  533.             hInfo->channel_position[chpos++] = FRONT_CHANNEL_CENTER;
  534.             chdir--;
  535.         }
  536.         for (i = 0; i < chdir; i += 2)
  537.         {
  538.             hInfo->channel_position[chpos++] = FRONT_CHANNEL_LEFT;
  539.             hInfo->channel_position[chpos++] = FRONT_CHANNEL_RIGHT;
  540.         }
  542.         for (i = 0; i < hInfo->num_side_channels; i += 2)
  543.         {
  544.             hInfo->channel_position[chpos++] = SIDE_CHANNEL_LEFT;
  545.             hInfo->channel_position[chpos++] = SIDE_CHANNEL_RIGHT;
  546.         }
  548.         chdir = hInfo->num_back_channels;
  549.         if (chdir & 1)
  550.         {
  551.             back_center = 1;
  552.             chdir--;
  553.         }
  554.         for (i = 0; i < chdir; i += 2)
  555.         {
  556.             hInfo->channel_position[chpos++] = BACK_CHANNEL_LEFT;
  557.             hInfo->channel_position[chpos++] = BACK_CHANNEL_RIGHT;
  558.         }
  559.         if (back_center)
  560.         {
  561.             hInfo->channel_position[chpos++] = BACK_CHANNEL_CENTER;
  562.         }
  564.         for (i = 0; i < hInfo->num_lfe_channels; i++)
  565.         {
  566.             hInfo->channel_position[chpos++] = LFE_CHANNEL;
  567.         }
  569.     } else {
  570.         switch (hDecoder->channelConfiguration)
  571.         {
  572.         case 1:
  573.             hInfo->num_front_channels = 1;
  574.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  575.             break;
  576.         case 2:
  577.             hInfo->num_front_channels = 2;
  578.             hInfo->channel_position[0] = FRONT_CHANNEL_LEFT;
  579.             hInfo->channel_position[1] = FRONT_CHANNEL_RIGHT;
  580.             break;
  581.         case 3:
  582.             hInfo->num_front_channels = 3;
  583.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  584.             hInfo->channel_position[1] = FRONT_CHANNEL_LEFT;
  585.             hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT;
  586.             break;
  587.         case 4:
  588.             hInfo->num_front_channels = 3;
  589.             hInfo->num_back_channels = 1;
  590.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  591.             hInfo->channel_position[1] = FRONT_CHANNEL_LEFT;
  592.             hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT;
  593.             hInfo->channel_position[3] = BACK_CHANNEL_CENTER;
  594.             break;
  595.         case 5:
  596.             hInfo->num_front_channels = 3;
  597.             hInfo->num_back_channels = 2;
  598.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  599.             hInfo->channel_position[1] = FRONT_CHANNEL_LEFT;
  600.             hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT;
  601.             hInfo->channel_position[3] = BACK_CHANNEL_LEFT;
  602.             hInfo->channel_position[4] = BACK_CHANNEL_RIGHT;
  603.             break;
  604.         case 6:
  605.             hInfo->num_front_channels = 3;
  606.             hInfo->num_back_channels = 2;
  607.             hInfo->num_lfe_channels = 1;
  608.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  609.             hInfo->channel_position[1] = FRONT_CHANNEL_LEFT;
  610.             hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT;
  611.             hInfo->channel_position[3] = BACK_CHANNEL_LEFT;
  612.             hInfo->channel_position[4] = BACK_CHANNEL_RIGHT;
  613.             hInfo->channel_position[5] = LFE_CHANNEL;
  614.             break;
  615.         case 7:
  616.             hInfo->num_front_channels = 3;
  617.             hInfo->num_side_channels = 2;
  618.             hInfo->num_back_channels = 2;
  619.             hInfo->num_lfe_channels = 1;
  620.             hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  621.             hInfo->channel_position[1] = FRONT_CHANNEL_LEFT;
  622.             hInfo->channel_position[2] = FRONT_CHANNEL_RIGHT;
  623.             hInfo->channel_position[3] = SIDE_CHANNEL_LEFT;
  624.             hInfo->channel_position[4] = SIDE_CHANNEL_RIGHT;
  625.             hInfo->channel_position[5] = BACK_CHANNEL_LEFT;
  626.             hInfo->channel_position[6] = BACK_CHANNEL_RIGHT;
  627.             hInfo->channel_position[7] = LFE_CHANNEL;
  628.             break;
  629.         default: /* channelConfiguration == 0 || channelConfiguration > 7 */
  630.             {
  631.                 uint8_t i;
  632.                 uint8_t ch = hDecoder->fr_channels - hDecoder->has_lfe;
  633.                 if (ch & 1) /* there's either a center front or a center back channel */
  634.                 {
  635.                     uint8_t ch1 = (ch-1)/2;
  636.                     if (hDecoder->first_syn_ele == ID_SCE)
  637.                     {
  638.                         hInfo->num_front_channels = ch1 + 1;
  639.                         hInfo->num_back_channels = ch1;
  640.                         hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  641.                         for (i = 1; i <= ch1; i+=2)
  642.                         {
  643.                             hInfo->channel_position[i] = FRONT_CHANNEL_LEFT;
  644.                             hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT;
  645.                         }
  646.                         for (i = ch1+1; i < ch; i+=2)
  647.                         {
  648.                             hInfo->channel_position[i] = BACK_CHANNEL_LEFT;
  649.                             hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT;
  650.                         }
  651.                     } else {
  652.                         hInfo->num_front_channels = ch1;
  653.                         hInfo->num_back_channels = ch1 + 1;
  654.                         for (i = 0; i < ch1; i+=2)
  655.                         {
  656.                             hInfo->channel_position[i] = FRONT_CHANNEL_LEFT;
  657.                             hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT;
  658.                         }
  659.                         for (i = ch1; i < ch-1; i+=2)
  660.                         {
  661.                             hInfo->channel_position[i] = BACK_CHANNEL_LEFT;
  662.                             hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT;
  663.                         }
  664.                         hInfo->channel_position[ch-1] = BACK_CHANNEL_CENTER;
  665.                     }
  666.                 } else {
  667.                     uint8_t ch1 = (ch)/2;
  668.                     hInfo->num_front_channels = ch1;
  669.                     hInfo->num_back_channels = ch1;
  670.                     if (ch1 & 1)
  671.                     {
  672.                         hInfo->channel_position[0] = FRONT_CHANNEL_CENTER;
  673.                         for (i = 1; i <= ch1; i+=2)
  674.                         {
  675.                             hInfo->channel_position[i] = FRONT_CHANNEL_LEFT;
  676.                             hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT;
  677.                         }
  678.                         for (i = ch1+1; i < ch-1; i+=2)
  679.                         {
  680.                             hInfo->channel_position[i] = BACK_CHANNEL_LEFT;
  681.                             hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT;
  682.                         }
  683.                         hInfo->channel_position[ch-1] = BACK_CHANNEL_CENTER;
  684.                     } else {
  685.                         for (i = 0; i < ch1; i+=2)
  686.                         {
  687.                             hInfo->channel_position[i] = FRONT_CHANNEL_LEFT;
  688.                             hInfo->channel_position[i+1] = FRONT_CHANNEL_RIGHT;
  689.                         }
  690.                         for (i = ch1; i < ch; i+=2)
  691.                         {
  692.                             hInfo->channel_position[i] = BACK_CHANNEL_LEFT;
  693.                             hInfo->channel_position[i+1] = BACK_CHANNEL_RIGHT;
  694.                         }
  695.                     }
  696.                 }
  697.                 hInfo->num_lfe_channels = hDecoder->has_lfe;
  698.                 for (i = ch; i < hDecoder->fr_channels; i++)
  699.                 {
  700.                     hInfo->channel_position[i] = LFE_CHANNEL;
  701.                 }
  702.             }
  703.             break;
  704.         }
  705.     }
  706. }
  708. void* NEAACDECAPI NeAACDecDecode(NeAACDecHandle hDecoder,
  709.                                  NeAACDecFrameInfo *hInfo,
  710.                                  uint8_t *buffer, uint32_t buffer_size)
  711. {
  712.     return aac_frame_decode(hDecoder, hInfo, buffer, buffer_size, NULL, 0);
  713. }
  715. void* NEAACDECAPI NeAACDecDecode2(NeAACDecHandle hDecoder,
  716.                                   NeAACDecFrameInfo *hInfo,
  717.                                   uint8_t *buffer, uint32_t buffer_size,
  718.                                   void **sample_buffer, uint32_t sample_buffer_size)
  719. {
  720.     if ((sample_buffer == NULL) || (sample_buffer_size == 0))
  721.     {
  722.         hInfo->error = 27;
  723.         return NULL;
  724.     }
  726.     return aac_frame_decode(hDecoder, hInfo, buffer, buffer_size,
  727.         sample_buffer, sample_buffer_size);
  728. }
  730. #ifdef DRM
  732. #define ERROR_STATE_INIT 6
  734. static void conceal_output(NeAACDecHandle hDecoder, uint16_t frame_len,
  735.                            uint8_t out_ch, void *sample_buffer)
  736. {
  737.     uint16_t i;
  738.     int16_t   *short_sample_buffer = (int16_t*)sample_buffer;
  739.     int32_t   *int_sample_buffer = (int32_t*)sample_buffer;
  740. #ifndef FIXED_POINT
  741.     float32_t *float_sample_buffer = (float32_t*)sample_buffer;
  742.     double    *double_sample_buffer = (double*)sample_buffer;
  743. #endif
  745.     static const int8_t mute_tab[ERROR_STATE_INIT+1] = { 0, 1, 1, 2, 2, 3, 3 };
  747.     if (hDecoder->error_state > 0)
  748.     {
  749.         switch (hDecoder->config.outputFormat)
  750.         {
  751.         case FAAD_FMT_16BIT:
  752.             for (i = 0; i < out_ch*frame_len; i++)
  753.             {
  754.                 short_sample_buffer[i] >>= mute_tab[hDecoder->error_state];
  755.                 //short_sample_buffer[i] = 0;
  756.             }
  758.             break;
  759.         case FAAD_FMT_24BIT:
  760.         case FAAD_FMT_32BIT:
  761. #ifdef FIXED_POINT
  762.         case FAAD_FMT_FIXED:
  763. #endif
  764.             for (i = 0; i < out_ch*frame_len; i++)
  765.             {
  766.                 int_sample_buffer[i] >>= mute_tab[hDecoder->error_state];
  767.                 //int_sample_buffer[i] = 0;
  768.             }
  769.             break;
  770. #ifndef FIXED_POINT
  771.         case FAAD_FMT_FLOAT:
  772.             for (i = 0; i < out_ch*frame_len; i++)
  773.             {
  774.                 float_sample_buffer[i] /= (float)(1<<mute_tab[hDecoder->error_state]);
  775.                 //float_sample_buffer[i] = 0;
  776.             }
  777.             break;
  778.         case FAAD_FMT_DOUBLE:
  779.             for (i = 0; i < out_ch*frame_len; i++)
  780.             {
  781.                 double_sample_buffer[i] /= (float)(1<<mute_tab[hDecoder->error_state]);
  782.                 //double_sample_buffer[i] = 0;
  783.             }
  784.             break;
  785. #endif
  786.         }
  788.         hDecoder->error_state--;
  789.     }
  790. }
  791. #endif
  793. static void* aac_frame_decode(NeAACDecHandle hDecoder, NeAACDecFrameInfo *hInfo,
  794.                               uint8_t *buffer, uint32_t buffer_size,
  795.                               void **sample_buffer2, uint32_t sample_buffer_size)
  796. {
  797.     uint16_t i;
  798.     uint8_t channels = 0;
  799.     uint8_t output_channels = 0;
  800.     bitfile ld;
  801.     uint32_t bitsconsumed;
  802.     uint16_t frame_len;
  803.     void *sample_buffer;
  805. #ifdef PROFILE
  806.     int64_t count = faad_get_ts();
  807. #endif
  809.     /* safety checks */
  810.     if ((hDecoder == NULL) || (hInfo == NULL) || (buffer == NULL))
  811.     {
  812.         return NULL;
  813.     }
  815. #if 0
  816.     printf("%dn", buffer_size*8);
  817. #endif
  819.     frame_len = hDecoder->frameLength;
  822.     memset(hInfo, 0, sizeof(NeAACDecFrameInfo));
  823.     memset(hDecoder->internal_channel, 0, MAX_CHANNELS*sizeof(hDecoder->internal_channel[0]));
  826.     /* check for some common metadata tag types in the bitstream
  827.      * No need to return an error
  828.      */
  829.     /* ID3 */
  830.     if (buffer_size >= 128)
  831.     {
  832.         if (memcmp(buffer, "TAG", 3) == 0)
  833.         {
  834.             /* found it */
  835.             hInfo->bytesconsumed = 128; /* 128 bytes fixed size */
  836.             /* no error, but no output either */
  837.             return NULL;
  838.         }
  839.     }
  842.     /* initialize the bitstream */
  843.     faad_initbits(&ld, buffer, buffer_size);
  845. #if 0
  846.     {
  847.         int i;
  848.         for (i = 0; i < ((buffer_size+3)>>2); i++)
  849.         {
  850.             uint8_t *buf;
  851.             uint32_t temp = 0;
  852.             buf = faad_getbitbuffer(&ld, 32);
  853.             //temp = getdword((void*)buf);
  854.             temp = *((uint32_t*)buf);
  855.             printf("0x%.8Xn", temp);
  856.             free(buf);
  857.         }
  858.         faad_endbits(&ld);
  859.         faad_initbits(&ld, buffer, buffer_size);
  860.     }
  861. #endif
  863. #ifdef DRM
  864.     if (hDecoder->object_type == DRM_ER_LC)
  865.     {
  866.         /* We do not support stereo right now */
  867.         if (0) //(hDecoder->channelConfiguration == 2)
  868.         {
  869.             hInfo->error = 28; // Throw CRC error
  870.             goto error;
  871.         }
  873.         faad_getbits(&ld, 8
  874.             DEBUGVAR(1,1,"NeAACDecDecode(): skip CRC"));
  875.     }
  876. #endif
  878.     if (hDecoder->adts_header_present)
  879.     {
  880.         adts_header adts;
  882.         adts.old_format = hDecoder->config.useOldADTSFormat;
  883.         if ((hInfo->error = adts_frame(&adts, &ld)) > 0)
  884.             goto error;
  886.         /* MPEG2 does byte_alignment() here,
  887.          * but ADTS header is always multiple of 8 bits in MPEG2
  888.          * so not needed to actually do it.
  889.          */
  890.     }
  892. #ifdef ANALYSIS
  893.     dbg_count = 0;
  894. #endif
  896.     /* decode the complete bitstream */
  897. #ifdef DRM
  898.     if (/*(hDecoder->object_type == 6) ||*/ (hDecoder->object_type == DRM_ER_LC))
  899.     {
  900.         DRM_aac_scalable_main_element(hDecoder, hInfo, &ld, &hDecoder->pce, hDecoder->drc);
  901.     } else {
  902. #endif
  903.         raw_data_block(hDecoder, hInfo, &ld, &hDecoder->pce, hDecoder->drc);
  904. #ifdef DRM
  905.     }
  906. #endif
  908.     channels = hDecoder->fr_channels;
  910.     if (hInfo->error > 0)
  911.         goto error;
  913.     /* safety check */
  914.     if (channels == 0 || channels > MAX_CHANNELS)
  915.     {
  916.         /* invalid number of channels */
  917.         hInfo->error = 12;
  918.         goto error;
  919.     }
  921.     /* no more bit reading after this */
  922.     bitsconsumed = faad_get_processed_bits(&ld);
  923.     hInfo->bytesconsumed = bit2byte(bitsconsumed);
  924.     if (ld.error)
  925.     {
  926.         hInfo->error = 14;
  927.         goto error;
  928.     }
  929.     faad_endbits(&ld);
  932.     if (!hDecoder->adts_header_present && !hDecoder->adif_header_present)
  933.     {
  934.         if (hDecoder->channelConfiguration == 0)
  935.             hDecoder->channelConfiguration = channels;
  937.         if (channels == 8) /* 7.1 */
  938.             hDecoder->channelConfiguration = 7;
  939.         if (channels == 7) /* not a standard channelConfiguration */
  940.             hDecoder->channelConfiguration = 0;
  941.     }
  943.     if ((channels == 5 || channels == 6) && hDecoder->config.downMatrix)
  944.     {
  945.         hDecoder->downMatrix = 1;
  946.         output_channels = 2;
  947.     } else {
  948.         output_channels = channels;
  949.     }
  951. #if (defined(PS_DEC) || defined(DRM_PS))
  952.     hDecoder->upMatrix = 0;
  953.     /* check if we have a mono file */
  954.     if (output_channels == 1)
  955.     {
  956.         /* upMatrix to 2 channels for implicit signalling of PS */
  957.         hDecoder->upMatrix = 1;
  958.         output_channels = 2;
  959.     }
  960. #endif
  962.     /* Make a channel configuration based on either a PCE or a channelConfiguration */
  963.     create_channel_config(hDecoder, hInfo);
  965.     /* number of samples in this frame */
  966.     hInfo->samples = frame_len*output_channels;
  967.     /* number of channels in this frame */
  968.     hInfo->channels = output_channels;
  969.     /* samplerate */
  970.     hInfo->samplerate = get_sample_rate(hDecoder->sf_index);
  971.     /* object type */
  972.     hInfo->object_type = hDecoder->object_type;
  973.     /* sbr */
  974.     hInfo->sbr = NO_SBR;
  975.     /* header type */
  976.     hInfo->header_type = RAW;
  977.     if (hDecoder->adif_header_present)
  978.         hInfo->header_type = ADIF;
  979.     if (hDecoder->adts_header_present)
  980.         hInfo->header_type = ADTS;
  981. #if (defined(PS_DEC) || defined(DRM_PS))
  982.     hInfo->ps = hDecoder->ps_used_global;
  983. #endif
  985.     /* check if frame has channel elements */
  986.     if (channels == 0)
  987.     {
  988.         hDecoder->frame++;
  989.         return NULL;
  990.     }
  992.     /* allocate the buffer for the final samples */
  993.     if ((hDecoder->sample_buffer == NULL) ||
  994.         (hDecoder->alloced_channels != output_channels))
  995.     {
  996.         static const uint8_t str[] = { sizeof(int16_t), sizeof(int32_t), sizeof(int32_t),
  997.             sizeof(float32_t), sizeof(double), sizeof(int16_t), sizeof(int16_t),
  998.             sizeof(int16_t), sizeof(int16_t), 0, 0, 0
  999.         };
  1000.         uint8_t stride = str[hDecoder->config.outputFormat-1];
  1001. #ifdef SBR_DEC
  1002.         if (((hDecoder->sbr_present_flag == 1)&&(!hDecoder->downSampledSBR)) || (hDecoder->forceUpSampling == 1))
  1003.         {
  1004.             stride = 2 * stride;
  1005.         }
  1006. #endif
  1007.         /* check if we want to use internal sample_buffer */
  1008.         if (sample_buffer_size == 0)
  1009.         {
  1010.             if (hDecoder->sample_buffer)
  1011.                 faad_free(hDecoder->sample_buffer);
  1012.             hDecoder->sample_buffer = NULL;
  1013.             hDecoder->sample_buffer = faad_malloc(frame_len*output_channels*stride);
  1014.         } else if (sample_buffer_size < frame_len*output_channels*stride) {
  1015.             /* provided sample buffer is not big enough */
  1016.             hInfo->error = 27;
  1017.             return NULL;
  1018.         }
  1019.         hDecoder->alloced_channels = output_channels;
  1020.     }
  1022.     if (sample_buffer_size == 0)
  1023.     {
  1024.         sample_buffer = hDecoder->sample_buffer;
  1025.     } else {
  1026.         sample_buffer = *sample_buffer2;
  1027.     }
  1029. #ifdef SBR_DEC
  1030.     if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  1031.     {
  1032.         uint8_t ele;
  1034.         /* this data is different when SBR is used or when the data is upsampled */
  1035.         if (!hDecoder->downSampledSBR)
  1036.         {
  1037.             frame_len *= 2;
  1038.             hInfo->samples *= 2;
  1039.             hInfo->samplerate *= 2;
  1040.         }
  1042.         /* check if every element was provided with SBR data */
  1043.         for (ele = 0; ele < hDecoder->fr_ch_ele; ele++)
  1044.         {
  1045.             if (hDecoder->sbr[ele] == NULL)
  1046.             {
  1047.                 hInfo->error = 25;
  1048.                 goto error;
  1049.             }
  1050.         }
  1052.         /* sbr */
  1053.         if (hDecoder->sbr_present_flag == 1)
  1054.         {
  1055.             hInfo->object_type = HE_AAC;
  1056.             hInfo->sbr = SBR_UPSAMPLED;
  1057.         } else {
  1058.             hInfo->sbr = NO_SBR_UPSAMPLED;
  1059.         }
  1060.         if (hDecoder->downSampledSBR)
  1061.         {
  1062.             hInfo->sbr = SBR_DOWNSAMPLED;
  1063.         }
  1064.     }
  1065. #endif
  1068.     sample_buffer = output_to_PCM(hDecoder, hDecoder->time_out, sample_buffer,
  1069.         output_channels, frame_len, hDecoder->config.outputFormat);
  1072. #ifdef DRM
  1073.     //conceal_output(hDecoder, frame_len, output_channels, sample_buffer);
  1074. #endif
  1077.     hDecoder->postSeekResetFlag = 0;
  1079.     hDecoder->frame++;
  1080. #ifdef LD_DEC
  1081.     if (hDecoder->object_type != LD)
  1082.     {
  1083. #endif
  1084.         if (hDecoder->frame <= 1)
  1085.             hInfo->samples = 0;
  1086. #ifdef LD_DEC
  1087.     } else {
  1088.         /* LD encoders will give lower delay */
  1089.         if (hDecoder->frame <= 0)
  1090.             hInfo->samples = 0;
  1091.     }
  1092. #endif
  1094.     /* cleanup */
  1095. #ifdef ANALYSIS
  1096.     fflush(stdout);
  1097. #endif
  1099. #ifdef PROFILE
  1100.     count = faad_get_ts() - count;
  1101.     hDecoder->cycles += count;
  1102. #endif
  1104.     return sample_buffer;
  1106. error:
  1109. #ifdef DRM
  1110.     hDecoder->error_state = ERROR_STATE_INIT;
  1111. #endif
  1113.     /* reset filterbank state */
  1114.     for (i = 0; i < MAX_CHANNELS; i++)
  1115.     {
  1116.         if (hDecoder->fb_intermed[i] != NULL)
  1117.         {
  1118.             memset(hDecoder->fb_intermed[i], 0, hDecoder->frameLength*sizeof(real_t));
  1119.         }
  1120.     }
  1121. #ifdef SBR_DEC
  1122.     for (i = 0; i < MAX_SYNTAX_ELEMENTS; i++)
  1123.     {
  1124.         if (hDecoder->sbr[i] != NULL)
  1125.         {
  1126.             sbrReset(hDecoder->sbr[i]);
  1127.         }
  1128.     }
  1129. #endif
  1132.     faad_endbits(&ld);
  1134.     /* cleanup */
  1135. #ifdef ANALYSIS
  1136.     fflush(stdout);
  1137. #endif
  1139.     return NULL;
  1140. }