1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5� Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16of the MPEG specifications. 17 18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20individually for the purpose of encoding or decoding bit streams in products that are compliant with 21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27applications information and documentation. 28 292. COPYRIGHT LICENSE 30 31Redistribution and use in source and binary forms, with or without modification, are permitted without 32payment of copyright license fees provided that you satisfy the following conditions: 33 34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35your modifications thereto in source code form. 36 37You must retain the complete text of this software license in the documentation and/or other materials 38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40modifications thereto to recipients of copies in binary form. 41 42The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43prior written permission. 44 45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46software or your modifications thereto. 47 48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49and the date of any change. For modified versions of the FDK AAC Codec, the term 50"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 533. NO PATENT LICENSE 54 55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57respect to this software. 58 59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60by appropriate patent licenses. 61 624. DISCLAIMER 63 64This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69or business interruption, however caused and on any theory of liability, whether in contract, strict 70liability, or tort (including negligence), arising in any way out of the use of this software, even if 71advised of the possibility of such damage. 72 735. CONTACT INFORMATION 74 75Fraunhofer Institute for Integrated Circuits IIS 76Attention: Audio and Multimedia Departments - FDK AAC LL 77Am Wolfsmantel 33 7891058 Erlangen, Germany 79 80www.iis.fraunhofer.de/amm 81amm-info@iis.fraunhofer.de 82----------------------------------------------------------------------------------------------------------- */ 83 84/***************************** MPEG-4 AAC Decoder ************************** 85 86 Author(s): Manuel Jander 87 Description: 88 89******************************************************************************/ 90 91#include "aacdecoder_lib.h" 92 93#include "aac_ram.h" 94#include "aacdecoder.h" 95#include "tpdec_lib.h" 96#include "FDK_core.h" /* FDK_tools version info */ 97 98 99 #include "sbrdecoder.h" 100 101 102 103 104#include "conceal.h" 105 106 #include "aacdec_drc.h" 107 108 109 110/* Decoder library info */ 111#define AACDECODER_LIB_VL0 2 112#define AACDECODER_LIB_VL1 5 113#define AACDECODER_LIB_VL2 5 114#define AACDECODER_LIB_TITLE "AAC Decoder Lib" 115#define AACDECODER_LIB_BUILD_DATE __DATE__ 116#define AACDECODER_LIB_BUILD_TIME __TIME__ 117 118static AAC_DECODER_ERROR 119setConcealMethod ( const HANDLE_AACDECODER self, 120 const INT method ); 121 122 123LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_GetFreeBytes ( const HANDLE_AACDECODER self, UINT *pFreeBytes){ 124 125 /* reset free bytes */ 126 *pFreeBytes = 0; 127 128 /* check handle */ 129 if(!self) 130 return AAC_DEC_INVALID_HANDLE; 131 132 /* return nr of free bytes */ 133 HANDLE_FDK_BITSTREAM hBs = transportDec_GetBitstream(self->hInput, 0); 134 *pFreeBytes = FDKgetFreeBits(hBs) >> 3; 135 136 /* success */ 137 return AAC_DEC_OK; 138} 139 140/** 141 * Config Decoder using a CSAudioSpecificConfig struct. 142 */ 143static 144LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_Config(HANDLE_AACDECODER self, const CSAudioSpecificConfig *pAscStruct) 145{ 146 AAC_DECODER_ERROR err; 147 148 /* Initialize AAC core decoder, and update self->streaminfo */ 149 err = CAacDecoder_Init(self, pAscStruct); 150 151 return err; 152} 153 154LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_ConfigRaw ( 155 HANDLE_AACDECODER self, 156 UCHAR *conf[], 157 const UINT length[] ) 158{ 159 AAC_DECODER_ERROR err = AAC_DEC_OK; 160 TRANSPORTDEC_ERROR errTp; 161 UINT layer, nrOfLayers = self->nrOfLayers; 162 163 for(layer = 0; layer < nrOfLayers; layer++){ 164 if(length[layer] > 0){ 165 errTp = transportDec_OutOfBandConfig(self->hInput, conf[layer], length[layer], layer); 166 if (errTp != TRANSPORTDEC_OK) { 167 switch (errTp) { 168 case TRANSPORTDEC_NEED_TO_RESTART: 169 err = AAC_DEC_NEED_TO_RESTART; 170 break; 171 case TRANSPORTDEC_UNSUPPORTED_FORMAT: 172 err = AAC_DEC_UNSUPPORTED_FORMAT; 173 break; 174 default: 175 err = AAC_DEC_UNKNOWN; 176 break; 177 } 178 /* if baselayer is OK we continue decoding */ 179 if(layer >= 1){ 180 self->nrOfLayers = layer; 181 } 182 break; 183 } 184 } 185 } 186 187 return err; 188} 189 190 191 192static INT aacDecoder_ConfigCallback(void *handle, const CSAudioSpecificConfig *pAscStruct) 193{ 194 HANDLE_AACDECODER self = (HANDLE_AACDECODER)handle; 195 AAC_DECODER_ERROR err = AAC_DEC_OK; 196 TRANSPORTDEC_ERROR errTp; 197 198 { 199 { 200 err = aacDecoder_Config(self, pAscStruct); 201 } 202 } 203 if (err == AAC_DEC_OK) { 204 if ( self->flags & (AC_USAC|AC_RSVD50|AC_LD|AC_ELD) 205 && CConcealment_GetDelay(&self->concealCommonData) > 0 ) 206 { 207 /* Revert to error concealment method Noise Substitution. 208 Because interpolation is not implemented for USAC/RSVD50 or 209 the additional delay is unwanted for low delay codecs. */ 210 setConcealMethod(self, 1); 211#ifdef DEBUG 212 FDKprintf(" Concealment method was reverted to 1 !\n"); 213#endif 214 } 215 errTp = TRANSPORTDEC_OK; 216 } else { 217 if (IS_INIT_ERROR(err)) { 218 errTp = TRANSPORTDEC_UNSUPPORTED_FORMAT; 219 } /* Fatal errors */ 220 else if (err == AAC_DEC_NEED_TO_RESTART) { 221 errTp = TRANSPORTDEC_NEED_TO_RESTART; 222 } else { 223 errTp = TRANSPORTDEC_UNKOWN_ERROR; 224 } 225 } 226 227 return errTp; 228} 229 230 231 232LINKSPEC_CPP AAC_DECODER_ERROR 233aacDecoder_AncDataInit ( HANDLE_AACDECODER self, 234 UCHAR *buffer, 235 int size ) 236{ 237 CAncData *ancData = &self->ancData; 238 239 return CAacDecoder_AncDataInit(ancData, buffer, size); 240} 241 242 243LINKSPEC_CPP AAC_DECODER_ERROR 244aacDecoder_AncDataGet ( HANDLE_AACDECODER self, 245 int index, 246 UCHAR **ptr, 247 int *size ) 248{ 249 CAncData *ancData = &self->ancData; 250 251 return CAacDecoder_AncDataGet(ancData, index, ptr, size); 252} 253 254 255static AAC_DECODER_ERROR 256setConcealMethod ( const HANDLE_AACDECODER self, /*!< Handle of the decoder instance */ 257 const INT method ) 258{ 259 AAC_DECODER_ERROR errorStatus = AAC_DEC_OK; 260 CConcealParams *pConcealData = NULL; 261 HANDLE_SBRDECODER hSbrDec = NULL; 262 HANDLE_AAC_DRC hDrcInfo = NULL; 263 HANDLE_PCM_DOWNMIX hPcmDmx = NULL; 264 CConcealmentMethod backupMethod = ConcealMethodNone; 265 int backupDelay = 0; 266 int bsDelay = 0; 267 268 /* check decoder handle */ 269 if (self != NULL) { 270 pConcealData = &self->concealCommonData; 271 hSbrDec = self->hSbrDecoder; 272 hDrcInfo = self->hDrcInfo; 273 hPcmDmx = self->hPcmUtils; 274 } 275 276 277 /* Get current method/delay */ 278 backupMethod = CConcealment_GetMethod(pConcealData); 279 backupDelay = CConcealment_GetDelay(pConcealData); 280 281 /* Be sure to set AAC and SBR concealment method simultaneously! */ 282 errorStatus = 283 CConcealment_SetParams( 284 pConcealData, 285 (int)method, // concealMethod 286 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, // concealFadeOutSlope 287 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, // concealFadeInSlope 288 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, // concealMuteRelease 289 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED // concealComfNoiseLevel 290 ); 291 if ( (errorStatus != AAC_DEC_OK) 292 && (errorStatus != AAC_DEC_INVALID_HANDLE) ) { 293 goto bail; 294 } 295 296 /* Get new delay */ 297 bsDelay = CConcealment_GetDelay(pConcealData); 298 299 { 300 SBR_ERROR sbrErr = SBRDEC_OK; 301 302 /* set SBR bitstream delay */ 303 sbrErr = sbrDecoder_SetParam ( 304 hSbrDec, 305 SBR_SYSTEM_BITSTREAM_DELAY, 306 bsDelay 307 ); 308 309 switch (sbrErr) { 310 case SBRDEC_OK: 311 case SBRDEC_NOT_INITIALIZED: 312 if (self != NULL) { 313 /* save the param value and set later 314 (when SBR has been initialized) */ 315 self->sbrParams.bsDelay = bsDelay; 316 } 317 break; 318 default: 319 errorStatus = AAC_DEC_SET_PARAM_FAIL; 320 goto bail; 321 } 322 } 323 324 errorStatus = 325 aacDecoder_drcSetParam ( 326 hDrcInfo, 327 DRC_BS_DELAY, 328 bsDelay 329 ); 330 if ( (errorStatus != AAC_DEC_OK) 331 && (errorStatus != AAC_DEC_INVALID_HANDLE) ) { 332 goto bail; 333 } 334 335 if (errorStatus == AAC_DEC_OK) { 336 PCMDMX_ERROR err = 337 pcmDmx_SetParam ( 338 hPcmDmx, 339 DMX_BS_DATA_DELAY, 340 bsDelay 341 ); 342 switch (err) { 343 case PCMDMX_INVALID_HANDLE: 344 errorStatus = AAC_DEC_INVALID_HANDLE; 345 case PCMDMX_OK: 346 break; 347 default: 348 errorStatus = AAC_DEC_SET_PARAM_FAIL; 349 goto bail; 350 } 351 } 352 353 354bail: 355 if ( (errorStatus != AAC_DEC_OK) 356 && (errorStatus != AAC_DEC_INVALID_HANDLE) ) 357 { 358 /* Revert to the initial state */ 359 CConcealment_SetParams ( 360 pConcealData, 361 (int)backupMethod, 362 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, 363 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, 364 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED, 365 AACDEC_CONCEAL_PARAM_NOT_SPECIFIED 366 ); 367 /* Revert SBR bitstream delay */ 368 sbrDecoder_SetParam ( 369 hSbrDec, 370 SBR_SYSTEM_BITSTREAM_DELAY, 371 backupDelay 372 ); 373 /* Revert DRC bitstream delay */ 374 aacDecoder_drcSetParam ( 375 hDrcInfo, 376 DRC_BS_DELAY, 377 backupDelay 378 ); 379 /* Revert PCM mixdown bitstream delay */ 380 pcmDmx_SetParam ( 381 hPcmDmx, 382 DMX_BS_DATA_DELAY, 383 backupDelay 384 ); 385 } 386 387 return errorStatus; 388} 389 390 391LINKSPEC_CPP AAC_DECODER_ERROR 392aacDecoder_SetParam ( const HANDLE_AACDECODER self, /*!< Handle of the decoder instance */ 393 const AACDEC_PARAM param, /*!< Parameter to set */ 394 const INT value) /*!< Parameter valued */ 395{ 396 AAC_DECODER_ERROR errorStatus = AAC_DEC_OK; 397 CConcealParams *pConcealData = NULL; 398 HANDLE_AAC_DRC hDrcInfo = NULL; 399 HANDLE_PCM_DOWNMIX hPcmDmx = NULL; 400 401 /* check decoder handle */ 402 if (self != NULL) { 403 pConcealData = &self->concealCommonData; 404 hDrcInfo = self->hDrcInfo; 405 hPcmDmx = self->hPcmUtils; 406 } else { 407 errorStatus = AAC_DEC_INVALID_HANDLE; 408 } 409 410 /* configure the subsystems */ 411 switch (param) 412 { 413 case AAC_PCM_OUTPUT_INTERLEAVED: 414 if (value < 0 || value > 1) { 415 return AAC_DEC_SET_PARAM_FAIL; 416 } 417 if (self == NULL) { 418 return AAC_DEC_INVALID_HANDLE; 419 } 420 self->outputInterleaved = value; 421 break; 422 423 case AAC_PCM_OUTPUT_CHANNELS: 424 if (value < -1 || value > (6)) { 425 return AAC_DEC_SET_PARAM_FAIL; 426 } 427 { 428 PCMDMX_ERROR err; 429 430 err = pcmDmx_SetParam ( 431 hPcmDmx, 432 NUMBER_OF_OUTPUT_CHANNELS, 433 value ); 434 435 switch (err) { 436 case PCMDMX_OK: 437 break; 438 case PCMDMX_INVALID_HANDLE: 439 return AAC_DEC_INVALID_HANDLE; 440 default: 441 return AAC_DEC_SET_PARAM_FAIL; 442 } 443 } 444 break; 445 446 case AAC_PCM_DUAL_CHANNEL_OUTPUT_MODE: 447 { 448 PCMDMX_ERROR err; 449 450 err = pcmDmx_SetParam ( 451 hPcmDmx, 452 DUAL_CHANNEL_DOWNMIX_MODE, 453 value ); 454 455 switch (err) { 456 case PCMDMX_OK: 457 break; 458 case PCMDMX_INVALID_HANDLE: 459 return AAC_DEC_INVALID_HANDLE; 460 default: 461 return AAC_DEC_SET_PARAM_FAIL; 462 } 463 } 464 break; 465 466 case AAC_PCM_OUTPUT_CHANNEL_MAPPING: 467 switch (value) { 468 case 0: 469 if (self != NULL) { 470 self->channelOutputMapping = channelMappingTablePassthrough; 471 } 472 break; 473 case 1: 474 if (self != NULL) { 475 self->channelOutputMapping = channelMappingTableWAV; 476 } 477 break; 478 default: 479 errorStatus = AAC_DEC_SET_PARAM_FAIL; 480 break; 481 } 482 break; 483 484 485 case AAC_QMF_LOWPOWER: 486 if (value < -1 || value > 1) { 487 return AAC_DEC_SET_PARAM_FAIL; 488 } 489 if (self == NULL) { 490 return AAC_DEC_INVALID_HANDLE; 491 } 492 493 /** 494 * Set QMF mode (might be overriden) 495 * 0:HQ (complex) 496 * 1:LP (partially complex) 497 */ 498 self->qmfModeUser = (QMF_MODE)value; 499 break; 500 501 502 case AAC_DRC_ATTENUATION_FACTOR: 503 /* DRC compression factor (where 0 is no and 127 is max compression) */ 504 errorStatus = 505 aacDecoder_drcSetParam ( 506 hDrcInfo, 507 DRC_CUT_SCALE, 508 value 509 ); 510 break; 511 512 case AAC_DRC_BOOST_FACTOR: 513 /* DRC boost factor (where 0 is no and 127 is max boost) */ 514 errorStatus = 515 aacDecoder_drcSetParam ( 516 hDrcInfo, 517 DRC_BOOST_SCALE, 518 value 519 ); 520 break; 521 522 case AAC_DRC_REFERENCE_LEVEL: 523 /* DRC reference level quantized in 0.25dB steps using values [0..127] it is '-' for analog scaling */ 524 errorStatus = 525 aacDecoder_drcSetParam ( 526 hDrcInfo, 527 TARGET_REF_LEVEL, 528 value 529 ); 530 break; 531 532 case AAC_DRC_HEAVY_COMPRESSION: 533 /* Don't need to overwrite cut/boost values */ 534 errorStatus = 535 aacDecoder_drcSetParam ( 536 hDrcInfo, 537 APPLY_HEAVY_COMPRESSION, 538 value 539 ); 540 break; 541 542 543 case AAC_TPDEC_CLEAR_BUFFER: 544 transportDec_SetParam(self->hInput, TPDEC_PARAM_RESET, 1); 545 self->streamInfo.numLostAccessUnits = 0; 546 self->streamInfo.numBadBytes = 0; 547 self->streamInfo.numTotalBytes = 0; 548 /* aacDecoder_SignalInterruption(self); */ 549 break; 550 551 case AAC_CONCEAL_METHOD: 552 /* Changing the concealment method can introduce additional bitstream delay. And 553 that in turn affects sub libraries and modules which makes the whole thing quite 554 complex. So the complete changing routine is packed into a helper function which 555 keeps all modules and libs in a consistent state even in the case an error occures. */ 556 errorStatus = setConcealMethod ( self, value ); 557 break; 558 559 default: 560 return AAC_DEC_SET_PARAM_FAIL; 561 } /* switch(param) */ 562 563 return (errorStatus); 564} 565 566 567LINKSPEC_CPP HANDLE_AACDECODER aacDecoder_Open(TRANSPORT_TYPE transportFmt, UINT nrOfLayers) 568{ 569 AAC_DECODER_INSTANCE *aacDec = NULL; 570 HANDLE_TRANSPORTDEC pIn; 571 int err = 0; 572 573 /* Allocate transport layer struct. */ 574 pIn = transportDec_Open(transportFmt, TP_FLAG_MPEG4); 575 if (pIn == NULL) { 576 return NULL; 577 } 578 579 transportDec_SetParam(pIn, TPDEC_PARAM_IGNORE_BUFFERFULLNESS, 1); 580 581 /* Allocate AAC decoder core struct. */ 582 aacDec = CAacDecoder_Open(transportFmt); 583 584 if (aacDec == NULL) { 585 transportDec_Close(&pIn); 586 goto bail; 587 } 588 aacDec->hInput = pIn; 589 590 aacDec->nrOfLayers = nrOfLayers; 591 592 aacDec->channelOutputMapping = channelMappingTableWAV; 593 594 /* Register Config Update callback. */ 595 transportDec_RegisterAscCallback(pIn, aacDecoder_ConfigCallback, (void*)aacDec); 596 597 /* open SBR decoder */ 598 if ( SBRDEC_OK != sbrDecoder_Open ( &aacDec->hSbrDecoder )) { 599 err = -1; 600 goto bail; 601 } 602 aacDec->qmfModeUser = NOT_DEFINED; 603 transportDec_RegisterSbrCallback(aacDec->hInput, (cbSbr_t)sbrDecoder_Header, (void*)aacDec->hSbrDecoder); 604 605 606 pcmDmx_Open( &aacDec->hPcmUtils ); 607 if (aacDec->hPcmUtils == NULL) { 608 err = -1; 609 goto bail; 610 } 611 612 613 614 /* Assure that all modules have same delay */ 615 if ( setConcealMethod(aacDec, CConcealment_GetMethod(&aacDec->concealCommonData)) ) { 616 err = -1; 617 goto bail; 618 } 619 620bail: 621 if (err == -1) { 622 aacDecoder_Close(aacDec); 623 aacDec = NULL; 624 } 625 return aacDec; 626} 627 628LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_Fill( 629 HANDLE_AACDECODER self, 630 UCHAR *pBuffer[], 631 const UINT bufferSize[], 632 UINT *pBytesValid 633 ) 634{ 635 TRANSPORTDEC_ERROR tpErr; 636 /* loop counter for layers; if not TT_MP4_RAWPACKETS used as index for only 637 available layer */ 638 INT layer = 0; 639 INT nrOfLayers = self->nrOfLayers; 640 641 { 642 for (layer = 0; layer < nrOfLayers; layer++){ 643 { 644 tpErr = transportDec_FillData( self->hInput, pBuffer[layer], bufferSize[layer], &pBytesValid[layer], layer ); 645 if (tpErr != TRANSPORTDEC_OK) { 646 return AAC_DEC_UNKNOWN; /* Must be an internal error */ 647 } 648 } 649 } 650 } 651 652 return AAC_DEC_OK; 653} 654 655 656static void aacDecoder_SignalInterruption(HANDLE_AACDECODER self) 657{ 658 CAacDecoder_SignalInterruption(self); 659 660 if ( self->hSbrDecoder != NULL ) { 661 sbrDecoder_SetParam(self->hSbrDecoder, SBR_BS_INTERRUPTION, 0); 662 } 663} 664 665static void aacDecoder_UpdateBitStreamCounters(CStreamInfo *pSi, HANDLE_FDK_BITSTREAM hBs, int nBits, AAC_DECODER_ERROR ErrorStatus) 666{ 667 /* calculate bit difference (amount of bits moved forward) */ 668 nBits = nBits - FDKgetValidBits(hBs); 669 670 /* Note: The amount of bits consumed might become negative when parsing a 671 bit stream with several sub frames, and we find out at the last sub frame 672 that the total frame length does not match the sum of sub frame length. 673 If this happens, the transport decoder might want to rewind to the supposed 674 ending of the transport frame, and this position might be before the last 675 access unit beginning. */ 676 677 /* Calc bitrate. */ 678 if (pSi->frameSize > 0) { 679 pSi->bitRate = (nBits * pSi->sampleRate)/pSi->frameSize; 680 } 681 682 /* bit/byte counters */ 683 { 684 int nBytes; 685 686 nBytes = nBits>>3; 687 pSi->numTotalBytes += nBytes; 688 if (IS_OUTPUT_VALID(ErrorStatus)) { 689 pSi->numTotalAccessUnits++; 690 } 691 if (IS_DECODE_ERROR(ErrorStatus)) { 692 pSi->numBadBytes += nBytes; 693 pSi->numBadAccessUnits++; 694 } 695 } 696} 697 698static INT aacDecoder_EstimateNumberOfLostFrames(HANDLE_AACDECODER self) 699{ 700 INT n; 701 702 transportDec_GetMissingAccessUnitCount( &n, self->hInput); 703 704 return n; 705} 706 707LINKSPEC_CPP AAC_DECODER_ERROR aacDecoder_DecodeFrame( 708 HANDLE_AACDECODER self, 709 INT_PCM *pTimeData, 710 const INT timeDataSize, 711 const UINT flags) 712{ 713 AAC_DECODER_ERROR ErrorStatus; 714 INT layer; 715 INT nBits; 716 INT interleaved = self->outputInterleaved; 717 HANDLE_FDK_BITSTREAM hBs; 718 int fTpInterruption = 0; /* Transport originated interruption detection. */ 719 int fTpConceal = 0; /* Transport originated concealment. */ 720 721 722 if (self == NULL) { 723 return AAC_DEC_INVALID_HANDLE; 724 } 725 726 if (flags & AACDEC_INTR) { 727 self->streamInfo.numLostAccessUnits = 0; 728 } 729 730 hBs = transportDec_GetBitstream(self->hInput, 0); 731 732 /* Get current bits position for bitrate calculation. */ 733 nBits = FDKgetValidBits(hBs); 734 if (! (flags & (AACDEC_CONCEAL | AACDEC_FLUSH) ) ) 735 { 736 TRANSPORTDEC_ERROR err; 737 738 for(layer = 0; layer < self->nrOfLayers; layer++) 739 { 740 err = transportDec_ReadAccessUnit(self->hInput, layer); 741 if (err != TRANSPORTDEC_OK) { 742 switch (err) { 743 case TRANSPORTDEC_NOT_ENOUGH_BITS: 744 ErrorStatus = AAC_DEC_NOT_ENOUGH_BITS; 745 goto bail; 746 case TRANSPORTDEC_SYNC_ERROR: 747 self->streamInfo.numLostAccessUnits = aacDecoder_EstimateNumberOfLostFrames(self); 748 fTpInterruption = 1; 749 break; 750 case TRANSPORTDEC_NEED_TO_RESTART: 751 ErrorStatus = AAC_DEC_NEED_TO_RESTART; 752 goto bail; 753 case TRANSPORTDEC_CRC_ERROR: 754 fTpConceal = 1; 755 break; 756 default: 757 ErrorStatus = AAC_DEC_UNKNOWN; 758 goto bail; 759 } 760 } 761 } 762 } else { 763 if (self->streamInfo.numLostAccessUnits > 0) { 764 self->streamInfo.numLostAccessUnits--; 765 } 766 } 767 768 /* Signal bit stream interruption to other modules if required. */ 769 if ( fTpInterruption || (flags & (AACDEC_INTR|AACDEC_CLRHIST)) ) 770 { 771 aacDecoder_SignalInterruption(self); 772 if ( ! (flags & AACDEC_INTR) ) { 773 ErrorStatus = AAC_DEC_TRANSPORT_SYNC_ERROR; 774 goto bail; 775 } 776 } 777 778 /* Empty bit buffer in case of flush request. */ 779 if (flags & AACDEC_FLUSH) 780 { 781 transportDec_SetParam(self->hInput, TPDEC_PARAM_RESET, 1); 782 self->streamInfo.numLostAccessUnits = 0; 783 self->streamInfo.numBadBytes = 0; 784 self->streamInfo.numTotalBytes = 0; 785 } 786 787 788 ErrorStatus = CAacDecoder_DecodeFrame(self, 789 flags | (fTpConceal ? AACDEC_CONCEAL : 0), 790 pTimeData, 791 timeDataSize, 792 interleaved); 793 794 if (!(flags & (AACDEC_CONCEAL|AACDEC_FLUSH))) { 795 TRANSPORTDEC_ERROR tpErr; 796 tpErr = transportDec_EndAccessUnit(self->hInput); 797 if (tpErr != TRANSPORTDEC_OK) { 798 self->frameOK = 0; 799 } 800 } 801 802 /* If the current pTimeData does not contain a valid signal, there nothing else we can do, so bail. */ 803 if ( ! IS_OUTPUT_VALID(ErrorStatus) ) { 804 goto bail; 805 } 806 807 { 808 /* Export data into streaminfo structure */ 809 self->streamInfo.sampleRate = self->streamInfo.aacSampleRate; 810 self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame; 811 } 812 self->streamInfo.numChannels = self->streamInfo.aacNumChannels; 813 814 815 816 CAacDecoder_SyncQmfMode(self); 817 818/* sbr decoder */ 819 820 if (ErrorStatus || (flags & AACDEC_CONCEAL) || self->pAacDecoderStaticChannelInfo[0]->concealmentInfo.concealState > ConcealState_FadeIn) 821 { 822 self->frameOK = 0; /* if an error has occured do concealment in the SBR decoder too */ 823 } 824 825 if (self->sbrEnabled) 826 { 827 SBR_ERROR sbrError = SBRDEC_OK; 828 829 /* set params */ 830 sbrDecoder_SetParam ( self->hSbrDecoder, 831 SBR_SYSTEM_BITSTREAM_DELAY, 832 self->sbrParams.bsDelay); 833 834 if ( self->streamInfo.aot == AOT_ER_AAC_ELD ) { 835 /* Configure QMF */ 836 sbrDecoder_SetParam ( self->hSbrDecoder, 837 SBR_LD_QMF_TIME_ALIGN, 838 (self->flags & AC_LD_MPS) ? 1 : 0 ); 839 } 840 841 842 843 844 /* apply SBR processing */ 845 sbrError = sbrDecoder_Apply ( self->hSbrDecoder, 846 pTimeData, 847 &self->streamInfo.numChannels, 848 &self->streamInfo.sampleRate, 849 self->channelOutputMapping[self->streamInfo.numChannels-1], 850 interleaved, 851 self->frameOK, 852 &self->psPossible); 853 854 855 if (sbrError == SBRDEC_OK) { 856 857 /* Update data in streaminfo structure. Assume that the SBR upsampling factor is either 1 or 2 */ 858 self->flags |= AC_SBR_PRESENT; 859 if (self->streamInfo.aacSampleRate != self->streamInfo.sampleRate) { 860 if (self->streamInfo.frameSize == 768) { 861 self->streamInfo.frameSize = (self->streamInfo.aacSamplesPerFrame * 8) / 3; 862 } else { 863 self->streamInfo.frameSize = self->streamInfo.aacSamplesPerFrame << 1; 864 } 865 } 866 867 if (self->psPossible) { 868 self->flags |= AC_PS_PRESENT; 869 self->channelType[0] = ACT_FRONT; 870 self->channelType[1] = ACT_FRONT; 871 self->channelIndices[0] = 0; 872 self->channelIndices[1] = 1; 873 } else { 874 self->flags &= ~AC_PS_PRESENT; 875 } 876 } 877 } 878 879 880 if ( flags & (AACDEC_INTR | AACDEC_CLRHIST) ) { 881 /* delete data from the past (e.g. mixdown coeficients) */ 882 pcmDmx_Reset( self->hPcmUtils, PCMDMX_RESET_BS_DATA ); 883 } 884 /* do PCM post processing */ 885 pcmDmx_ApplyFrame ( 886 self->hPcmUtils, 887 pTimeData, 888 self->streamInfo.frameSize, 889 &self->streamInfo.numChannels, 890 interleaved, 891 self->channelType, 892 self->channelIndices, 893 self->channelOutputMapping 894 ); 895 896 897 898 /* Signal interruption to take effect in next frame. */ 899 if ( flags & AACDEC_FLUSH ) { 900 aacDecoder_SignalInterruption(self); 901 } 902 903 /* Update externally visible copy of flags */ 904 self->streamInfo.flags = self->flags; 905 906bail: 907 908 /* Update Statistics */ 909 aacDecoder_UpdateBitStreamCounters(&self->streamInfo, hBs, nBits, ErrorStatus); 910 911 return ErrorStatus; 912} 913 914LINKSPEC_CPP void aacDecoder_Close ( HANDLE_AACDECODER self ) 915{ 916 if (self == NULL) 917 return; 918 919 920 921 if (self->hPcmUtils != NULL) { 922 pcmDmx_Close( &self->hPcmUtils ); 923 } 924 925 926 927 if (self->hSbrDecoder != NULL) { 928 sbrDecoder_Close(&self->hSbrDecoder); 929 } 930 931 if (self->hInput != NULL) { 932 transportDec_Close(&self->hInput); 933 } 934 935 CAacDecoder_Close(self); 936} 937 938 939LINKSPEC_CPP CStreamInfo* aacDecoder_GetStreamInfo ( HANDLE_AACDECODER self ) 940{ 941 return CAacDecoder_GetStreamInfo(self); 942} 943 944LINKSPEC_CPP INT aacDecoder_GetLibInfo ( LIB_INFO *info ) 945{ 946 int i; 947 948 if (info == NULL) { 949 return -1; 950 } 951 952 sbrDecoder_GetLibInfo( info ); 953 transportDec_GetLibInfo( info ); 954 FDK_toolsGetLibInfo( info ); 955 pcmDmx_GetLibInfo( info ); 956 957 /* search for next free tab */ 958 for (i = 0; i < FDK_MODULE_LAST; i++) { 959 if (info[i].module_id == FDK_NONE) break; 960 } 961 if (i == FDK_MODULE_LAST) { 962 return -1; 963 } 964 info += i; 965 966 info->module_id = FDK_AACDEC; 967 /* build own library info */ 968 info->version = LIB_VERSION(AACDECODER_LIB_VL0, AACDECODER_LIB_VL1, AACDECODER_LIB_VL2); 969 LIB_VERSION_STRING(info); 970 info->build_date = AACDECODER_LIB_BUILD_DATE; 971 info->build_time = AACDECODER_LIB_BUILD_TIME; 972 info->title = AACDECODER_LIB_TITLE; 973 974 /* Set flags */ 975 info->flags = 0 976 | CAPF_AAC_LC 977 | CAPF_AAC_VCB11 978 | CAPF_AAC_HCR 979 | CAPF_AAC_RVLC 980 | CAPF_ER_AAC_LD 981 | CAPF_ER_AAC_ELD 982 | CAPF_AAC_CONCEALMENT 983 | CAPF_AAC_DRC 984 985 | CAPF_AAC_MPEG4 986 987 988 | CAPF_AAC_1024 989 | CAPF_AAC_960 990 991 | CAPF_AAC_512 992 993 | CAPF_AAC_480 994 995 ; 996 /* End of flags */ 997 998 return 0; 999} 1000 1001 1002 1003 1004