1 2 /* ----------------------------------------------------------------------------------------------------------- 3 Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5 Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16 of the MPEG specifications. 17 18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20 individually for the purpose of encoding or decoding bit streams in products that are compliant with 21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23 software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27 applications information and documentation. 28 29 2. COPYRIGHT LICENSE 30 31 Redistribution and use in source and binary forms, with or without modification, are permitted without 32 payment of copyright license fees provided that you satisfy the following conditions: 33 34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35 your modifications thereto in source code form. 36 37 You must retain the complete text of this software license in the documentation and/or other materials 38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40 modifications thereto to recipients of copies in binary form. 41 42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43 prior written permission. 44 45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46 software or your modifications thereto. 47 48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49 and 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 53 3. NO PATENT LICENSE 54 55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57 respect to this software. 58 59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60 by appropriate patent licenses. 61 62 4. DISCLAIMER 63 64 This 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 66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69 or business interruption, however caused and on any theory of liability, whether in contract, strict 70 liability, or tort (including negligence), arising in any way out of the use of this software, even if 71 advised of the possibility of such damage. 72 73 5. CONTACT INFORMATION 74 75 Fraunhofer Institute for Integrated Circuits IIS 76 Attention: Audio and Multimedia Departments - FDK AAC LL 77 Am Wolfsmantel 33 78 91058 Erlangen, Germany 79 80 www.iis.fraunhofer.de/amm 81 amm-info (at) iis.fraunhofer.de 82 ----------------------------------------------------------------------------------------------------------- */ 83 84 /******************************** MPEG Audio Encoder ************************** 85 86 Initial author: M. Werner 87 contents/description: Bitstream encoder 88 89 ******************************************************************************/ 90 91 #include "bitenc.h" 92 #include "bit_cnt.h" 93 #include "dyn_bits.h" 94 #include "qc_data.h" 95 #include "interface.h" 96 #include "aacEnc_ram.h" 97 98 99 #include "tpenc_lib.h" 100 101 #include "FDK_tools_rom.h" /* needed for the bitstream syntax tables */ 102 103 static const int globalGainOffset = 100; 104 static const int icsReservedBit = 0; 105 static const int noiseOffset = 90; 106 107 /***************************************************************************** 108 109 functionname: FDKaacEnc_encodeSpectralData 110 description: encode spectral data 111 returns: the number of written bits 112 input: 113 output: 114 115 *****************************************************************************/ 116 static INT FDKaacEnc_encodeSpectralData(INT *sfbOffset, 117 SECTION_DATA *sectionData, 118 SHORT *quantSpectrum, 119 HANDLE_FDK_BITSTREAM hBitStream) 120 { 121 INT i,sfb; 122 INT dbgVal = FDKgetValidBits(hBitStream); 123 124 for(i=0;i<sectionData->noOfSections;i++) 125 { 126 if(sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO) 127 { 128 /* huffencode spectral data for this huffsection */ 129 INT tmp = sectionData->huffsection[i].sfbStart+sectionData->huffsection[i].sfbCnt; 130 for(sfb=sectionData->huffsection[i].sfbStart; sfb<tmp; sfb++) 131 { 132 FDKaacEnc_codeValues(quantSpectrum+sfbOffset[sfb], 133 sfbOffset[sfb+1]-sfbOffset[sfb], 134 sectionData->huffsection[i].codeBook, 135 hBitStream); 136 } 137 } 138 } 139 return(FDKgetValidBits(hBitStream)-dbgVal); 140 } 141 142 /***************************************************************************** 143 144 functionname:FDKaacEnc_encodeGlobalGain 145 description: encodes Global Gain (common scale factor) 146 returns: the number of static bits 147 input: 148 output: 149 150 *****************************************************************************/ 151 static INT FDKaacEnc_encodeGlobalGain(INT globalGain, 152 INT scalefac, 153 HANDLE_FDK_BITSTREAM hBitStream, 154 INT mdctScale) 155 { 156 if (hBitStream != NULL) { 157 FDKwriteBits(hBitStream,globalGain - scalefac + globalGainOffset-4*(LOG_NORM_PCM-mdctScale),8); 158 } 159 return (8); 160 } 161 162 163 /***************************************************************************** 164 165 functionname:FDKaacEnc_encodeIcsInfo 166 description: encodes Ics Info 167 returns: the number of static bits 168 input: 169 output: 170 171 *****************************************************************************/ 172 173 static INT FDKaacEnc_encodeIcsInfo(INT blockType, 174 INT windowShape, 175 INT groupingMask, 176 INT maxSfbPerGroup, 177 HANDLE_FDK_BITSTREAM hBitStream, 178 UINT syntaxFlags) 179 { 180 INT statBits; 181 182 if (blockType == SHORT_WINDOW) { 183 statBits = 8 + TRANS_FAC - 1; 184 } else { 185 if (syntaxFlags & AC_ELD) { 186 statBits = 6; 187 } else 188 { 189 statBits = (!(syntaxFlags & AC_SCALABLE)) ? 11 : 10; 190 } 191 } 192 193 if (hBitStream != NULL) { 194 195 if (!(syntaxFlags & AC_ELD)){ 196 FDKwriteBits(hBitStream,icsReservedBit,1); 197 FDKwriteBits(hBitStream,blockType,2); 198 FDKwriteBits(hBitStream, (windowShape == LOL_WINDOW) ? KBD_WINDOW : windowShape,1); 199 } 200 201 switch(blockType){ 202 case LONG_WINDOW: 203 case START_WINDOW: 204 case STOP_WINDOW: 205 FDKwriteBits(hBitStream,maxSfbPerGroup,6); 206 207 if (!(syntaxFlags & (AC_SCALABLE|AC_ELD)) ) { /* If not scalable syntax then ... */ 208 /* No predictor data present */ 209 FDKwriteBits(hBitStream, 0, 1); 210 } 211 break; 212 213 case SHORT_WINDOW: 214 FDKwriteBits(hBitStream,maxSfbPerGroup,4); 215 216 /* Write grouping bits */ 217 FDKwriteBits(hBitStream,groupingMask,TRANS_FAC-1); 218 break; 219 } 220 } 221 222 return (statBits); 223 } 224 225 /***************************************************************************** 226 227 functionname: FDKaacEnc_encodeSectionData 228 description: encode section data (common Huffman codebooks for adjacent 229 SFB's) 230 returns: none 231 input: 232 output: 233 234 *****************************************************************************/ 235 static INT FDKaacEnc_encodeSectionData(SECTION_DATA *sectionData, 236 HANDLE_FDK_BITSTREAM hBitStream, 237 UINT useVCB11) 238 { 239 if (hBitStream != NULL) { 240 INT sectEscapeVal=0,sectLenBits=0; 241 INT sectLen; 242 INT i; 243 INT dbgVal=FDKgetValidBits(hBitStream); 244 INT sectCbBits = 4; 245 246 switch(sectionData->blockType) 247 { 248 case LONG_WINDOW: 249 case START_WINDOW: 250 case STOP_WINDOW: 251 sectEscapeVal = SECT_ESC_VAL_LONG; 252 sectLenBits = SECT_BITS_LONG; 253 break; 254 255 case SHORT_WINDOW: 256 sectEscapeVal = SECT_ESC_VAL_SHORT; 257 sectLenBits = SECT_BITS_SHORT; 258 break; 259 } 260 261 for(i=0;i<sectionData->noOfSections;i++) 262 { 263 INT codeBook = sectionData->huffsection[i].codeBook; 264 265 FDKwriteBits(hBitStream,codeBook,sectCbBits); 266 267 { 268 sectLen = sectionData->huffsection[i].sfbCnt; 269 270 while(sectLen >= sectEscapeVal) 271 { 272 FDKwriteBits(hBitStream,sectEscapeVal,sectLenBits); 273 sectLen-=sectEscapeVal; 274 } 275 FDKwriteBits(hBitStream,sectLen,sectLenBits); 276 } 277 } 278 return(FDKgetValidBits(hBitStream)-dbgVal); 279 } 280 return (0); 281 } 282 283 /***************************************************************************** 284 285 functionname: FDKaacEnc_encodeScaleFactorData 286 description: encode DPCM coded scale factors 287 returns: none 288 input: 289 output: 290 291 *****************************************************************************/ 292 static INT FDKaacEnc_encodeScaleFactorData(UINT *maxValueInSfb, 293 SECTION_DATA *sectionData, 294 INT *scalefac, 295 HANDLE_FDK_BITSTREAM hBitStream, 296 INT *RESTRICT noiseNrg, 297 const INT *isScale, 298 INT globalGain) 299 { 300 if (hBitStream != NULL) { 301 INT i,j,lastValScf,deltaScf; 302 INT deltaPns; 303 INT lastValPns = 0; 304 INT noisePCMFlag = TRUE; 305 INT lastValIs; 306 307 INT dbgVal = FDKgetValidBits(hBitStream); 308 309 lastValScf=scalefac[sectionData->firstScf]; 310 lastValPns = globalGain-scalefac[sectionData->firstScf]+globalGainOffset-4*LOG_NORM_PCM-noiseOffset; 311 lastValIs = 0; 312 313 for(i=0; i<sectionData->noOfSections; i++){ 314 if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) { 315 316 if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || 317 (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) 318 { 319 INT sfbStart = sectionData->huffsection[i].sfbStart; 320 INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt; 321 for(j=sfbStart; j<tmp; j++) { 322 INT deltaIs = isScale[j]-lastValIs; 323 lastValIs = isScale[j]; 324 if(FDKaacEnc_codeScalefactorDelta(deltaIs,hBitStream)) { 325 return(1); 326 } 327 } /* sfb */ 328 } 329 else if(sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) { 330 INT sfbStart = sectionData->huffsection[i].sfbStart; 331 INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt; 332 for(j=sfbStart; j<tmp; j++) { 333 deltaPns = noiseNrg[j]-lastValPns; 334 lastValPns = noiseNrg[j]; 335 336 if(noisePCMFlag){ 337 FDKwriteBits(hBitStream,deltaPns+(1<<(PNS_PCM_BITS-1)),PNS_PCM_BITS); 338 noisePCMFlag = FALSE; 339 } 340 else { 341 if(FDKaacEnc_codeScalefactorDelta(deltaPns,hBitStream)) { 342 return(1); 343 } 344 } 345 } /* sfb */ 346 } 347 else { 348 INT tmp = sectionData->huffsection[i].sfbStart+sectionData->huffsection[i].sfbCnt; 349 for(j=sectionData->huffsection[i].sfbStart; j<tmp; j++){ 350 /* 351 check if we can repeat the last value to save bits 352 */ 353 if(maxValueInSfb[j] == 0) 354 deltaScf = 0; 355 else{ 356 deltaScf = -(scalefac[j]-lastValScf); 357 lastValScf = scalefac[j]; 358 } 359 if(FDKaacEnc_codeScalefactorDelta(deltaScf,hBitStream)){ 360 return(1); 361 } 362 } /* sfb */ 363 } /* code scalefactor */ 364 } /* sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO */ 365 } /* section loop */ 366 367 return(FDKgetValidBits(hBitStream)-dbgVal); 368 } /* if (hBitStream != NULL) */ 369 370 return (0); 371 } 372 373 /***************************************************************************** 374 375 functionname:encodeMsInfo 376 description: encodes MS-Stereo Info 377 returns: the number of static bits 378 input: 379 output: 380 381 *****************************************************************************/ 382 static INT FDKaacEnc_encodeMSInfo(INT sfbCnt, 383 INT grpSfb, 384 INT maxSfb, 385 INT msDigest, 386 INT *jsFlags, 387 HANDLE_FDK_BITSTREAM hBitStream) 388 { 389 INT sfb, sfbOff, msBits = 0; 390 391 if (hBitStream != NULL) 392 { 393 switch(msDigest) 394 { 395 case MS_NONE: 396 FDKwriteBits(hBitStream,SI_MS_MASK_NONE,2); 397 msBits += 2; 398 break; 399 400 case MS_ALL: 401 FDKwriteBits(hBitStream,SI_MS_MASK_ALL,2); 402 msBits += 2; 403 break; 404 405 case MS_SOME: 406 FDKwriteBits(hBitStream,SI_MS_MASK_SOME,2); 407 msBits += 2; 408 for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb) 409 { 410 for(sfb=0; sfb<maxSfb; sfb++) 411 { 412 if(jsFlags[sfbOff+sfb] & MS_ON){ 413 FDKwriteBits(hBitStream,1,1); 414 } 415 else{ 416 FDKwriteBits(hBitStream,0,1); 417 } 418 msBits += 1; 419 } 420 } 421 break; 422 } 423 } 424 else { 425 msBits += 2; 426 if (msDigest == MS_SOME) { 427 for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb) { 428 for(sfb=0; sfb<maxSfb; sfb++) { 429 msBits += 1; 430 } 431 } 432 } 433 } 434 return (msBits); 435 } 436 437 /***************************************************************************** 438 439 functionname: FDKaacEnc_encodeTnsDataPresent 440 description: encode TNS data (filter order, coeffs, ..) 441 returns: the number of static bits 442 input: 443 output: 444 445 *****************************************************************************/ 446 static INT FDKaacEnc_encodeTnsDataPresent(TNS_INFO *tnsInfo, 447 INT blockType, 448 HANDLE_FDK_BITSTREAM hBitStream) 449 { 450 if ( (hBitStream!=NULL) && (tnsInfo!=NULL) ) 451 { 452 INT i, tnsPresent = 0; 453 INT numOfWindows = (blockType==SHORT_WINDOW?TRANS_FAC:1); 454 455 for (i=0; i<numOfWindows; i++) { 456 if (tnsInfo->numOfFilters[i]!=0) { 457 tnsPresent=1; 458 break; 459 } 460 } 461 462 if (tnsPresent==0) { 463 FDKwriteBits(hBitStream,0,1); 464 } else { 465 FDKwriteBits(hBitStream,1,1); 466 } 467 } 468 return (1); 469 } 470 471 /***************************************************************************** 472 473 functionname: FDKaacEnc_encodeTnsData 474 description: encode TNS data (filter order, coeffs, ..) 475 returns: the number of static bits 476 input: 477 output: 478 479 *****************************************************************************/ 480 static INT FDKaacEnc_encodeTnsData(TNS_INFO *tnsInfo, 481 INT blockType, 482 HANDLE_FDK_BITSTREAM hBitStream) 483 { 484 INT tnsBits = 0; 485 486 if (tnsInfo!=NULL) { 487 488 INT i,j,k; 489 INT tnsPresent = 0; 490 INT coefBits; 491 INT numOfWindows=(blockType==SHORT_WINDOW?TRANS_FAC:1); 492 493 for (i=0; i<numOfWindows; i++) { 494 if (tnsInfo->numOfFilters[i]!=0) { 495 tnsPresent=1; 496 } 497 } 498 499 if (hBitStream != NULL) 500 { 501 if (tnsPresent==1) { /* there is data to be written*/ 502 for (i=0; i<numOfWindows; i++) { 503 FDKwriteBits(hBitStream,tnsInfo->numOfFilters[i],(blockType==SHORT_WINDOW?1:2)); 504 tnsBits += (blockType==SHORT_WINDOW?1:2); 505 if (tnsInfo->numOfFilters[i]) { 506 FDKwriteBits(hBitStream,(tnsInfo->coefRes[i]==4?1:0),1); 507 tnsBits += 1; 508 } 509 for (j=0; j<tnsInfo->numOfFilters[i]; j++) { 510 FDKwriteBits(hBitStream,tnsInfo->length[i][j],(blockType==SHORT_WINDOW?4:6)); 511 tnsBits += (blockType==SHORT_WINDOW?4:6); 512 FDK_ASSERT(tnsInfo->order[i][j] <= 12); 513 FDKwriteBits(hBitStream,tnsInfo->order[i][j],(blockType==SHORT_WINDOW?3:5)); 514 tnsBits += (blockType==SHORT_WINDOW?3:5); 515 if (tnsInfo->order[i][j]){ 516 FDKwriteBits(hBitStream,tnsInfo->direction[i][j],1); 517 tnsBits +=1; /*direction*/ 518 if(tnsInfo->coefRes[i] == 4) { 519 coefBits = 3; 520 for(k=0; k<tnsInfo->order[i][j]; k++) { 521 if (tnsInfo->coef[i][j][k]> 3 || 522 tnsInfo->coef[i][j][k]< -4) { 523 coefBits = 4; 524 break; 525 } 526 } 527 } else { 528 coefBits = 2; 529 for(k=0; k<tnsInfo->order[i][j]; k++) { 530 if ( tnsInfo->coef[i][j][k]> 1 531 || tnsInfo->coef[i][j][k]< -2) { 532 coefBits = 3; 533 break; 534 } 535 } 536 } 537 FDKwriteBits(hBitStream,-(coefBits - tnsInfo->coefRes[i]),1); /*coef_compres*/ 538 tnsBits +=1; /*coef_compression */ 539 for (k=0; k<tnsInfo->order[i][j]; k++ ) { 540 static const INT rmask[] = {0,1,3,7,15}; 541 FDKwriteBits(hBitStream,tnsInfo->coef[i][j][k] & rmask[coefBits],coefBits); 542 tnsBits += coefBits; 543 } 544 } 545 } 546 } 547 } 548 } 549 else { 550 if (tnsPresent != 0) { 551 for (i=0; i<numOfWindows; i++) { 552 tnsBits += (blockType==SHORT_WINDOW?1:2); 553 if (tnsInfo->numOfFilters[i]) { 554 tnsBits += 1; 555 for (j=0; j<tnsInfo->numOfFilters[i]; j++) { 556 tnsBits += (blockType==SHORT_WINDOW?4:6); 557 tnsBits += (blockType==SHORT_WINDOW?3:5); 558 if (tnsInfo->order[i][j]) { 559 tnsBits +=1; /*direction*/ 560 tnsBits +=1; /*coef_compression */ 561 if (tnsInfo->coefRes[i] == 4) { 562 coefBits=3; 563 for (k=0; k<tnsInfo->order[i][j]; k++) { 564 if (tnsInfo->coef[i][j][k]> 3 || tnsInfo->coef[i][j][k]< -4) { 565 coefBits = 4; 566 break; 567 } 568 } 569 } 570 else { 571 coefBits = 2; 572 for (k=0; k<tnsInfo->order[i][j]; k++) { 573 if (tnsInfo->coef[i][j][k]> 1 || tnsInfo->coef[i][j][k]< -2) { 574 coefBits = 3; 575 break; 576 } 577 } 578 } 579 for (k=0; k<tnsInfo->order[i][j]; k++) { 580 tnsBits += coefBits; 581 } 582 } 583 } 584 } 585 } 586 } 587 } 588 } /* (tnsInfo!=NULL) */ 589 590 return (tnsBits); 591 } 592 593 /***************************************************************************** 594 595 functionname: FDKaacEnc_encodeGainControlData 596 description: unsupported 597 returns: none 598 input: 599 output: 600 601 *****************************************************************************/ 602 static INT FDKaacEnc_encodeGainControlData(HANDLE_FDK_BITSTREAM hBitStream) 603 { 604 if (hBitStream != NULL) { 605 FDKwriteBits(hBitStream,0,1); 606 } 607 return (1); 608 } 609 610 /***************************************************************************** 611 612 functionname: FDKaacEnc_encodePulseData 613 description: not supported yet (dummy) 614 returns: none 615 input: 616 output: 617 618 *****************************************************************************/ 619 static INT FDKaacEnc_encodePulseData(HANDLE_FDK_BITSTREAM hBitStream) 620 { 621 if (hBitStream != NULL) { 622 FDKwriteBits(hBitStream,0,1); 623 } 624 return (1); 625 } 626 627 628 /***************************************************************************** 629 630 functionname: FDKaacEnc_writeExtensionPayload 631 description: write extension payload to bitstream 632 returns: number of written bits 633 input: 634 output: 635 636 *****************************************************************************/ 637 static INT FDKaacEnc_writeExtensionPayload( HANDLE_FDK_BITSTREAM hBitStream, 638 EXT_PAYLOAD_TYPE extPayloadType, 639 const UCHAR *extPayloadData, 640 INT extPayloadBits 641 ) 642 { 643 #define EXT_TYPE_BITS ( 4 ) 644 #define DATA_EL_VERSION_BITS ( 4 ) 645 #define FILL_NIBBLE_BITS ( 4 ) 646 647 INT extBitsUsed = 0; 648 649 if (extPayloadBits >= EXT_TYPE_BITS) 650 { 651 UCHAR fillByte = 0x00; /* for EXT_FIL and EXT_FILL_DATA */ 652 653 if (hBitStream != NULL) { 654 FDKwriteBits(hBitStream, extPayloadType, EXT_TYPE_BITS); 655 } 656 extBitsUsed += EXT_TYPE_BITS; 657 658 switch (extPayloadType) { 659 case EXT_DYNAMIC_RANGE: 660 /* case EXT_SAC_DATA: */ 661 case EXT_SBR_DATA: 662 case EXT_SBR_DATA_CRC: 663 if (hBitStream != NULL) { 664 int i, writeBits = extPayloadBits; 665 for (i=0; writeBits >= 8; i++) { 666 FDKwriteBits(hBitStream, extPayloadData[i], 8); 667 writeBits -= 8; 668 } 669 if (writeBits > 0) { 670 FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); 671 } 672 } 673 extBitsUsed += extPayloadBits; 674 break; 675 676 case EXT_DATA_ELEMENT: 677 { 678 INT dataElementLength = (extPayloadBits+7)>>3; 679 INT cnt = dataElementLength; 680 int loopCounter = 1; 681 682 while (dataElementLength >= 255) { 683 loopCounter++; 684 dataElementLength -= 255; 685 } 686 687 if (hBitStream != NULL) { 688 int i; 689 FDKwriteBits(hBitStream, 0x00, DATA_EL_VERSION_BITS); /* data_element_version = ANC_DATA */ 690 691 for (i=1; i<loopCounter; i++) { 692 FDKwriteBits(hBitStream, 255, 8); 693 } 694 FDKwriteBits(hBitStream, dataElementLength, 8); 695 696 for (i=0; i<cnt; i++) { 697 FDKwriteBits(hBitStream, extPayloadData[i], 8); 698 } 699 } 700 extBitsUsed += DATA_EL_VERSION_BITS + (loopCounter*8) + (cnt*8); 701 } 702 break; 703 704 case EXT_FILL_DATA: 705 fillByte = 0xA5; 706 case EXT_FIL: 707 default: 708 if (hBitStream != NULL) { 709 int writeBits = extPayloadBits; 710 FDKwriteBits(hBitStream, 0x00, FILL_NIBBLE_BITS); 711 writeBits -= 8; /* acount for the extension type and the fill nibble */ 712 while (writeBits >= 8) { 713 FDKwriteBits(hBitStream, fillByte, 8); 714 writeBits -= 8; 715 } 716 } 717 extBitsUsed += FILL_NIBBLE_BITS + (extPayloadBits & ~0x7) - 8; 718 break; 719 } 720 } 721 722 return (extBitsUsed); 723 } 724 725 726 /***************************************************************************** 727 728 functionname: FDKaacEnc_writeDataStreamElement 729 description: write data stream elements like ancillary data ... 730 returns: the amount of used bits 731 input: 732 output: 733 734 ******************************************************************************/ 735 static INT FDKaacEnc_writeDataStreamElement( HANDLE_TRANSPORTENC hTpEnc, 736 INT elementInstanceTag, 737 INT dataPayloadBytes, 738 UCHAR *dataBuffer, 739 UINT alignAnchor ) 740 { 741 #define DATA_BYTE_ALIGN_FLAG ( 0 ) 742 743 #define EL_INSTANCE_TAG_BITS ( 4 ) 744 #define DATA_BYTE_ALIGN_FLAG_BITS ( 1 ) 745 #define DATA_LEN_COUNT_BITS ( 8 ) 746 #define DATA_LEN_ESC_COUNT_BITS ( 8 ) 747 748 #define MAX_DATA_ALIGN_BITS ( 7 ) 749 #define MAX_DSE_DATA_BYTES ( 510 ) 750 751 INT dseBitsUsed = 0; 752 753 while (dataPayloadBytes > 0) 754 { 755 int esc_count = -1; 756 int cnt = 0; 757 INT crcReg = -1; 758 759 dseBitsUsed += EL_ID_BITS + EL_INSTANCE_TAG_BITS 760 + DATA_BYTE_ALIGN_FLAG_BITS + DATA_LEN_COUNT_BITS; 761 762 if (DATA_BYTE_ALIGN_FLAG) { 763 dseBitsUsed += MAX_DATA_ALIGN_BITS; 764 } 765 766 cnt = fixMin(MAX_DSE_DATA_BYTES, dataPayloadBytes); 767 if ( cnt >= 255 ) { 768 esc_count = cnt - 255; 769 dseBitsUsed += DATA_LEN_ESC_COUNT_BITS; 770 } 771 772 dataPayloadBytes -= cnt; 773 dseBitsUsed += cnt * 8; 774 775 if (hTpEnc != NULL) { 776 HANDLE_FDK_BITSTREAM hBitStream = transportEnc_GetBitstream(hTpEnc); 777 int i; 778 779 FDKwriteBits(hBitStream, ID_DSE, EL_ID_BITS); 780 781 crcReg = transportEnc_CrcStartReg(hTpEnc, 0); 782 783 FDKwriteBits(hBitStream, elementInstanceTag, EL_INSTANCE_TAG_BITS); 784 FDKwriteBits(hBitStream, DATA_BYTE_ALIGN_FLAG, DATA_BYTE_ALIGN_FLAG_BITS); 785 786 /* write length field(s) */ 787 if ( esc_count >= 0 ) { 788 FDKwriteBits(hBitStream, 255, DATA_LEN_COUNT_BITS); 789 FDKwriteBits(hBitStream, esc_count, DATA_LEN_ESC_COUNT_BITS); 790 } else { 791 FDKwriteBits(hBitStream, cnt, DATA_LEN_COUNT_BITS); 792 } 793 794 if (DATA_BYTE_ALIGN_FLAG) { 795 INT tmp = (INT)FDKgetValidBits(hBitStream); 796 FDKbyteAlign(hBitStream, alignAnchor); 797 /* count actual bits */ 798 dseBitsUsed += (INT)FDKgetValidBits(hBitStream) - tmp - MAX_DATA_ALIGN_BITS; 799 } 800 801 /* write payload */ 802 for (i=0; i<cnt; i++) { 803 FDKwriteBits(hBitStream, dataBuffer[i], 8); 804 } 805 transportEnc_CrcEndReg(hTpEnc, crcReg); 806 } 807 } 808 809 return (dseBitsUsed); 810 } 811 812 813 /***************************************************************************** 814 815 functionname: FDKaacEnc_writeExtensionData 816 description: write extension payload to bitstream 817 returns: number of written bits 818 input: 819 output: 820 821 *****************************************************************************/ 822 INT FDKaacEnc_writeExtensionData( HANDLE_TRANSPORTENC hTpEnc, 823 QC_OUT_EXTENSION *pExtension, 824 INT elInstanceTag, /* for DSE only */ 825 UINT alignAnchor, /* for DSE only */ 826 UINT syntaxFlags, 827 AUDIO_OBJECT_TYPE aot, 828 SCHAR epConfig 829 ) 830 { 831 #define FILL_EL_COUNT_BITS ( 4 ) 832 #define FILL_EL_ESC_COUNT_BITS ( 8 ) 833 #define MAX_FILL_DATA_BYTES ( 269 ) 834 835 HANDLE_FDK_BITSTREAM hBitStream = NULL; 836 INT payloadBits = pExtension->nPayloadBits; 837 INT extBitsUsed = 0; 838 839 if (hTpEnc != NULL) { 840 hBitStream = transportEnc_GetBitstream(hTpEnc); 841 } 842 843 if (syntaxFlags & (AC_SCALABLE|AC_ER)) 844 { 845 if ( syntaxFlags & AC_DRM ) 846 { /* CAUTION: The caller has to assure that fill 847 data is written before the SBR payload. */ 848 UCHAR *extPayloadData = pExtension->pPayload; 849 850 switch (pExtension->type) 851 { 852 case EXT_SBR_DATA: 853 case EXT_SBR_DATA_CRC: 854 /* SBR payload is written in reverse */ 855 if (hBitStream != NULL) { 856 int i, writeBits = payloadBits; 857 858 FDKpushFor(hBitStream, payloadBits-1); /* Does a cache sync internally */ 859 860 for (i=0; writeBits >= 8; i++) { 861 FDKwriteBitsBwd(hBitStream, extPayloadData[i], 8); 862 writeBits -= 8; 863 } 864 if (writeBits > 0) { 865 FDKwriteBitsBwd(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); 866 } 867 868 FDKsyncCacheBwd (hBitStream); 869 FDKpushFor (hBitStream, payloadBits+1); 870 } 871 extBitsUsed += payloadBits; 872 break; 873 874 case EXT_FILL_DATA: 875 case EXT_FIL: 876 default: 877 if (hBitStream != NULL) { 878 int writeBits = payloadBits; 879 while (writeBits >= 8) { 880 FDKwriteBits(hBitStream, 0x00, 8); 881 writeBits -= 8; 882 } 883 FDKwriteBits(hBitStream, 0x00, writeBits); 884 } 885 extBitsUsed += payloadBits; 886 break; 887 } 888 } 889 else { 890 if ( (syntaxFlags & AC_ELD) && ((pExtension->type==EXT_SBR_DATA) || (pExtension->type==EXT_SBR_DATA_CRC)) ) { 891 892 if (hBitStream != NULL) { 893 int i, writeBits = payloadBits; 894 UCHAR *extPayloadData = pExtension->pPayload; 895 896 for (i=0; writeBits >= 8; i++) { 897 FDKwriteBits(hBitStream, extPayloadData[i], 8); 898 writeBits -= 8; 899 } 900 if (writeBits > 0) { 901 FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); 902 } 903 } 904 extBitsUsed += payloadBits; 905 } 906 else 907 { 908 /* ER or scalable syntax -> write extension en bloc */ 909 extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream, 910 pExtension->type, 911 pExtension->pPayload, 912 payloadBits ); 913 } 914 } 915 } 916 else { 917 /* We have normal GA bitstream payload (AOT 2,5,29) so pack 918 the data into a fill elements or DSEs */ 919 920 if ( pExtension->type == EXT_DATA_ELEMENT ) 921 { 922 extBitsUsed += FDKaacEnc_writeDataStreamElement( hTpEnc, 923 elInstanceTag, 924 pExtension->nPayloadBits>>3, 925 pExtension->pPayload, 926 alignAnchor ); 927 } 928 else { 929 while (payloadBits >= (EL_ID_BITS + FILL_EL_COUNT_BITS)) { 930 INT cnt, esc_count=-1, alignBits=7; 931 932 if ( (pExtension->type == EXT_FILL_DATA) || (pExtension->type == EXT_FIL) ) 933 { 934 payloadBits -= EL_ID_BITS + FILL_EL_COUNT_BITS; 935 if (payloadBits >= 15*8) { 936 payloadBits -= FILL_EL_ESC_COUNT_BITS; 937 esc_count = 0; /* write esc_count even if cnt becomes smaller 15 */ 938 } 939 alignBits = 0; 940 } 941 942 cnt = fixMin(MAX_FILL_DATA_BYTES, (payloadBits+alignBits)>>3); 943 944 if (cnt >= 15) { 945 esc_count = cnt - 15 + 1; 946 } 947 948 if (hBitStream != NULL) { 949 /* write bitstream */ 950 FDKwriteBits(hBitStream, ID_FIL, EL_ID_BITS); 951 if (esc_count >= 0) { 952 FDKwriteBits(hBitStream, 15, FILL_EL_COUNT_BITS); 953 FDKwriteBits(hBitStream, esc_count, FILL_EL_ESC_COUNT_BITS); 954 } else { 955 FDKwriteBits(hBitStream, cnt, FILL_EL_COUNT_BITS); 956 } 957 } 958 959 extBitsUsed += EL_ID_BITS + FILL_EL_COUNT_BITS + ((esc_count>=0) ? FILL_EL_ESC_COUNT_BITS : 0); 960 961 cnt = fixMin(cnt*8, payloadBits); /* convert back to bits */ 962 extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream, 963 pExtension->type, 964 pExtension->pPayload, 965 cnt ); 966 payloadBits -= cnt; 967 } 968 } 969 } 970 971 return (extBitsUsed); 972 } 973 974 975 /***************************************************************************** 976 977 functionname: FDKaacEnc_ByteAlignment 978 description: 979 returns: 980 input: 981 output: 982 983 *****************************************************************************/ 984 static void FDKaacEnc_ByteAlignment(HANDLE_FDK_BITSTREAM hBitStream, int alignBits) 985 { 986 FDKwriteBits(hBitStream, 0, alignBits); 987 } 988 989 AAC_ENCODER_ERROR FDKaacEnc_ChannelElementWrite( HANDLE_TRANSPORTENC hTpEnc, 990 ELEMENT_INFO *pElInfo, 991 QC_OUT_CHANNEL *qcOutChannel[(2)], 992 PSY_OUT_ELEMENT *psyOutElement, 993 PSY_OUT_CHANNEL *psyOutChannel[(2)], 994 UINT syntaxFlags, 995 AUDIO_OBJECT_TYPE aot, 996 SCHAR epConfig, 997 INT *pBitDemand, 998 UCHAR minCnt 999 ) 1000 { 1001 AAC_ENCODER_ERROR error = AAC_ENC_OK; 1002 HANDLE_FDK_BITSTREAM hBitStream = NULL; 1003 INT bitDemand = 0; 1004 const element_list_t *list; 1005 int i, ch, decision_bit; 1006 INT crcReg1 = -1, crcReg2 = -1; 1007 UCHAR numberOfChannels; 1008 1009 if (hTpEnc != NULL) { 1010 /* Get bitstream handle */ 1011 hBitStream = transportEnc_GetBitstream(hTpEnc); 1012 } 1013 1014 if ( (pElInfo->elType==ID_SCE) || (pElInfo->elType==ID_LFE) ) { 1015 numberOfChannels = 1; 1016 } else { 1017 numberOfChannels = 2; 1018 } 1019 1020 /* Get channel element sequence table */ 1021 list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0); 1022 if (list == NULL) { 1023 error = AAC_ENC_UNSUPPORTED_AOT; 1024 goto bail; 1025 } 1026 1027 if (!(syntaxFlags & (AC_SCALABLE|AC_ER))) { 1028 if (hBitStream != NULL) { 1029 FDKwriteBits(hBitStream, pElInfo->elType, EL_ID_BITS); 1030 } 1031 bitDemand += EL_ID_BITS; 1032 } 1033 1034 /* Iterate through sequence table */ 1035 i = 0; 1036 ch = 0; 1037 decision_bit = 0; 1038 do { 1039 /* some tmp values */ 1040 SECTION_DATA *pChSectionData = NULL; 1041 INT *pChScf = NULL; 1042 UINT *pChMaxValueInSfb = NULL; 1043 TNS_INFO *pTnsInfo = NULL; 1044 INT chGlobalGain = 0; 1045 INT chBlockType = 0; 1046 INT chMaxSfbPerGrp = 0; 1047 INT chSfbPerGrp = 0; 1048 INT chSfbCnt = 0; 1049 INT chFirstScf = 0; 1050 1051 if (minCnt==0) { 1052 if ( qcOutChannel!=NULL ) { 1053 pChSectionData = &(qcOutChannel[ch]->sectionData); 1054 pChScf = qcOutChannel[ch]->scf; 1055 chGlobalGain = qcOutChannel[ch]->globalGain; 1056 pChMaxValueInSfb = qcOutChannel[ch]->maxValueInSfb; 1057 chBlockType = pChSectionData->blockType; 1058 chMaxSfbPerGrp = pChSectionData->maxSfbPerGroup; 1059 chSfbPerGrp = pChSectionData->sfbPerGroup; 1060 chSfbCnt = pChSectionData->sfbCnt; 1061 chFirstScf = pChScf[pChSectionData->firstScf]; 1062 } 1063 else { 1064 /* get values from PSY */ 1065 chSfbCnt = psyOutChannel[ch]->sfbCnt; 1066 chSfbPerGrp = psyOutChannel[ch]->sfbPerGroup; 1067 chMaxSfbPerGrp = psyOutChannel[ch]->maxSfbPerGroup; 1068 } 1069 pTnsInfo = &psyOutChannel[ch]->tnsInfo; 1070 } /* minCnt==0 */ 1071 1072 if ( qcOutChannel==NULL ) { 1073 chBlockType = psyOutChannel[ch]->lastWindowSequence; 1074 } 1075 1076 switch (list->id[i]) 1077 { 1078 case element_instance_tag: 1079 /* Write element instance tag */ 1080 if (hBitStream != NULL) { 1081 FDKwriteBits(hBitStream, pElInfo->instanceTag, 4); 1082 } 1083 bitDemand += 4; 1084 break; 1085 1086 case common_window: 1087 /* Write common window flag */ 1088 decision_bit = psyOutElement->commonWindow; 1089 if (hBitStream != NULL) { 1090 FDKwriteBits(hBitStream, psyOutElement->commonWindow, 1); 1091 } 1092 bitDemand += 1; 1093 break; 1094 1095 case ics_info: 1096 /* Write individual channel info */ 1097 bitDemand += FDKaacEnc_encodeIcsInfo( chBlockType, 1098 psyOutChannel[ch]->windowShape, 1099 psyOutChannel[ch]->groupingMask, 1100 chMaxSfbPerGrp, 1101 hBitStream, 1102 syntaxFlags); 1103 break; 1104 1105 case ltp_data_present: 1106 /* Write LTP data present flag */ 1107 if (hBitStream != NULL) { 1108 FDKwriteBits(hBitStream, 0, 1); 1109 } 1110 bitDemand += 1; 1111 break; 1112 1113 case ltp_data: 1114 /* Predictor data not supported. 1115 Nothing to do here. */ 1116 break; 1117 1118 case ms: 1119 /* Write MS info */ 1120 bitDemand += FDKaacEnc_encodeMSInfo( chSfbCnt, 1121 chSfbPerGrp, 1122 chMaxSfbPerGrp, 1123 (minCnt==0) ? psyOutElement->toolsInfo.msDigest : MS_NONE, 1124 psyOutElement->toolsInfo.msMask, 1125 hBitStream); 1126 break; 1127 1128 case global_gain: 1129 bitDemand += FDKaacEnc_encodeGlobalGain( chGlobalGain, 1130 chFirstScf, 1131 hBitStream, 1132 psyOutChannel[ch]->mdctScale ); 1133 break; 1134 1135 case section_data: 1136 { 1137 INT siBits = FDKaacEnc_encodeSectionData(pChSectionData, hBitStream, (syntaxFlags & AC_ER_VCB11)?1:0); 1138 if (hBitStream != NULL) { 1139 if (siBits != qcOutChannel[ch]->sectionData.sideInfoBits) { 1140 error = AAC_ENC_WRITE_SEC_ERROR; 1141 } 1142 } 1143 bitDemand += siBits; 1144 } 1145 break; 1146 1147 case scale_factor_data: 1148 { 1149 INT sfDataBits = FDKaacEnc_encodeScaleFactorData( pChMaxValueInSfb, 1150 pChSectionData, 1151 pChScf, 1152 hBitStream, 1153 psyOutChannel[ch]->noiseNrg, 1154 psyOutChannel[ch]->isScale, 1155 chGlobalGain ); 1156 if ( (hBitStream != NULL) 1157 && (sfDataBits != (qcOutChannel[ch]->sectionData.scalefacBits + qcOutChannel[ch]->sectionData.noiseNrgBits)) ) { 1158 error = AAC_ENC_WRITE_SCAL_ERROR; 1159 } 1160 bitDemand += sfDataBits; 1161 } 1162 break; 1163 1164 case esc2_rvlc: 1165 if (syntaxFlags & AC_ER_RVLC) { 1166 /* write RVLC data into bitstream (error sens. cat. 2) */ 1167 error = AAC_ENC_UNSUPPORTED_AOT; 1168 } 1169 break; 1170 1171 case pulse: 1172 /* Write pulse data */ 1173 bitDemand += FDKaacEnc_encodePulseData(hBitStream); 1174 break; 1175 1176 case tns_data_present: 1177 /* Write TNS data present flag */ 1178 bitDemand += FDKaacEnc_encodeTnsDataPresent(pTnsInfo, 1179 chBlockType, 1180 hBitStream); 1181 break; 1182 case tns_data: 1183 /* Write TNS data */ 1184 bitDemand += FDKaacEnc_encodeTnsData(pTnsInfo, 1185 chBlockType, 1186 hBitStream); 1187 break; 1188 1189 case gain_control_data: 1190 /* Nothing to do here */ 1191 break; 1192 1193 case gain_control_data_present: 1194 bitDemand += FDKaacEnc_encodeGainControlData(hBitStream); 1195 break; 1196 1197 1198 case esc1_hcr: 1199 if (syntaxFlags & AC_ER_HCR) 1200 { 1201 error = AAC_ENC_UNKNOWN; 1202 } 1203 break; 1204 1205 case spectral_data: 1206 if (hBitStream != NULL) 1207 { 1208 INT spectralBits = 0; 1209 1210 spectralBits = FDKaacEnc_encodeSpectralData( psyOutChannel[ch]->sfbOffsets, 1211 pChSectionData, 1212 qcOutChannel[ch]->quantSpec, 1213 hBitStream ); 1214 1215 if (spectralBits != qcOutChannel[ch]->sectionData.huffmanBits) { 1216 return AAC_ENC_WRITE_SPEC_ERROR; 1217 } 1218 bitDemand += spectralBits; 1219 } 1220 break; 1221 1222 /* Non data cases */ 1223 case adtscrc_start_reg1: 1224 if (hTpEnc != NULL) { 1225 crcReg1 = transportEnc_CrcStartReg(hTpEnc, 192); 1226 } 1227 break; 1228 case adtscrc_start_reg2: 1229 if (hTpEnc != NULL) { 1230 crcReg2 = transportEnc_CrcStartReg(hTpEnc, 128); 1231 } 1232 break; 1233 case adtscrc_end_reg1: 1234 case drmcrc_end_reg: 1235 if (hTpEnc != NULL) { 1236 transportEnc_CrcEndReg(hTpEnc, crcReg1); 1237 } 1238 break; 1239 case adtscrc_end_reg2: 1240 if (hTpEnc != NULL) { 1241 transportEnc_CrcEndReg(hTpEnc, crcReg2); 1242 } 1243 break; 1244 case drmcrc_start_reg: 1245 if (hTpEnc != NULL) { 1246 crcReg1 = transportEnc_CrcStartReg(hTpEnc, 0); 1247 } 1248 break; 1249 case next_channel: 1250 ch = (ch + 1) % numberOfChannels; 1251 break; 1252 case link_sequence: 1253 list = list->next[decision_bit]; 1254 i=-1; 1255 break; 1256 1257 default: 1258 error = AAC_ENC_UNKNOWN; 1259 break; 1260 } 1261 1262 if (error != AAC_ENC_OK) { 1263 return error; 1264 } 1265 1266 i++; 1267 1268 } while (list->id[i] != end_of_sequence); 1269 1270 bail: 1271 if (pBitDemand != NULL) { 1272 *pBitDemand = bitDemand; 1273 } 1274 1275 return error; 1276 } 1277 1278 1279 //----------------------------------------------------------------------------------------------- 1280 1281 AAC_ENCODER_ERROR FDKaacEnc_WriteBitstream(HANDLE_TRANSPORTENC hTpEnc, 1282 CHANNEL_MAPPING *channelMapping, 1283 QC_OUT *qcOut, 1284 PSY_OUT* psyOut, 1285 QC_STATE *qcKernel, 1286 AUDIO_OBJECT_TYPE aot, 1287 UINT syntaxFlags, 1288 SCHAR epConfig 1289 ) 1290 { 1291 HANDLE_FDK_BITSTREAM hBs = transportEnc_GetBitstream(hTpEnc); 1292 AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK; 1293 int i, n, doByteAlign = 1; 1294 INT bitMarkUp; 1295 INT frameBits; 1296 /* Get first bit of raw data block. 1297 In case of ADTS+PCE, AU would start at PCE. 1298 This is okay because PCE assures alignment. */ 1299 UINT alignAnchor = FDKgetValidBits(hBs); 1300 1301 frameBits = bitMarkUp = alignAnchor; 1302 1303 1304 /* Channel element loop */ 1305 for (i=0; i<channelMapping->nElements; i++) { 1306 1307 ELEMENT_INFO elInfo = channelMapping->elInfo[i]; 1308 INT elementUsedBits = 0; 1309 1310 switch (elInfo.elType) 1311 { 1312 case ID_SCE: /* single channel */ 1313 case ID_CPE: /* channel pair */ 1314 case ID_LFE: /* low freq effects channel */ 1315 { 1316 if ( AAC_ENC_OK != (ErrorStatus = FDKaacEnc_ChannelElementWrite( hTpEnc, 1317 &elInfo, 1318 qcOut->qcElement[i]->qcOutChannel, 1319 psyOut->psyOutElement[i], 1320 psyOut->psyOutElement[i]->psyOutChannel, 1321 syntaxFlags, /* syntaxFlags (ER tools ...) */ 1322 aot, /* aot: AOT_AAC_LC, AOT_SBR, AOT_PS */ 1323 epConfig, /* epConfig -1, 0, 1 */ 1324 NULL, 1325 0 )) ) 1326 { 1327 return ErrorStatus; 1328 } 1329 1330 if ( !(syntaxFlags & AC_ER) ) 1331 { 1332 /* Write associated extension payload */ 1333 for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { 1334 FDKaacEnc_writeExtensionData( hTpEnc, 1335 &qcOut->qcElement[i]->extension[n], 1336 0, 1337 alignAnchor, 1338 syntaxFlags, 1339 aot, 1340 epConfig ); 1341 } 1342 } 1343 } 1344 break; 1345 1346 /* In FDK, DSE signalling explicit done in elDSE. See channel_map.cpp */ 1347 default: 1348 return AAC_ENC_INVALID_ELEMENTINFO_TYPE; 1349 1350 } /* switch */ 1351 1352 if(elInfo.elType != ID_DSE) { 1353 elementUsedBits -= bitMarkUp; 1354 bitMarkUp = FDKgetValidBits(hBs); 1355 elementUsedBits += bitMarkUp; 1356 frameBits += elementUsedBits; 1357 } 1358 1359 } /* for (i=0; i<channelMapping.nElements; i++) */ 1360 1361 if ( (syntaxFlags & AC_ER) && !(syntaxFlags & AC_DRM) ) 1362 { 1363 UCHAR channelElementExtensionWritten[(8)][(1)]; /* 0: extension not touched, 1: extension already written */ 1364 1365 FDKmemclear(channelElementExtensionWritten, sizeof(channelElementExtensionWritten)); 1366 1367 if ( syntaxFlags & AC_ELD ) { 1368 1369 for (i=0; i<channelMapping->nElements; i++) { 1370 for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { 1371 1372 if ( (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA) 1373 || (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA_CRC) ) 1374 { 1375 /* Write sbr extension payload */ 1376 FDKaacEnc_writeExtensionData( hTpEnc, 1377 &qcOut->qcElement[i]->extension[n], 1378 0, 1379 alignAnchor, 1380 syntaxFlags, 1381 aot, 1382 epConfig ); 1383 1384 channelElementExtensionWritten[i][n] = 1; 1385 } /* SBR */ 1386 } /* n */ 1387 } /* i */ 1388 } /* AC_ELD */ 1389 1390 for (i=0; i<channelMapping->nElements; i++) { 1391 for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { 1392 1393 if (channelElementExtensionWritten[i][n]==0) 1394 { 1395 /* Write all ramaining extension payloads in element */ 1396 FDKaacEnc_writeExtensionData( hTpEnc, 1397 &qcOut->qcElement[i]->extension[n], 1398 0, 1399 alignAnchor, 1400 syntaxFlags, 1401 aot, 1402 epConfig ); 1403 } 1404 } /* n */ 1405 } /* i */ 1406 } /* if AC_ER */ 1407 1408 /* Extend global extension payload table with fill bits */ 1409 if ( syntaxFlags & AC_DRM ) 1410 { 1411 /* Exception for Drm */ 1412 for (n = 0; n < qcOut->nExtensions; n++) { 1413 if ( (qcOut->extension[n].type == EXT_SBR_DATA) 1414 || (qcOut->extension[n].type == EXT_SBR_DATA_CRC) ) { 1415 /* SBR data must be the last extension! */ 1416 FDKmemcpy(&qcOut->extension[qcOut->nExtensions], &qcOut->extension[n], sizeof(QC_OUT_EXTENSION)); 1417 break; 1418 } 1419 } 1420 /* Do byte alignment after AAC (+ MPS) payload. 1421 Assure that MPS has been written as channel assigned extension payload! */ 1422 if (((FDKgetValidBits(hBs)-alignAnchor+(UINT)qcOut->totFillBits)&0x7)!=(UINT)qcOut->alignBits) { 1423 return AAC_ENC_WRITTEN_BITS_ERROR; 1424 } 1425 FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits); 1426 doByteAlign = 0; 1427 1428 } /* AC_DRM */ 1429 1430 /* Add fill data / stuffing bits */ 1431 n = qcOut->nExtensions; 1432 qcOut->extension[n].type = EXT_FILL_DATA; 1433 qcOut->extension[n].nPayloadBits = qcOut->totFillBits; 1434 qcOut->nExtensions++; 1435 1436 /* Write global extension payload and fill data */ 1437 for (n = 0; (n < qcOut->nExtensions) && (n < (2+2)); n++) 1438 { 1439 FDKaacEnc_writeExtensionData( hTpEnc, 1440 &qcOut->extension[n], 1441 0, 1442 alignAnchor, 1443 syntaxFlags, 1444 aot, 1445 epConfig ); 1446 1447 /* For EXT_FIL or EXT_FILL_DATA we could do an additional sanity check here */ 1448 } 1449 1450 if (!(syntaxFlags & (AC_SCALABLE|AC_ER))) { 1451 FDKwriteBits(hBs, ID_END, EL_ID_BITS); 1452 } 1453 1454 if (doByteAlign) { 1455 /* Assure byte alignment*/ 1456 if (((alignAnchor-FDKgetValidBits(hBs))&0x7)!=(UINT)qcOut->alignBits) { 1457 return AAC_ENC_WRITTEN_BITS_ERROR; 1458 } 1459 1460 FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits); 1461 } 1462 1463 frameBits -= bitMarkUp; 1464 frameBits += FDKgetValidBits(hBs); 1465 1466 transportEnc_EndAccessUnit(hTpEnc, &frameBits); 1467 1468 if (frameBits != qcOut->totalBits + qcKernel->globHdrBits){ 1469 return AAC_ENC_WRITTEN_BITS_ERROR; 1470 } 1471 1472 return ErrorStatus; 1473 } 1474 1475
