1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5© Copyright 1995 - 2012 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 Audio Encoder ************************** 85 86 Initial author: M.Werner 87 contents/description: Noiseless coder module 88 89******************************************************************************/ 90 91#include "dyn_bits.h" 92#include "bit_cnt.h" 93#include "psy_const.h" 94#include "aacenc_pns.h" 95#include "aacEnc_ram.h" 96#include "aacEnc_rom.h" 97 98typedef INT (*lookUpTable)[CODE_BOOK_ESC_NDX + 1]; 99 100static INT FDKaacEnc_getSideInfoBits( 101 const SECTION_INFO* const huffsection, 102 const SHORT* const sideInfoTab, 103 const INT useHCR 104 ) 105{ 106 INT sideInfoBits; 107 108 if ( useHCR && ((huffsection->codeBook == 11) || (huffsection->codeBook >= 16)) ) { 109 sideInfoBits = 5; 110 } 111 else { 112 sideInfoBits = sideInfoTab[huffsection->sfbCnt]; 113 } 114 115 return (sideInfoBits); 116} 117 118/* count bits using all possible tables */ 119static void FDKaacEnc_buildBitLookUp( 120 const SHORT* const quantSpectrum, 121 const INT maxSfb, 122 const INT* const sfbOffset, 123 const UINT* const sfbMax, 124 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 125 SECTION_INFO* const huffsection 126 ) 127{ 128 INT i, sfbWidth; 129 130 for (i = 0; i < maxSfb; i++) 131 { 132 huffsection[i].sfbCnt = 1; 133 huffsection[i].sfbStart = i; 134 huffsection[i].sectionBits = INVALID_BITCOUNT; 135 huffsection[i].codeBook = -1; 136 sfbWidth = sfbOffset[i + 1] - sfbOffset[i]; 137 FDKaacEnc_bitCount(quantSpectrum + sfbOffset[i], sfbWidth, sfbMax[i], bitLookUp[i]); 138 } 139} 140 141/* essential helper functions */ 142static INT FDKaacEnc_findBestBook( 143 const INT* const bc, 144 INT* const book, 145 const INT useVCB11 146 ) 147{ 148 INT minBits = INVALID_BITCOUNT, j; 149 150 int end = CODE_BOOK_ESC_NDX; 151 152 153 for (j = 0; j <= end; j++) 154 { 155 if (bc[j] < minBits) 156 { 157 minBits = bc[j]; 158 *book = j; 159 } 160 } 161 return (minBits); 162} 163 164static INT FDKaacEnc_findMinMergeBits( 165 const INT* const bc1, 166 const INT* const bc2, 167 const INT useVCB11 168 ) 169{ 170 INT minBits = INVALID_BITCOUNT, j; 171 172 int end = CODE_BOOK_ESC_NDX; 173 174 175 for (j = 0; j <= end; j++) 176 { 177 if (bc1[j] + bc2[j] < minBits) 178 { 179 minBits = bc1[j] + bc2[j]; 180 } 181 } 182 return (minBits); 183} 184 185static void FDKaacEnc_mergeBitLookUp( 186 INT* const bc1, 187 const INT* const bc2 188 ) 189{ 190 int j; 191 192 for (j = 0; j <= CODE_BOOK_ESC_NDX; j++) 193 { 194 bc1[j] = fixMin(bc1[j] + bc2[j], INVALID_BITCOUNT); 195 } 196} 197 198static INT FDKaacEnc_findMaxMerge( 199 const INT* const mergeGainLookUp, 200 const SECTION_INFO* const huffsection, 201 const INT maxSfb, 202 INT* const maxNdx 203 ) 204{ 205 INT i, maxMergeGain = 0; 206 207 for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) 208 { 209 if (mergeGainLookUp[i] > maxMergeGain) 210 { 211 maxMergeGain = mergeGainLookUp[i]; 212 *maxNdx = i; 213 } 214 } 215 return (maxMergeGain); 216} 217 218static INT FDKaacEnc_CalcMergeGain( 219 const SECTION_INFO* const huffsection, 220 const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 221 const SHORT* const sideInfoTab, 222 const INT ndx1, 223 const INT ndx2, 224 const INT useVCB11 225 ) 226{ 227 INT MergeGain, MergeBits, SplitBits; 228 229 MergeBits = sideInfoTab[huffsection[ndx1].sfbCnt + huffsection[ndx2].sfbCnt] + FDKaacEnc_findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2], useVCB11); 230 SplitBits = huffsection[ndx1].sectionBits + huffsection[ndx2].sectionBits; /* Bit amount for splitted huffsections */ 231 MergeGain = SplitBits - MergeBits; 232 233 if ( (huffsection[ndx1].codeBook==CODE_BOOK_PNS_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_PNS_NO) 234 || (huffsection[ndx1].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO) 235 || (huffsection[ndx1].codeBook==CODE_BOOK_IS_IN_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_IN_PHASE_NO) 236 ) 237 { 238 MergeGain = -1; 239 } 240 241 return (MergeGain); 242} 243 244 245/* sectioning Stage 0:find minimum codbooks */ 246static void FDKaacEnc_gmStage0( 247 SECTION_INFO* const RESTRICT huffsection, 248 const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 249 const INT maxSfb, 250 const INT* const noiseNrg, 251 const INT* const isBook 252 ) 253{ 254 INT i; 255 256 for (i = 0; i < maxSfb; i++) 257 { 258 /* Side-Info bits will be calculated in Stage 1! */ 259 if (huffsection[i].sectionBits == INVALID_BITCOUNT) 260 { 261 /* intensity and pns codebooks are already allocated in bitcount.c */ 262 if(noiseNrg[i] != NO_NOISE_PNS){ 263 huffsection[i].codeBook=CODE_BOOK_PNS_NO; 264 huffsection[i].sectionBits = 0; 265 } 266 else if( isBook[i] ) { 267 huffsection[i].codeBook=isBook[i]; 268 huffsection[i].sectionBits = 0; 269 } 270 else { 271 huffsection[i].sectionBits = FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), 0); /* useVCB11 must be 0!!! */ 272 } 273 } 274 } 275} 276 277/* 278 sectioning Stage 1:merge all connected regions with the same code book and 279 calculate side info 280 */ 281static void FDKaacEnc_gmStage1( 282 SECTION_INFO* const RESTRICT huffsection, 283 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 284 const INT maxSfb, 285 const SHORT* const sideInfoTab, 286 const INT useVCB11 287 ) 288{ 289 INT mergeStart = 0, mergeEnd; 290 291 do 292 { 293 for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++) 294 { 295 if (huffsection[mergeStart].codeBook != huffsection[mergeEnd].codeBook) 296 break; 297 298 299 /* we can merge. update tables, side info bits will be updated outside of this loop */ 300 huffsection[mergeStart].sfbCnt++; 301 huffsection[mergeStart].sectionBits += huffsection[mergeEnd].sectionBits; 302 303 /* update bit look up for all code books */ 304 FDKaacEnc_mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]); 305 } 306 307 /* add side info info bits */ 308 huffsection[mergeStart].sectionBits += FDKaacEnc_getSideInfoBits(&huffsection[mergeStart], sideInfoTab, useVCB11); 309 huffsection[mergeEnd - 1].sfbStart = huffsection[mergeStart].sfbStart; /* speed up prev search */ 310 311 mergeStart = mergeEnd; 312 313 } while (mergeStart < maxSfb); 314} 315 316/* 317 sectioning Stage 2:greedy merge algorithm, merge connected sections with 318 maximum bit gain until no more gain is possible 319 */ 320static void 321FDKaacEnc_gmStage2( 322 SECTION_INFO* const RESTRICT huffsection, 323 INT* const RESTRICT mergeGainLookUp, 324 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 325 const INT maxSfb, 326 const SHORT* const sideInfoTab, 327 const INT useVCB11 328 ) 329{ 330 INT i; 331 332 for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) 333 { 334 mergeGainLookUp[i] = FDKaacEnc_CalcMergeGain(huffsection, 335 bitLookUp, 336 sideInfoTab, 337 i, 338 i + huffsection[i].sfbCnt, 339 useVCB11); 340 } 341 342 while (TRUE) 343 { 344 INT maxMergeGain, maxNdx = 0, maxNdxNext, maxNdxLast; 345 346 maxMergeGain = FDKaacEnc_findMaxMerge(mergeGainLookUp, huffsection, maxSfb, &maxNdx); 347 348 /* exit while loop if no more gain is possible */ 349 if (maxMergeGain <= 0) 350 break; 351 352 maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt; 353 354 /* merge sections with maximum bit gain */ 355 huffsection[maxNdx].sfbCnt += huffsection[maxNdxNext].sfbCnt; 356 huffsection[maxNdx].sectionBits += huffsection[maxNdxNext].sectionBits - maxMergeGain; 357 358 /* update bit look up table for merged huffsection */ 359 FDKaacEnc_mergeBitLookUp(bitLookUp[maxNdx], bitLookUp[maxNdxNext]); 360 361 /* update mergeLookUpTable */ 362 if (maxNdx != 0) 363 { 364 maxNdxLast = huffsection[maxNdx - 1].sfbStart; 365 mergeGainLookUp[maxNdxLast] = FDKaacEnc_CalcMergeGain(huffsection, 366 bitLookUp, 367 sideInfoTab, 368 maxNdxLast, 369 maxNdx, 370 useVCB11); 371 372 } 373 maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt; 374 375 huffsection[maxNdxNext - 1].sfbStart = huffsection[maxNdx].sfbStart; 376 377 if (maxNdxNext < maxSfb) 378 mergeGainLookUp[maxNdx] = FDKaacEnc_CalcMergeGain(huffsection, 379 bitLookUp, 380 sideInfoTab, 381 maxNdx, 382 maxNdxNext, 383 useVCB11); 384 385 } 386} 387 388/* count bits used by the noiseless coder */ 389static void FDKaacEnc_noiselessCounter( 390 SECTION_DATA* const RESTRICT sectionData, 391 INT mergeGainLookUp[MAX_SFB_LONG], 392 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], 393 const SHORT* const quantSpectrum, 394 const UINT* const maxValueInSfb, 395 const INT* const sfbOffset, 396 const INT blockType, 397 const INT* const noiseNrg, 398 const INT* const isBook, 399 const INT useVCB11 400 ) 401{ 402 INT grpNdx, i; 403 const SHORT *sideInfoTab = NULL; 404 SECTION_INFO *huffsection; 405 406 /* use appropriate side info table */ 407 switch (blockType) 408 { 409 case LONG_WINDOW: 410 case START_WINDOW: 411 case STOP_WINDOW: 412 sideInfoTab = FDKaacEnc_sideInfoTabLong; 413 break; 414 case SHORT_WINDOW: 415 sideInfoTab = FDKaacEnc_sideInfoTabShort; 416 break; 417 } 418 419 sectionData->noOfSections = 0; 420 sectionData->huffmanBits = 0; 421 sectionData->sideInfoBits = 0; 422 423 424 if (sectionData->maxSfbPerGroup == 0) 425 return; 426 427 /* loop trough groups */ 428 for (grpNdx = 0; grpNdx < sectionData->sfbCnt; grpNdx += sectionData->sfbPerGroup) 429 { 430 huffsection = sectionData->huffsection + sectionData->noOfSections; 431 432 /* count bits in this group */ 433 FDKaacEnc_buildBitLookUp(quantSpectrum, 434 sectionData->maxSfbPerGroup, 435 sfbOffset + grpNdx, 436 maxValueInSfb + grpNdx, 437 bitLookUp, 438 huffsection); 439 440 /* 0.Stage :Find minimum Codebooks */ 441 FDKaacEnc_gmStage0(huffsection, bitLookUp, sectionData->maxSfbPerGroup, noiseNrg+grpNdx, isBook+grpNdx); 442 443 /* 1.Stage :Merge all connected regions with the same code book */ 444 FDKaacEnc_gmStage1(huffsection, bitLookUp, sectionData->maxSfbPerGroup, sideInfoTab, useVCB11); 445 446 447 /* 448 2.Stage 449 greedy merge algorithm, merge connected huffsections with maximum bit 450 gain until no more gain is possible 451 */ 452 453 FDKaacEnc_gmStage2(huffsection, 454 mergeGainLookUp, 455 bitLookUp, 456 sectionData->maxSfbPerGroup, 457 sideInfoTab, 458 useVCB11); 459 460 461 462 /* 463 compress output, calculate total huff and side bits 464 since we did not update the actual codebook in stage 2 465 to save time, we must set it here for later use in bitenc 466 */ 467 468 for (i = 0; i < sectionData->maxSfbPerGroup; i += huffsection[i].sfbCnt) 469 { 470 if ((huffsection[i].codeBook==CODE_BOOK_PNS_NO) || 471 (huffsection[i].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO) || 472 (huffsection[i].codeBook==CODE_BOOK_IS_IN_PHASE_NO)) 473 { 474 huffsection[i].sectionBits=0; 475 } else { 476 /* the sections in the sectionData are now marked with the optimal code book */ 477 478 FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), useVCB11); 479 480 sectionData->huffmanBits += huffsection[i].sectionBits - FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11); 481 } 482 483 huffsection[i].sfbStart += grpNdx; 484 485 /* sum up side info bits (section data bits) */ 486 sectionData->sideInfoBits += FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11); 487 sectionData->huffsection[sectionData->noOfSections++] = huffsection[i]; 488 } 489 } 490} 491 492 493/******************************************************************************* 494 495 functionname: FDKaacEnc_scfCount 496 returns : --- 497 description : count bits used by scalefactors. 498 499 not in all cases if maxValueInSfb[] == 0 we set deltaScf 500 to zero. only if the difference of the last and future 501 scalefacGain is not greater then CODE_BOOK_SCF_LAV (60). 502 503 example: 504 ^ 505 scalefacGain | 506 | 507 | last 75 508 | | 509 | | 510 | | 511 | | current 50 512 | | | 513 | | | 514 | | | 515 | | | 516 | | | future 5 517 | | | | 518 --- ... ---------------------------- ... ---------> 519 sfb 520 521 522 if maxValueInSfb[] of current is zero because of a 523 notfallstrategie, we do not save bits and transmit a 524 deltaScf of 25. otherwise the deltaScf between the last 525 scalfacGain (75) and the future scalefacGain (5) is 70. 526 527********************************************************************************/ 528static void FDKaacEnc_scfCount( 529 const INT* const scalefacGain, 530 const UINT* const maxValueInSfb, 531 SECTION_DATA* const RESTRICT sectionData, 532 const INT* const isScale 533 ) 534{ 535 INT i, j, k, m, n; 536 537 INT lastValScf = 0; 538 INT deltaScf = 0; 539 INT found = 0; 540 INT scfSkipCounter = 0; 541 INT lastValIs = 0; 542 543 sectionData->scalefacBits = 0; 544 545 if (scalefacGain == NULL) 546 return; 547 548 sectionData->firstScf = 0; 549 550 for (i=0; i<sectionData->noOfSections; i++) 551 { 552 if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) 553 { 554 sectionData->firstScf = sectionData->huffsection[i].sfbStart; 555 lastValScf = scalefacGain[sectionData->firstScf]; 556 break; 557 } 558 } 559 560 for (i=0; i<sectionData->noOfSections; i++) 561 { 562 if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || 563 (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) 564 { 565 for (j = sectionData->huffsection[i].sfbStart; 566 j < sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt; 567 j++) 568 { 569 INT deltaIs = isScale[j]-lastValIs; 570 lastValIs = isScale[j]; 571 sectionData->scalefacBits+=FDKaacEnc_bitCountScalefactorDelta(deltaIs); 572 } 573 } /* Intensity */ 574 else if ((sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) && 575 (sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO)) 576 { 577 INT tmp = sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt; 578 for (j = sectionData->huffsection[i].sfbStart; j<tmp; j++) 579 { 580 /* check if we can repeat the last value to save bits */ 581 if (maxValueInSfb[j] == 0) 582 { 583 found = 0; 584 /* are scalefactors skipped? */ 585 if (scfSkipCounter == 0) 586 { 587 /* end of section */ 588 if (j == (tmp - 1) ) 589 found = 0; /* search in other sections for maxValueInSfb != 0 */ 590 else 591 { 592 /* search in this section for the next maxValueInSfb[] != 0 */ 593 for (k = (j+1); k < tmp; k++) 594 { 595 if (maxValueInSfb[k] != 0) 596 { 597 found = 1; 598 if ( (fixp_abs(scalefacGain[k] - lastValScf)) <= CODE_BOOK_SCF_LAV) 599 deltaScf = 0; /* save bits */ 600 else 601 { 602 /* do not save bits */ 603 deltaScf = lastValScf - scalefacGain[j]; 604 lastValScf = scalefacGain[j]; 605 scfSkipCounter = 0; 606 } 607 break; 608 } 609 /* count scalefactor skip */ 610 scfSkipCounter++; 611 } 612 } 613 614 /* search for the next maxValueInSfb[] != 0 in all other sections */ 615 for (m=(i+1); (m < sectionData->noOfSections) && (found == 0); m++) 616 { 617 if ((sectionData->huffsection[m].codeBook != CODE_BOOK_ZERO_NO) && (sectionData->huffsection[m].codeBook != CODE_BOOK_PNS_NO)) 618 { 619 INT end = sectionData->huffsection[m].sfbStart + sectionData->huffsection[m].sfbCnt; 620 for (n = sectionData->huffsection[m].sfbStart; n<end; n++) 621 { 622 if (maxValueInSfb[n] != 0) 623 { 624 found = 1; 625 if (fixp_abs(scalefacGain[n] - lastValScf) <= CODE_BOOK_SCF_LAV) 626 deltaScf = 0; /* save bits */ 627 else 628 { 629 /* do not save bits */ 630 deltaScf = lastValScf - scalefacGain[j]; 631 lastValScf = scalefacGain[j]; 632 scfSkipCounter = 0; 633 } 634 break; 635 } 636 /* count scalefactor skip */ 637 scfSkipCounter++; 638 } 639 } 640 } 641 /* no maxValueInSfb[] != 0 found */ 642 if (found == 0) 643 { 644 deltaScf = 0; 645 scfSkipCounter = 0; 646 } 647 } 648 else { 649 /* consider skipped scalefactors */ 650 deltaScf = 0; 651 scfSkipCounter--; 652 } 653 } 654 else { 655 deltaScf = lastValScf - scalefacGain[j]; 656 lastValScf = scalefacGain[j]; 657 } 658 sectionData->scalefacBits += FDKaacEnc_bitCountScalefactorDelta(deltaScf); 659 } 660 } 661 } /* for (i=0; i<sectionData->noOfSections; i++) */ 662} 663 664#ifdef PNS_PRECOUNT_ENABLE 665/* 666 preCount bits used pns 667*/ 668/* estimate bits used by pns for correction of static bits */ 669/* no codebook switch estimation, see AAC LD FASTENC */ 670INT noisePreCount(const INT *noiseNrg, INT maxSfb) 671{ 672 INT noisePCMFlag = TRUE; 673 INT lastValPns = 0, deltaPns; 674 int i, bits=0; 675 676 for (i = 0; i < maxSfb; i++) { 677 if (noiseNrg[i] != NO_NOISE_PNS) { 678 679 if (noisePCMFlag) { 680 bits+=PNS_PCM_BITS; 681 lastValPns = noiseNrg[i]; 682 noisePCMFlag = FALSE; 683 }else { 684 deltaPns = noiseNrg[i]-lastValPns; 685 lastValPns = noiseNrg[i]; 686 bits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns); 687 } 688 } 689 } 690 return ( bits ); 691} 692#endif /* PNS_PRECOUNT_ENABLE */ 693 694/* count bits used by pns */ 695static void FDKaacEnc_noiseCount( 696 SECTION_DATA* const RESTRICT sectionData, 697 const INT* const noiseNrg 698 ) 699{ 700 INT noisePCMFlag = TRUE; 701 INT lastValPns = 0, deltaPns; 702 int i, j; 703 704 sectionData->noiseNrgBits = 0; 705 706 for (i = 0; i < sectionData->noOfSections; i++) { 707 if (sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) { 708 int sfbStart = sectionData->huffsection[i].sfbStart; 709 int sfbEnd = sfbStart + sectionData->huffsection[i].sfbCnt; 710 for (j=sfbStart; j<sfbEnd; j++) { 711 712 if (noisePCMFlag) { 713 sectionData->noiseNrgBits+=PNS_PCM_BITS; 714 lastValPns = noiseNrg[j]; 715 noisePCMFlag = FALSE; 716 } else { 717 deltaPns = noiseNrg[j]-lastValPns; 718 lastValPns = noiseNrg[j]; 719 sectionData->noiseNrgBits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns); 720 } 721 } 722 } 723 } 724} 725 726INT FDKaacEnc_dynBitCount( 727 BITCNTR_STATE* const hBC, 728 const SHORT* const quantSpectrum, 729 const UINT* const maxValueInSfb, 730 const INT* const scalefac, 731 const INT blockType, 732 const INT sfbCnt, 733 const INT maxSfbPerGroup, 734 const INT sfbPerGroup, 735 const INT* const sfbOffset, 736 SECTION_DATA* const RESTRICT sectionData, 737 const INT* const noiseNrg, 738 const INT* const isBook, 739 const INT* const isScale, 740 const UINT syntaxFlags 741 ) 742{ 743 sectionData->blockType = blockType; 744 sectionData->sfbCnt = sfbCnt; 745 sectionData->sfbPerGroup = sfbPerGroup; 746 sectionData->noOfGroups = sfbCnt / sfbPerGroup; 747 sectionData->maxSfbPerGroup = maxSfbPerGroup; 748 749 FDKaacEnc_noiselessCounter( 750 sectionData, 751 hBC->mergeGainLookUp, 752 (lookUpTable)hBC->bitLookUp, 753 quantSpectrum, 754 maxValueInSfb, 755 sfbOffset, 756 blockType, 757 noiseNrg, 758 isBook, 759 (syntaxFlags & AC_ER_VCB11)?1:0); 760 761 FDKaacEnc_scfCount( 762 scalefac, 763 maxValueInSfb, 764 sectionData, 765 isScale); 766 767 FDKaacEnc_noiseCount(sectionData, 768 noiseNrg); 769 770 return (sectionData->huffmanBits + 771 sectionData->sideInfoBits + 772 sectionData->scalefacBits + 773 sectionData->noiseNrgBits); 774} 775 776INT FDKaacEnc_BCNew(BITCNTR_STATE **phBC 777 ,UCHAR* dynamic_RAM 778 ) 779{ 780 BITCNTR_STATE *hBC = GetRam_aacEnc_BitCntrState(); 781 782 if (hBC) 783 { 784 *phBC = hBC; 785 hBC->bitLookUp = GetRam_aacEnc_BitLookUp(0,dynamic_RAM); 786 hBC->mergeGainLookUp = GetRam_aacEnc_MergeGainLookUp(0,dynamic_RAM); 787 if (hBC->bitLookUp == 0 || 788 hBC->mergeGainLookUp == 0) 789 { 790 return 1; 791 } 792 } 793 return (hBC == 0) ? 1 : 0; 794} 795 796void FDKaacEnc_BCClose(BITCNTR_STATE **phBC) 797{ 798 if (*phBC!=NULL) { 799 800 FreeRam_aacEnc_BitCntrState(phBC); 801 } 802} 803 804 805 806