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/*! 85 \file 86 \brief SBR decoder frontend 87 This module provides a frontend to the SBR decoder. The function openSBR() is called for 88 initialization. The function sbrDecoder_Apply() is called for each frame. sbr_Apply() will call the 89 required functions to decode the raw SBR data (provided by env_extr.cpp), to decode the envelope data and noise floor levels [decodeSbrData()], 90 and to finally apply SBR to the current frame [sbr_dec()]. 91 92 \sa sbrDecoder_Apply(), \ref documentationOverview 93*/ 94 95/*! 96 \page documentationOverview Overview of important information resources and source code documentation 97 98 The primary source code documentation is based on generated and cross-referenced HTML files using 99 <a HREF="http://www.doxygen.org">doxygen</a>. As part of this documentation 100 you can find more extensive descriptions about key concepts and algorithms at the following locations: 101 102 <h2>Programming</h2> 103 104 \li Buffer management: sbrDecoder_Apply() and sbr_dec() 105 \li Internal scale factors to maximize SNR on fixed point processors: #QMF_SCALE_FACTOR 106 \li Special mantissa-exponent format: Created in requantizeEnvelopeData() and used in calculateSbrEnvelope() 107 108 <h2>Algorithmic details</h2> 109 \li About the SBR data format: \ref SBR_HEADER_ELEMENT and \ref SBR_STANDARD_ELEMENT 110 \li Details about the bitstream decoder: env_extr.cpp 111 \li Details about the QMF filterbank and the provided polyphase implementation: qmf_dec.cpp 112 \li Details about the transposer: lpp_tran.cpp 113 \li Details about the envelope adjuster: env_calc.cpp 114 115*/ 116 117#include "sbrdecoder.h" 118 119#include "FDK_bitstream.h" 120 121#include "sbrdec_freq_sca.h" 122#include "env_extr.h" 123#include "sbr_dec.h" 124#include "env_dec.h" 125#include "sbr_crc.h" 126#include "sbr_ram.h" 127#include "sbr_rom.h" 128#include "lpp_tran.h" 129#include "transcendent.h" 130 131 132#include "sbrdec_drc.h" 133 134#include "psbitdec.h" 135 136 137/* Decoder library info */ 138#define SBRDECODER_LIB_VL0 2 139#define SBRDECODER_LIB_VL1 2 140#define SBRDECODER_LIB_VL2 3 141#define SBRDECODER_LIB_TITLE "SBR Decoder" 142#define SBRDECODER_LIB_BUILD_DATE __DATE__ 143#define SBRDECODER_LIB_BUILD_TIME __TIME__ 144 145 146 147 148static UCHAR getHeaderSlot( UCHAR currentSlot, UCHAR hdrSlotUsage[(1)+1] ) 149{ 150 UINT occupied = 0; 151 int s; 152 UCHAR slot = hdrSlotUsage[currentSlot]; 153 154 FDK_ASSERT((1)+1 < 32); 155 156 for (s = 0; s < (1)+1; s++) { 157 if ( (hdrSlotUsage[s] == slot) 158 && (s != slot) ) { 159 occupied = 1; 160 break; 161 } 162 } 163 164 if (occupied) { 165 occupied = 0; 166 167 for (s = 0; s < (1)+1; s++) { 168 occupied |= 1 << hdrSlotUsage[s]; 169 } 170 for (s = 0; s < (1)+1; s++) { 171 if ( !(occupied & 0x1) ) { 172 slot = s; 173 break; 174 } 175 occupied >>= 1; 176 } 177 } 178 179 return slot; 180} 181 182static void copySbrHeader( HANDLE_SBR_HEADER_DATA hDst, const HANDLE_SBR_HEADER_DATA hSrc ) 183{ 184 /* copy the whole header memory (including pointers) */ 185 FDKmemcpy( hDst, hSrc, sizeof(SBR_HEADER_DATA) ); 186 187 /* update pointers */ 188 hDst->freqBandData.freqBandTable[0] = hDst->freqBandData.freqBandTableLo; 189 hDst->freqBandData.freqBandTable[1] = hDst->freqBandData.freqBandTableHi; 190} 191 192 193/*! 194 \brief Reset SBR decoder. 195 196 Reset should only be called if SBR has been sucessfully detected by 197 an appropriate checkForPayload() function. 198 199 \return Error code. 200*/ 201static 202SBR_ERROR sbrDecoder_ResetElement ( 203 HANDLE_SBRDECODER self, 204 int sampleRateIn, 205 int sampleRateOut, 206 int samplesPerFrame, 207 const MP4_ELEMENT_ID elementID, 208 const int elementIndex, 209 const int overlap 210 ) 211{ 212 SBR_ERROR sbrError = SBRDEC_OK; 213 HANDLE_SBR_HEADER_DATA hSbrHeader; 214 UINT qmfFlags = 0; 215 216 int i, synDownsampleFac; 217 218 /* Check in/out samplerates */ 219 if ( sampleRateIn < 6400 220 || sampleRateIn > 48000 221 ) 222 { 223 sbrError = SBRDEC_UNSUPPORTED_CONFIG; 224 goto bail; 225 } 226 227 if ( sampleRateOut > 96000 ) 228 { 229 sbrError = SBRDEC_UNSUPPORTED_CONFIG; 230 goto bail; 231 } 232 233 /* Set QMF mode flags */ 234 if (self->flags & SBRDEC_LOW_POWER) 235 qmfFlags |= QMF_FLAG_LP; 236 237 if (self->coreCodec == AOT_ER_AAC_ELD) { 238 if (self->flags & SBRDEC_LD_MPS_QMF) { 239 qmfFlags |= QMF_FLAG_MPSLDFB; 240 } else { 241 qmfFlags |= QMF_FLAG_CLDFB; 242 } 243 } 244 245 /* Set downsampling factor for synthesis filter bank */ 246 if (sampleRateOut == 0) 247 { 248 /* no single rate mode */ 249 sampleRateOut = sampleRateIn<<1; /* In case of implicit signalling, assume dual rate SBR */ 250 } 251 252 if ( sampleRateIn == sampleRateOut ) { 253 synDownsampleFac = 2; 254 } else { 255 synDownsampleFac = 1; 256 } 257 258 self->synDownsampleFac = synDownsampleFac; 259 self->sampleRateOut = sampleRateOut; 260 261 { 262 int i; 263 264 for (i = 0; i < (1)+1; i++) 265 { 266 hSbrHeader = &(self->sbrHeader[elementIndex][i]); 267 268 /* init a default header such that we can at least do upsampling later */ 269 sbrError = initHeaderData( 270 hSbrHeader, 271 sampleRateIn, 272 sampleRateOut, 273 samplesPerFrame, 274 self->flags 275 ); 276 } 277 } 278 279 if (sbrError != SBRDEC_OK) { 280 goto bail; 281 } 282 283 /* Init SBR channels going to be assigned to a SBR element */ 284 { 285 int ch; 286 287 for (ch=0; ch<self->pSbrElement[elementIndex]->nChannels; ch++) 288 { 289 /* and create sbrDec */ 290 sbrError = createSbrDec (self->pSbrElement[elementIndex]->pSbrChannel[ch], 291 hSbrHeader, 292 &self->pSbrElement[elementIndex]->transposerSettings, 293 synDownsampleFac, 294 qmfFlags, 295 self->flags, 296 overlap, 297 ch ); 298 299 if (sbrError != SBRDEC_OK) { 300 goto bail; 301 } 302 } 303 } 304 305 //FDKmemclear(sbr_OverlapBuffer, sizeof(sbr_OverlapBuffer)); 306 307 if (self->numSbrElements == 1) { 308 switch ( self->coreCodec ) { 309 case AOT_AAC_LC: 310 case AOT_SBR: 311 case AOT_PS: 312 case AOT_ER_AAC_SCAL: 313 case AOT_DRM_AAC: 314 case AOT_DRM_SURROUND: 315 if (CreatePsDec ( &self->hParametricStereoDec, samplesPerFrame )) { 316 sbrError = SBRDEC_CREATE_ERROR; 317 goto bail; 318 } 319 break; 320 default: 321 break; 322 } 323 } 324 325 /* Init frame delay slot handling */ 326 self->pSbrElement[elementIndex]->useFrameSlot = 0; 327 for (i = 0; i < ((1)+1); i++) { 328 self->pSbrElement[elementIndex]->useHeaderSlot[i] = i; 329 } 330 331bail: 332 333 return sbrError; 334} 335 336 337SBR_ERROR sbrDecoder_Open ( HANDLE_SBRDECODER * pSelf ) 338{ 339 HANDLE_SBRDECODER self = NULL; 340 SBR_ERROR sbrError = SBRDEC_OK; 341 342 /* Get memory for this instance */ 343 self = GetRam_SbrDecoder(); 344 if (self == NULL) { 345 sbrError = SBRDEC_MEM_ALLOC_FAILED; 346 goto bail; 347 } 348 349 self->workBuffer1 = GetRam_SbrDecWorkBuffer1(); 350 self->workBuffer2 = GetRam_SbrDecWorkBuffer2(); 351 352 if ( self->workBuffer1 == NULL 353 || self->workBuffer2 == NULL ) 354 { 355 sbrError = SBRDEC_MEM_ALLOC_FAILED; 356 goto bail; 357 } 358 359 /* 360 Already zero because of calloc 361 self->numSbrElements = 0; 362 self->numSbrChannels = 0; 363 self->codecFrameSize = 0; 364 */ 365 366 self->numDelayFrames = (1); /* set to the max value by default */ 367 368 *pSelf = self; 369 370bail: 371 return sbrError; 372} 373 374/** 375 * \brief determine if the given core codec AOT can be processed or not. 376 * \param coreCodec core codec audio object type. 377 * \return 1 if SBR can be processed, 0 if SBR cannot be processed/applied. 378 */ 379static 380int sbrDecoder_isCoreCodecValid(AUDIO_OBJECT_TYPE coreCodec) 381{ 382 switch (coreCodec) { 383 case AOT_AAC_LC: 384 case AOT_SBR: 385 case AOT_PS: 386 case AOT_ER_AAC_SCAL: 387 case AOT_ER_AAC_ELD: 388 return 1; 389 default: 390 return 0; 391 } 392} 393 394static 395void sbrDecoder_DestroyElement ( 396 HANDLE_SBRDECODER self, 397 const int elementIndex 398 ) 399{ 400 if (self->pSbrElement[elementIndex] != NULL) { 401 int ch; 402 403 for (ch=0; ch<SBRDEC_MAX_CH_PER_ELEMENT; ch++) { 404 if (self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) { 405 deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] ); 406 FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] ); 407 self->numSbrChannels -= 1; 408 } 409 } 410 FreeRam_SbrDecElement( &self->pSbrElement[elementIndex] ); 411 self->numSbrElements -= 1; 412 } 413} 414 415 416SBR_ERROR sbrDecoder_InitElement ( 417 HANDLE_SBRDECODER self, 418 const int sampleRateIn, 419 const int sampleRateOut, 420 const int samplesPerFrame, 421 const AUDIO_OBJECT_TYPE coreCodec, 422 const MP4_ELEMENT_ID elementID, 423 const int elementIndex 424 ) 425{ 426 SBR_ERROR sbrError = SBRDEC_OK; 427 int chCnt=0; 428 int nSbrElementsStart = self->numSbrElements; 429 430 /* Check core codec AOT */ 431 if (! sbrDecoder_isCoreCodecValid(coreCodec) || elementIndex >= (4)) { 432 sbrError = SBRDEC_UNSUPPORTED_CONFIG; 433 goto bail; 434 } 435 436 if ( elementID != ID_SCE && elementID != ID_CPE && elementID != ID_LFE ) 437 { 438 sbrError = SBRDEC_UNSUPPORTED_CONFIG; 439 goto bail; 440 } 441 442 if ( self->sampleRateIn == sampleRateIn 443 && self->codecFrameSize == samplesPerFrame 444 && self->coreCodec == coreCodec 445 && self->pSbrElement[elementIndex] != NULL 446 && self->pSbrElement[elementIndex]->elementID == elementID 447 ) 448 { 449 /* Nothing to do */ 450 return SBRDEC_OK; 451 } 452 453 self->sampleRateIn = sampleRateIn; 454 self->codecFrameSize = samplesPerFrame; 455 self->coreCodec = coreCodec; 456 457 self->flags = 0; 458 self->flags |= (coreCodec == AOT_ER_AAC_ELD) ? SBRDEC_ELD_GRID : 0; 459 460 /* Init SBR elements */ 461 { 462 int elChannels, ch; 463 464 if (self->pSbrElement[elementIndex] == NULL) { 465 self->pSbrElement[elementIndex] = GetRam_SbrDecElement(elementIndex); 466 if (self->pSbrElement[elementIndex] == NULL) { 467 sbrError = SBRDEC_MEM_ALLOC_FAILED; 468 goto bail; 469 } 470 self->numSbrElements ++; 471 } else { 472 self->numSbrChannels -= self->pSbrElement[elementIndex]->nChannels; 473 } 474 475 /* Save element ID for sanity checks and to have a fallback for concealment. */ 476 self->pSbrElement[elementIndex]->elementID = elementID; 477 478 /* Determine amount of channels for this element */ 479 switch (elementID) { 480 case ID_NONE: 481 case ID_CPE: elChannels=2; 482 break; 483 case ID_LFE: 484 case ID_SCE: elChannels=1; 485 break; 486 default: elChannels=0; 487 break; 488 } 489 490 /* Handle case of Parametric Stereo */ 491 if ( elementIndex == 0 && elementID == ID_SCE ) { 492 switch (coreCodec) { 493 case AOT_AAC_LC: 494 case AOT_SBR: 495 case AOT_PS: 496 case AOT_ER_AAC_SCAL: 497 case AOT_DRM_AAC: 498 case AOT_DRM_SURROUND: 499 elChannels = 2; 500 break; 501 default: 502 break; 503 } 504 } 505 506 self->pSbrElement[elementIndex]->nChannels = elChannels; 507 508 for (ch=0; ch<elChannels; ch++) 509 { 510 if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) { 511 self->pSbrElement[elementIndex]->pSbrChannel[ch] = GetRam_SbrDecChannel(chCnt); 512 if (self->pSbrElement[elementIndex]->pSbrChannel[ch] == NULL) { 513 sbrError = SBRDEC_MEM_ALLOC_FAILED; 514 goto bail; 515 } 516 } 517 self->numSbrChannels ++; 518 519 sbrDecoder_drcInitChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.sbrDrcChannel ); 520 521 /* Add reference pointer to workbuffers. */ 522 self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer1 = self->workBuffer1; 523 self->pSbrElement[elementIndex]->pSbrChannel[ch]->SbrDec.WorkBuffer2 = self->workBuffer2; 524 chCnt++; 525 } 526 if (elChannels == 1 && self->pSbrElement[elementIndex]->pSbrChannel[ch] != NULL) { 527 deleteSbrDec( self->pSbrElement[elementIndex]->pSbrChannel[ch] ); 528 FreeRam_SbrDecChannel( &self->pSbrElement[elementIndex]->pSbrChannel[ch] ); 529 } 530 } 531 532 /* clear error flags for all delay slots */ 533 FDKmemclear(self->pSbrElement[elementIndex]->frameErrorFlag, ((1)+1)*sizeof(UCHAR)); 534 535 /* Initialize this instance */ 536 sbrError = sbrDecoder_ResetElement( 537 self, 538 sampleRateIn, 539 sampleRateOut, 540 samplesPerFrame, 541 elementID, 542 elementIndex, 543 (coreCodec == AOT_ER_AAC_ELD) ? 0 : (6) 544 ); 545 546 547 548bail: 549 if (sbrError != SBRDEC_OK) { 550 if (nSbrElementsStart < self->numSbrElements) { 551 /* Free the memory allocated for this element */ 552 sbrDecoder_DestroyElement( self, elementIndex ); 553 } else if (self->pSbrElement[elementIndex] != NULL) { 554 /* Set error flag to trigger concealment */ 555 self->pSbrElement[elementIndex]->frameErrorFlag[self->pSbrElement[elementIndex]->useFrameSlot] = 1; 556 } 557 } 558 559 return sbrError; 560} 561 562/** 563 * \brief Apply decoded SBR header for one element. 564 * \param self SBR decoder instance handle 565 * \param hSbrHeader SBR header handle to be processed. 566 * \param hSbrChannel pointer array to the SBR element channels corresponding to the SBR header. 567 * \param headerStatus header status value returned from SBR header parser. 568 * \param numElementChannels amount of channels for the SBR element whos header is to be processed. 569 */ 570static 571SBR_ERROR sbrDecoder_HeaderUpdate( 572 HANDLE_SBRDECODER self, 573 HANDLE_SBR_HEADER_DATA hSbrHeader, 574 SBR_HEADER_STATUS headerStatus, 575 HANDLE_SBR_CHANNEL hSbrChannel[], 576 const int numElementChannels 577 ) 578{ 579 SBR_ERROR errorStatus = SBRDEC_OK; 580 581 /* 582 change of control data, reset decoder 583 */ 584 errorStatus = resetFreqBandTables(hSbrHeader, self->flags); 585 586 if (errorStatus == SBRDEC_OK) { 587 if (hSbrHeader->syncState == UPSAMPLING && headerStatus != HEADER_RESET) 588 { 589 /* As the default header would limit the frequency range, 590 lowSubband and highSubband must be patched. */ 591 hSbrHeader->freqBandData.lowSubband = hSbrHeader->numberOfAnalysisBands; 592 hSbrHeader->freqBandData.highSubband = hSbrHeader->numberOfAnalysisBands; 593 } 594 595 /* Trigger a reset before processing this slot */ 596 hSbrHeader->status |= SBRDEC_HDR_STAT_RESET; 597 } 598 599 return errorStatus; 600} 601 602INT sbrDecoder_Header ( 603 HANDLE_SBRDECODER self, 604 HANDLE_FDK_BITSTREAM hBs, 605 const INT sampleRateIn, 606 const INT sampleRateOut, 607 const INT samplesPerFrame, 608 const AUDIO_OBJECT_TYPE coreCodec, 609 const MP4_ELEMENT_ID elementID, 610 const INT elementIndex 611 ) 612{ 613 SBR_HEADER_STATUS headerStatus; 614 HANDLE_SBR_HEADER_DATA hSbrHeader; 615 SBR_ERROR sbrError = SBRDEC_OK; 616 int headerIndex; 617 618 if ( self == NULL || elementIndex > (4) ) 619 { 620 return SBRDEC_UNSUPPORTED_CONFIG; 621 } 622 623 if (! sbrDecoder_isCoreCodecValid(coreCodec)) { 624 return SBRDEC_UNSUPPORTED_CONFIG; 625 } 626 627 sbrError = sbrDecoder_InitElement( 628 self, 629 sampleRateIn, 630 sampleRateOut, 631 samplesPerFrame, 632 coreCodec, 633 elementID, 634 elementIndex 635 ); 636 637 if (sbrError != SBRDEC_OK) { 638 goto bail; 639 } 640 641 headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot, 642 self->pSbrElement[elementIndex]->useHeaderSlot); 643 hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]); 644 645 headerStatus = sbrGetHeaderData ( hSbrHeader, 646 hBs, 647 self->flags, 648 0); 649 650 651 { 652 SBR_DECODER_ELEMENT *pSbrElement; 653 654 pSbrElement = self->pSbrElement[elementIndex]; 655 656 /* Sanity check */ 657 if (pSbrElement != NULL) { 658 if ( (elementID == ID_CPE && pSbrElement->nChannels != 2) 659 || (elementID != ID_CPE && pSbrElement->nChannels != 1) ) 660 { 661 return SBRDEC_UNSUPPORTED_CONFIG; 662 } 663 if ( headerStatus == HEADER_RESET ) { 664 665 sbrError = sbrDecoder_HeaderUpdate( 666 self, 667 hSbrHeader, 668 headerStatus, 669 pSbrElement->pSbrChannel, 670 pSbrElement->nChannels 671 ); 672 673 if (sbrError == SBRDEC_OK) { 674 hSbrHeader->syncState = SBR_HEADER; 675 hSbrHeader->status |= SBRDEC_HDR_STAT_UPDATE; 676 } 677 /* else { 678 Since we already have overwritten the old SBR header the only way out is UPSAMPLING! 679 This will be prepared in the next step. 680 } */ 681 } 682 } 683 } 684bail: 685 return sbrError; 686} 687 688 689SBR_ERROR sbrDecoder_SetParam (HANDLE_SBRDECODER self, 690 const SBRDEC_PARAM param, 691 const INT value ) 692{ 693 SBR_ERROR errorStatus = SBRDEC_OK; 694 695 /* configure the subsystems */ 696 switch (param) 697 { 698 case SBR_SYSTEM_BITSTREAM_DELAY: 699 if (value < 0 || value > (1)) { 700 errorStatus = SBRDEC_SET_PARAM_FAIL; 701 break; 702 } 703 if (self == NULL) { 704 errorStatus = SBRDEC_NOT_INITIALIZED; 705 } else { 706 self->numDelayFrames = (UCHAR)value; 707 } 708 break; 709 case SBR_QMF_MODE: 710 if (self == NULL) { 711 errorStatus = SBRDEC_NOT_INITIALIZED; 712 } else { 713 if (value == 1) { 714 self->flags |= SBRDEC_LOW_POWER; 715 } else { 716 self->flags &= ~SBRDEC_LOW_POWER; 717 } 718 } 719 break; 720 case SBR_LD_QMF_TIME_ALIGN: 721 if (self == NULL) { 722 errorStatus = SBRDEC_NOT_INITIALIZED; 723 } else { 724 if (value == 1) { 725 self->flags |= SBRDEC_LD_MPS_QMF; 726 } else { 727 self->flags &= ~SBRDEC_LD_MPS_QMF; 728 } 729 } 730 break; 731 case SBR_BS_INTERRUPTION: 732 { 733 int elementIndex; 734 735 if (self == NULL) { 736 errorStatus = SBRDEC_NOT_INITIALIZED; 737 break; 738 } 739 740 /* Loop over SBR elements */ 741 for (elementIndex = 0; elementIndex < self->numSbrElements; elementIndex++) 742 { 743 HANDLE_SBR_HEADER_DATA hSbrHeader; 744 int headerIndex = getHeaderSlot(self->pSbrElement[elementIndex]->useFrameSlot, 745 self->pSbrElement[elementIndex]->useHeaderSlot); 746 747 hSbrHeader = &(self->sbrHeader[elementIndex][headerIndex]); 748 749 /* Set sync state UPSAMPLING for the corresponding slot. 750 This switches off bitstream parsing until a new header arrives. */ 751 hSbrHeader->syncState = UPSAMPLING; 752 hSbrHeader->status |= SBRDEC_HDR_STAT_UPDATE; 753 } 754 } 755 break; 756 default: 757 errorStatus = SBRDEC_SET_PARAM_FAIL; 758 break; 759 } /* switch(param) */ 760 761 return (errorStatus); 762} 763 764static 765SBRDEC_DRC_CHANNEL * sbrDecoder_drcGetChannel( const HANDLE_SBRDECODER self, const INT channel ) 766{ 767 SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL; 768 int elementIndex, elChanIdx=0, numCh=0; 769 770 for (elementIndex = 0; (elementIndex < (4)) && (numCh <= channel); elementIndex++) 771 { 772 SBR_DECODER_ELEMENT *pSbrElement = self->pSbrElement[elementIndex]; 773 int c, elChannels; 774 775 elChanIdx = 0; 776 if (pSbrElement == NULL) break; 777 778 /* Determine amount of channels for this element */ 779 switch (pSbrElement->elementID) { 780 case ID_CPE: elChannels = 2; 781 break; 782 case ID_LFE: 783 case ID_SCE: elChannels = 1; 784 break; 785 case ID_NONE: 786 default: elChannels = 0; 787 break; 788 } 789 790 /* Limit with actual allocated element channels */ 791 elChannels = FDKmin(elChannels, pSbrElement->nChannels); 792 793 for (c = 0; (c < elChannels) && (numCh <= channel); c++) { 794 if (pSbrElement->pSbrChannel[elChanIdx] != NULL) { 795 numCh++; 796 elChanIdx++; 797 } 798 } 799 } 800 elementIndex -= 1; 801 elChanIdx -= 1; 802 803 if (elChanIdx < 0 || elementIndex < 0) { 804 return NULL; 805 } 806 807 if ( self->pSbrElement[elementIndex] != NULL ) { 808 if ( self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx] != NULL ) 809 { 810 pSbrDrcChannelData = &self->pSbrElement[elementIndex]->pSbrChannel[elChanIdx]->SbrDec.sbrDrcChannel; 811 } 812 } 813 814 return (pSbrDrcChannelData); 815} 816 817SBR_ERROR sbrDecoder_drcFeedChannel ( HANDLE_SBRDECODER self, 818 INT ch, 819 UINT numBands, 820 FIXP_DBL *pNextFact_mag, 821 INT nextFact_exp, 822 SHORT drcInterpolationScheme, 823 UCHAR winSequence, 824 USHORT *pBandTop ) 825{ 826 SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL; 827 int band, isValidData = 0; 828 829 if (self == NULL) { 830 return SBRDEC_NOT_INITIALIZED; 831 } 832 if (ch > (6) || pNextFact_mag == NULL) { 833 return SBRDEC_SET_PARAM_FAIL; 834 } 835 836 /* Search for gain values different to 1.0f */ 837 for (band = 0; band < numBands; band += 1) { 838 if ( !((pNextFact_mag[band] == FL2FXCONST_DBL(0.5)) && (nextFact_exp == 1)) 839 && !((pNextFact_mag[band] == (FIXP_DBL)MAXVAL_DBL) && (nextFact_exp == 0)) ) { 840 isValidData = 1; 841 break; 842 } 843 } 844 845 /* Find the right SBR channel */ 846 pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch ); 847 848 if ( pSbrDrcChannelData != NULL ) { 849 if ( pSbrDrcChannelData->enable || isValidData ) 850 { /* Activate processing only with real and valid data */ 851 int i; 852 853 pSbrDrcChannelData->enable = 1; 854 pSbrDrcChannelData->numBandsNext = numBands; 855 856 pSbrDrcChannelData->winSequenceNext = winSequence; 857 pSbrDrcChannelData->drcInterpolationSchemeNext = drcInterpolationScheme; 858 pSbrDrcChannelData->nextFact_exp = nextFact_exp; 859 860 for (i = 0; i < (int)numBands; i++) { 861 pSbrDrcChannelData->bandTopNext[i] = pBandTop[i]; 862 pSbrDrcChannelData->nextFact_mag[i] = pNextFact_mag[i]; 863 } 864 } 865 } 866 867 return SBRDEC_OK; 868} 869 870 871void sbrDecoder_drcDisable ( HANDLE_SBRDECODER self, 872 INT ch ) 873{ 874 SBRDEC_DRC_CHANNEL *pSbrDrcChannelData = NULL; 875 876 if ( (self == NULL) 877 || (ch > (6)) 878 || (self->numSbrElements == 0) 879 || (self->numSbrChannels == 0) ) { 880 return; 881 } 882 883 /* Find the right SBR channel */ 884 pSbrDrcChannelData = sbrDecoder_drcGetChannel( self, ch ); 885 886 if ( pSbrDrcChannelData != NULL ) { 887 sbrDecoder_drcInitChannel( pSbrDrcChannelData ); 888 } 889} 890 891 892 893SBR_ERROR sbrDecoder_Parse( 894 HANDLE_SBRDECODER self, 895 HANDLE_FDK_BITSTREAM hBs, 896 int *count, 897 int bsPayLen, 898 int crcFlag, 899 MP4_ELEMENT_ID prevElement, 900 int elementIndex, 901 int fGlobalIndependencyFlag 902 ) 903{ 904 SBR_DECODER_ELEMENT *hSbrElement; 905 HANDLE_SBR_HEADER_DATA hSbrHeader; 906 HANDLE_SBR_CHANNEL *pSbrChannel; 907 908 SBR_FRAME_DATA *hFrameDataLeft; 909 SBR_FRAME_DATA *hFrameDataRight; 910 911 SBR_ERROR errorStatus = SBRDEC_OK; 912 SBR_SYNC_STATE initialSyncState; 913 SBR_HEADER_STATUS headerStatus = HEADER_NOT_PRESENT; 914 915 INT startPos; 916 INT CRCLen = 0; 917 918 int stereo; 919 int fDoDecodeSbrData = 1; 920 921 int lastSlot, lastHdrSlot = 0, thisHdrSlot; 922 923 /* Remember start position of SBR element */ 924 startPos = FDKgetValidBits(hBs); 925 926 /* SBR sanity checks */ 927 if ( self == NULL || self->pSbrElement[elementIndex] == NULL ) { 928 errorStatus = SBRDEC_NOT_INITIALIZED; 929 goto bail; 930 } 931 932 hSbrElement = self->pSbrElement[elementIndex]; 933 934 lastSlot = (hSbrElement->useFrameSlot > 0) ? hSbrElement->useFrameSlot-1 : self->numDelayFrames; 935 lastHdrSlot = hSbrElement->useHeaderSlot[lastSlot]; 936 thisHdrSlot = getHeaderSlot( hSbrElement->useFrameSlot, hSbrElement->useHeaderSlot ); /* Get a free header slot not used by frames not processed yet. */ 937 938 /* Assign the free slot to store a new header if there is one. */ 939 hSbrHeader = &self->sbrHeader[elementIndex][thisHdrSlot]; 940 941 pSbrChannel = hSbrElement->pSbrChannel; 942 stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0; 943 944 hFrameDataLeft = &self->pSbrElement[elementIndex]->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot]; 945 hFrameDataRight = &self->pSbrElement[elementIndex]->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot]; 946 947 initialSyncState = hSbrHeader->syncState; 948 949 /* reset PS flag; will be set after PS was found */ 950 self->flags &= ~SBRDEC_PS_DECODED; 951 952 if (hSbrHeader->status & SBRDEC_HDR_STAT_UPDATE) { 953 /* Got a new header from extern (e.g. from an ASC) */ 954 headerStatus = HEADER_OK; 955 hSbrHeader->status &= ~SBRDEC_HDR_STAT_UPDATE; 956 } 957 else if (thisHdrSlot != lastHdrSlot) { 958 /* Copy the last header into this slot otherwise the 959 header compare will trigger more HEADER_RESETs than needed. */ 960 copySbrHeader( hSbrHeader, &self->sbrHeader[elementIndex][lastHdrSlot] ); 961 } 962 963 /* 964 Check if bit stream data is valid and matches the element context 965 */ 966 if ( ((prevElement != ID_SCE) && (prevElement != ID_CPE)) || prevElement != hSbrElement->elementID) { 967 /* In case of LFE we also land here, since there is no LFE SBR element (do upsampling only) */ 968 fDoDecodeSbrData = 0; 969 } 970 971 if (fDoDecodeSbrData) 972 { 973 if ((INT)FDKgetValidBits(hBs) <= 0) { 974 fDoDecodeSbrData = 0; 975 } 976 } 977 978 /* 979 SBR CRC-check 980 */ 981 if (fDoDecodeSbrData) 982 { 983 if (crcFlag == 1) { 984 switch (self->coreCodec) { 985 case AOT_ER_AAC_ELD: 986 FDKpushFor (hBs, 10); 987 /* check sbrcrc later: we don't know the payload length now */ 988 break; 989 default: 990 CRCLen = bsPayLen - 10; /* change: 0 => i */ 991 if (CRCLen < 0) { 992 fDoDecodeSbrData = 0; 993 } else { 994 fDoDecodeSbrData = SbrCrcCheck (hBs, CRCLen); 995 } 996 break; 997 } 998 } 999 } /* if (fDoDecodeSbrData) */ 1000 1001 /* 1002 Read in the header data and issue a reset if change occured 1003 */ 1004 if (fDoDecodeSbrData) 1005 { 1006 int sbrHeaderPresent; 1007 1008 { 1009 sbrHeaderPresent = FDKreadBit(hBs); 1010 } 1011 1012 if ( sbrHeaderPresent ) { 1013 headerStatus = sbrGetHeaderData (hSbrHeader, 1014 hBs, 1015 self->flags, 1016 1); 1017 } 1018 1019 if (headerStatus == HEADER_RESET) 1020 { 1021 errorStatus = sbrDecoder_HeaderUpdate( 1022 self, 1023 hSbrHeader, 1024 headerStatus, 1025 pSbrChannel, 1026 hSbrElement->nChannels 1027 ); 1028 1029 if (errorStatus == SBRDEC_OK) { 1030 hSbrHeader->syncState = SBR_HEADER; 1031 } else { 1032 hSbrHeader->syncState = SBR_NOT_INITIALIZED; 1033 } 1034 } 1035 1036 if (errorStatus != SBRDEC_OK) { 1037 fDoDecodeSbrData = 0; 1038 } 1039 } /* if (fDoDecodeSbrData) */ 1040 1041 /* 1042 Print debugging output only if state has changed 1043 */ 1044 1045 /* read frame data */ 1046 if ((hSbrHeader->syncState >= SBR_HEADER) && fDoDecodeSbrData) { 1047 int sbrFrameOk; 1048 /* read the SBR element data */ 1049 if (stereo) { 1050 sbrFrameOk = sbrGetChannelPairElement(hSbrHeader, 1051 hFrameDataLeft, 1052 hFrameDataRight, 1053 hBs, 1054 self->flags, 1055 self->pSbrElement[elementIndex]->transposerSettings.overlap); 1056 } 1057 else { 1058 if (self->hParametricStereoDec != NULL) { 1059 /* update slot index for PS bitstream parsing */ 1060 self->hParametricStereoDec->bsLastSlot = self->hParametricStereoDec->bsReadSlot; 1061 self->hParametricStereoDec->bsReadSlot = hSbrElement->useFrameSlot; 1062 } 1063 sbrFrameOk = sbrGetSingleChannelElement(hSbrHeader, 1064 hFrameDataLeft, 1065 hBs, 1066 self->hParametricStereoDec, 1067 self->flags, 1068 self->pSbrElement[elementIndex]->transposerSettings.overlap); 1069 } 1070 if (!sbrFrameOk) { 1071 fDoDecodeSbrData = 0; 1072 } 1073 else { 1074 INT valBits; 1075 1076 if (bsPayLen > 0) { 1077 valBits = bsPayLen - ((INT)startPos - (INT)FDKgetValidBits(hBs)); 1078 } else { 1079 valBits = (INT)FDKgetValidBits(hBs); 1080 } 1081 1082 if ( crcFlag == 1 ) { 1083 switch (self->coreCodec) { 1084 case AOT_ER_AAC_ELD: 1085 { 1086 /* late crc check for eld */ 1087 INT payloadbits = (INT)startPos - (INT)FDKgetValidBits(hBs) - startPos; 1088 INT crcLen = payloadbits - 10; 1089 FDKpushBack(hBs, payloadbits); 1090 fDoDecodeSbrData = SbrCrcCheck (hBs, crcLen); 1091 FDKpushFor(hBs, crcLen); 1092 } 1093 break; 1094 default: 1095 break; 1096 } 1097 } 1098 1099 /* sanity check of remaining bits */ 1100 if (valBits < 0) { 1101 fDoDecodeSbrData = 0; 1102 } else { 1103 switch (self->coreCodec) { 1104 case AOT_SBR: 1105 case AOT_PS: 1106 case AOT_AAC_LC: 1107 { 1108 /* This sanity check is only meaningful with General Audio bitstreams */ 1109 int alignBits = valBits & 0x7; 1110 1111 if (valBits > alignBits) { 1112 fDoDecodeSbrData = 0; 1113 } 1114 } 1115 break; 1116 default: 1117 /* No sanity check available */ 1118 break; 1119 } 1120 } 1121 } 1122 } 1123 1124 if (!fDoDecodeSbrData) { 1125 /* Set error flag for this slot to trigger concealment */ 1126 self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 1; 1127 errorStatus = SBRDEC_PARSE_ERROR; 1128 } else { 1129 /* Everything seems to be ok so clear the error flag */ 1130 self->pSbrElement[elementIndex]->frameErrorFlag[hSbrElement->useFrameSlot] = 0; 1131 } 1132 1133 if (!stereo) { 1134 /* Turn coupling off explicitely to avoid access to absent right frame data 1135 that might occur with corrupt bitstreams. */ 1136 hFrameDataLeft->coupling = COUPLING_OFF; 1137 } 1138 1139bail: 1140 if (errorStatus == SBRDEC_OK) { 1141 if (headerStatus == HEADER_NOT_PRESENT) { 1142 /* Use the old header for this frame */ 1143 hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = lastHdrSlot; 1144 } else { 1145 /* Use the new header for this frame */ 1146 hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot] = thisHdrSlot; 1147 } 1148 1149 /* Move frame pointer to the next slot which is up to be decoded/applied next */ 1150 hSbrElement->useFrameSlot = (hSbrElement->useFrameSlot+1) % (self->numDelayFrames+1); 1151 } 1152 1153 *count -= startPos - FDKgetValidBits(hBs); 1154 1155 return errorStatus; 1156} 1157 1158 1159/** 1160 * \brief Render one SBR element into time domain signal. 1161 * \param self SBR decoder handle 1162 * \param timeData pointer to output buffer 1163 * \param interleaved flag indicating interleaved channel output 1164 * \param channelMapping pointer to UCHAR array where next 2 channel offsets are stored. 1165 * \param elementIndex enumerating index of the SBR element to render. 1166 * \param numInChannels number of channels from core coder (reading stride). 1167 * \param numOutChannels pointer to a location to return number of output channels. 1168 * \param psPossible flag indicating if PS is possible or not. 1169 * \return SBRDEC_OK if successfull, else error code 1170 */ 1171static SBR_ERROR 1172sbrDecoder_DecodeElement ( 1173 HANDLE_SBRDECODER self, 1174 INT_PCM *timeData, 1175 const int interleaved, 1176 const UCHAR *channelMapping, 1177 const int elementIndex, 1178 const int numInChannels, 1179 int *numOutChannels, 1180 const int psPossible 1181 ) 1182{ 1183 SBR_DECODER_ELEMENT *hSbrElement = self->pSbrElement[elementIndex]; 1184 HANDLE_SBR_CHANNEL *pSbrChannel = self->pSbrElement[elementIndex]->pSbrChannel; 1185 HANDLE_SBR_HEADER_DATA hSbrHeader = &self->sbrHeader[elementIndex][hSbrElement->useHeaderSlot[hSbrElement->useFrameSlot]]; 1186 HANDLE_PS_DEC h_ps_d = self->hParametricStereoDec; 1187 1188 /* get memory for frame data from scratch */ 1189 SBR_FRAME_DATA *hFrameDataLeft = &hSbrElement->pSbrChannel[0]->frameData[hSbrElement->useFrameSlot]; 1190 SBR_FRAME_DATA *hFrameDataRight = &hSbrElement->pSbrChannel[1]->frameData[hSbrElement->useFrameSlot]; 1191 1192 SBR_ERROR errorStatus = SBRDEC_OK; 1193 1194 1195 INT strideIn, strideOut, offset0, offset1; 1196 INT codecFrameSize = self->codecFrameSize; 1197 1198 int stereo = (hSbrElement->elementID == ID_CPE) ? 1 : 0; 1199 int numElementChannels = hSbrElement->nChannels; /* Number of channels of the current SBR element */ 1200 1201 /* Update the header error flag */ 1202 hSbrHeader->frameErrorFlag = hSbrElement->frameErrorFlag[hSbrElement->useFrameSlot]; 1203 1204 /* 1205 Prepare filterbank for upsampling if no valid bit stream data is available. 1206 */ 1207 if ( hSbrHeader->syncState == SBR_NOT_INITIALIZED ) 1208 { 1209 errorStatus = initHeaderData( 1210 hSbrHeader, 1211 self->sampleRateIn, 1212 self->sampleRateOut, 1213 codecFrameSize, 1214 self->flags 1215 ); 1216 1217 if (errorStatus != SBRDEC_OK) { 1218 return errorStatus; 1219 } 1220 1221 hSbrHeader->syncState = UPSAMPLING; 1222 1223 errorStatus = sbrDecoder_HeaderUpdate( 1224 self, 1225 hSbrHeader, 1226 HEADER_NOT_PRESENT, 1227 pSbrChannel, 1228 hSbrElement->nChannels 1229 ); 1230 1231 if (errorStatus != SBRDEC_OK) { 1232 hSbrHeader->syncState = SBR_NOT_INITIALIZED; 1233 return errorStatus; 1234 } 1235 } 1236 1237 /* reset */ 1238 if (hSbrHeader->status & SBRDEC_HDR_STAT_RESET) { 1239 int ch; 1240 for (ch = 0 ; ch < numElementChannels; ch++) { 1241 SBR_ERROR errorStatusTmp = SBRDEC_OK; 1242 1243 errorStatusTmp = resetSbrDec ( 1244 &pSbrChannel[ch]->SbrDec, 1245 hSbrHeader, 1246 &pSbrChannel[ch]->prevFrameData, 1247 self->flags & SBRDEC_LOW_POWER, 1248 self->synDownsampleFac 1249 ); 1250 1251 if (errorStatusTmp != SBRDEC_OK) { 1252 errorStatus = errorStatusTmp; 1253 } 1254 } 1255 hSbrHeader->status &= ~SBRDEC_HDR_STAT_RESET; 1256 } 1257 1258 /* decoding */ 1259 if ( (hSbrHeader->syncState == SBR_ACTIVE) 1260 || ((hSbrHeader->syncState == SBR_HEADER) && (hSbrHeader->frameErrorFlag == 0)) ) 1261 { 1262 errorStatus = SBRDEC_OK; 1263 1264 decodeSbrData (hSbrHeader, 1265 hFrameDataLeft, 1266 &pSbrChannel[0]->prevFrameData, 1267 (stereo) ? hFrameDataRight : NULL, 1268 (stereo) ? &pSbrChannel[1]->prevFrameData : NULL); 1269 1270 1271 /* Now we have a full parameter set and can do parameter 1272 based concealment instead of plain upsampling. */ 1273 hSbrHeader->syncState = SBR_ACTIVE; 1274 } 1275 1276 /* decode PS data if available */ 1277 if (h_ps_d != NULL && psPossible) { 1278 int applyPs = 1; 1279 1280 /* define which frame delay line slot to process */ 1281 h_ps_d->processSlot = hSbrElement->useFrameSlot; 1282 1283 applyPs = DecodePs(h_ps_d, hSbrHeader->frameErrorFlag); 1284 self->flags |= (applyPs) ? SBRDEC_PS_DECODED : 0; 1285 } 1286 1287 /* Set strides for reading and writing */ 1288 if (interleaved) { 1289 strideIn = numInChannels; 1290 if ( psPossible ) 1291 strideOut = (numInChannels < 2) ? 2 : numInChannels; 1292 else 1293 strideOut = numInChannels; 1294 offset0 = channelMapping[0]; 1295 offset1 = channelMapping[1]; 1296 } else { 1297 strideIn = 1; 1298 strideOut = 1; 1299 offset0 = channelMapping[0]*2*codecFrameSize; 1300 offset1 = channelMapping[1]*2*codecFrameSize; 1301 } 1302 1303 /* use same buffers for left and right channel and apply PS per timeslot */ 1304 /* Process left channel */ 1305//FDKprintf("self->codecFrameSize %d\t%d\n",self->codecFrameSize,self->sampleRateIn); 1306 sbr_dec (&pSbrChannel[0]->SbrDec, 1307 timeData + offset0, 1308 timeData + offset0, 1309 &pSbrChannel[1]->SbrDec, 1310 timeData + offset1, 1311 strideIn, 1312 strideOut, 1313 hSbrHeader, 1314 hFrameDataLeft, 1315 &pSbrChannel[0]->prevFrameData, 1316 (hSbrHeader->syncState == SBR_ACTIVE), 1317 h_ps_d, 1318 self->flags 1319 ); 1320 1321 if (stereo) { 1322 /* Process right channel */ 1323 sbr_dec (&pSbrChannel[1]->SbrDec, 1324 timeData + offset1, 1325 timeData + offset1, 1326 NULL, 1327 NULL, 1328 strideIn, 1329 strideOut, 1330 hSbrHeader, 1331 hFrameDataRight, 1332 &pSbrChannel[1]->prevFrameData, 1333 (hSbrHeader->syncState == SBR_ACTIVE), 1334 NULL, 1335 self->flags 1336 ); 1337 } 1338 1339 if (h_ps_d != NULL) { 1340 /* save PS status for next run */ 1341 h_ps_d->psDecodedPrv = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0 ; 1342 } 1343 1344 if ( psPossible 1345 ) 1346 { 1347 FDK_ASSERT(strideOut > 1); 1348 if ( !(self->flags & SBRDEC_PS_DECODED) ) { 1349 /* A decoder which is able to decode PS has to produce a stereo output even if no PS data is availble. */ 1350 /* So copy left channel to right channel. */ 1351 if (interleaved) { 1352 INT_PCM *ptr; 1353 INT i; 1354 FDK_ASSERT(strideOut == 2); 1355 1356 ptr = timeData; 1357 for (i = codecFrameSize; i--; ) 1358 { 1359 INT_PCM tmp; /* This temporal variable is required because some compilers can't do *ptr++ = *ptr++ correctly. */ 1360 tmp = *ptr++; *ptr++ = tmp; 1361 tmp = *ptr++; *ptr++ = tmp; 1362 } 1363 } else { 1364 FDKmemcpy( timeData+2*codecFrameSize, timeData, 2*codecFrameSize*sizeof(INT_PCM) ); 1365 } 1366 } 1367 *numOutChannels = 2; /* Output minimum two channels when PS is enabled. */ 1368 } 1369 1370 return errorStatus; 1371} 1372 1373 1374SBR_ERROR sbrDecoder_Apply ( HANDLE_SBRDECODER self, 1375 INT_PCM *timeData, 1376 int *numChannels, 1377 int *sampleRate, 1378 const UCHAR channelMapping[(6)], 1379 const int interleaved, 1380 const int coreDecodedOk, 1381 UCHAR *psDecoded ) 1382{ 1383 SBR_ERROR errorStatus = SBRDEC_OK; 1384 1385 int psPossible = 0; 1386 int sbrElementNum; 1387 int numCoreChannels = *numChannels; 1388 int numSbrChannels = 0; 1389 1390 psPossible = *psDecoded; 1391 1392 if (self->numSbrElements < 1) { 1393 /* exit immediately to avoid access violations */ 1394 return SBRDEC_CREATE_ERROR; 1395 } 1396 1397 /* Sanity check of allocated SBR elements. */ 1398 for (sbrElementNum=0; sbrElementNum<self->numSbrElements; sbrElementNum++) { 1399 if (self->pSbrElement[sbrElementNum] == NULL) { 1400 return SBRDEC_CREATE_ERROR; 1401 } 1402 } 1403 1404 if (self->numSbrElements != 1 || self->pSbrElement[0]->elementID != ID_SCE) { 1405 psPossible = 0; 1406 } 1407 1408 1409 /* In case of non-interleaved time domain data and upsampling, make room for bigger SBR output. */ 1410 if (self->synDownsampleFac == 1 && interleaved == 0) { 1411 int c, outputFrameSize; 1412 1413 outputFrameSize = 1414 self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_channels 1415 * self->pSbrElement[0]->pSbrChannel[0]->SbrDec.SynthesisQMF.no_col; 1416 1417 for (c=numCoreChannels-1; c>0; c--) { 1418 FDKmemmove(timeData + c*outputFrameSize, timeData + c*self->codecFrameSize , self->codecFrameSize*sizeof(INT_PCM)); 1419 } 1420 } 1421 1422 1423 /* Make sure that even if no SBR data was found/parsed *psDecoded is returned 1 if psPossible was 0. */ 1424 if (psPossible == 0) { 1425 self->flags &= ~SBRDEC_PS_DECODED; 1426 } 1427 1428 /* Loop over SBR elements */ 1429 for (sbrElementNum = 0; sbrElementNum<self->numSbrElements; sbrElementNum++) 1430 { 1431 int numElementChan; 1432 1433 if (psPossible && self->pSbrElement[sbrElementNum]->pSbrChannel[1] == NULL) { 1434 errorStatus = SBRDEC_UNSUPPORTED_CONFIG; 1435 goto bail; 1436 } 1437 1438 numElementChan = (self->pSbrElement[sbrElementNum]->elementID == ID_CPE) ? 2 : 1; 1439 1440 /* If core signal is bad then force upsampling */ 1441 if ( ! coreDecodedOk ) { 1442 self->pSbrElement[sbrElementNum]->frameErrorFlag[self->pSbrElement[sbrElementNum]->useFrameSlot] = 1; 1443 } 1444 1445 errorStatus = sbrDecoder_DecodeElement ( 1446 self, 1447 timeData, 1448 interleaved, 1449 channelMapping, 1450 sbrElementNum, 1451 numCoreChannels, 1452 &numElementChan, 1453 psPossible 1454 ); 1455 1456 if (errorStatus != SBRDEC_OK) { 1457 goto bail; 1458 } 1459 1460 numSbrChannels += numElementChan; 1461 channelMapping += numElementChan; 1462 1463 if (numSbrChannels >= numCoreChannels) { 1464 break; 1465 } 1466 } 1467 1468 /* Update numChannels and samplerate */ 1469 *numChannels = numSbrChannels; 1470 *sampleRate = self->sampleRateOut; 1471 *psDecoded = (self->flags & SBRDEC_PS_DECODED) ? 1 : 0; 1472 1473 1474 1475bail: 1476 1477 return errorStatus; 1478} 1479 1480 1481SBR_ERROR sbrDecoder_Close ( HANDLE_SBRDECODER *pSelf ) 1482{ 1483 HANDLE_SBRDECODER self = *pSelf; 1484 int i; 1485 1486 if (self != NULL) 1487 { 1488 if (self->hParametricStereoDec != NULL) { 1489 DeletePsDec ( &self->hParametricStereoDec ); 1490 } 1491 1492 if (self->workBuffer1 != NULL) { 1493 FreeRam_SbrDecWorkBuffer1(&self->workBuffer1); 1494 } 1495 if (self->workBuffer2 != NULL) { 1496 FreeRam_SbrDecWorkBuffer2(&self->workBuffer2); 1497 } 1498 1499 for (i = 0; i < (4); i++) { 1500 sbrDecoder_DestroyElement( self, i ); 1501 } 1502 1503 FreeRam_SbrDecoder(pSelf); 1504 } 1505 1506 return SBRDEC_OK; 1507} 1508 1509 1510INT sbrDecoder_GetLibInfo( LIB_INFO *info ) 1511{ 1512 int i; 1513 1514 if (info == NULL) { 1515 return -1; 1516 } 1517 1518 /* search for next free tab */ 1519 for (i = 0; i < FDK_MODULE_LAST; i++) { 1520 if (info[i].module_id == FDK_NONE) 1521 break; 1522 } 1523 if (i == FDK_MODULE_LAST) 1524 return -1; 1525 info += i; 1526 1527 info->module_id = FDK_SBRDEC; 1528 info->version = LIB_VERSION(SBRDECODER_LIB_VL0, SBRDECODER_LIB_VL1, SBRDECODER_LIB_VL2); 1529 LIB_VERSION_STRING(info); 1530 info->build_date = (char *)SBRDECODER_LIB_BUILD_DATE; 1531 info->build_time = (char *)SBRDECODER_LIB_BUILD_TIME; 1532 info->title = (char *)SBRDECODER_LIB_TITLE; 1533 1534 /* Set flags */ 1535 info->flags = 0 1536 | CAPF_SBR_HQ 1537 | CAPF_SBR_LP 1538 | CAPF_SBR_PS_MPEG 1539 | CAPF_SBR_CONCEALMENT 1540 | CAPF_SBR_DRC 1541 ; 1542 /* End of flags */ 1543 1544 return 0; 1545} 1546 1547