| /* ----------------------------------------------------------------------------- |
| Software License for The Fraunhofer FDK AAC Codec Library for Android |
| |
| © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten |
| Forschung e.V. All rights reserved. |
| |
| 1. INTRODUCTION |
| The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software |
| that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding |
| scheme for digital audio. This FDK AAC Codec software is intended to be used on |
| a wide variety of Android devices. |
| |
| AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient |
| general perceptual audio codecs. AAC-ELD is considered the best-performing |
| full-bandwidth communications codec by independent studies and is widely |
| deployed. AAC has been standardized by ISO and IEC as part of the MPEG |
| specifications. |
| |
| Patent licenses for necessary patent claims for the FDK AAC Codec (including |
| those of Fraunhofer) may be obtained through Via Licensing |
| (www.vialicensing.com) or through the respective patent owners individually for |
| the purpose of encoding or decoding bit streams in products that are compliant |
| with the ISO/IEC MPEG audio standards. Please note that most manufacturers of |
| Android devices already license these patent claims through Via Licensing or |
| directly from the patent owners, and therefore FDK AAC Codec software may |
| already be covered under those patent licenses when it is used for those |
| licensed purposes only. |
| |
| Commercially-licensed AAC software libraries, including floating-point versions |
| with enhanced sound quality, are also available from Fraunhofer. Users are |
| encouraged to check the Fraunhofer website for additional applications |
| information and documentation. |
| |
| 2. COPYRIGHT LICENSE |
| |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted without payment of copyright license fees provided that you |
| satisfy the following conditions: |
| |
| You must retain the complete text of this software license in redistributions of |
| the FDK AAC Codec or your modifications thereto in source code form. |
| |
| You must retain the complete text of this software license in the documentation |
| and/or other materials provided with redistributions of the FDK AAC Codec or |
| your modifications thereto in binary form. You must make available free of |
| charge copies of the complete source code of the FDK AAC Codec and your |
| modifications thereto to recipients of copies in binary form. |
| |
| The name of Fraunhofer may not be used to endorse or promote products derived |
| from this library without prior written permission. |
| |
| You may not charge copyright license fees for anyone to use, copy or distribute |
| the FDK AAC Codec software or your modifications thereto. |
| |
| Your modified versions of the FDK AAC Codec must carry prominent notices stating |
| that you changed the software and the date of any change. For modified versions |
| of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" |
| must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK |
| AAC Codec Library for Android." |
| |
| 3. NO PATENT LICENSE |
| |
| NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without |
| limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. |
| Fraunhofer provides no warranty of patent non-infringement with respect to this |
| software. |
| |
| You may use this FDK AAC Codec software or modifications thereto only for |
| purposes that are authorized by appropriate patent licenses. |
| |
| 4. DISCLAIMER |
| |
| This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright |
| holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, |
| including but not limited to the implied warranties of merchantability and |
| fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, |
| or consequential damages, including but not limited to procurement of substitute |
| goods or services; loss of use, data, or profits, or business interruption, |
| however caused and on any theory of liability, whether in contract, strict |
| liability, or tort (including negligence), arising in any way out of the use of |
| this software, even if advised of the possibility of such damage. |
| |
| 5. CONTACT INFORMATION |
| |
| Fraunhofer Institute for Integrated Circuits IIS |
| Attention: Audio and Multimedia Departments - FDK AAC LL |
| Am Wolfsmantel 33 |
| 91058 Erlangen, Germany |
| |
| www.iis.fraunhofer.de/amm |
| amm-info@iis.fraunhofer.de |
| ----------------------------------------------------------------------------- */ |
| |
| /**************************** AAC encoder library ****************************** |
| |
| Author(s): M.Werner |
| |
| Description: Noiseless coder module |
| |
| *******************************************************************************/ |
| |
| #include "dyn_bits.h" |
| #include "bit_cnt.h" |
| #include "psy_const.h" |
| #include "aacenc_pns.h" |
| #include "aacEnc_ram.h" |
| #include "aacEnc_rom.h" |
| |
| typedef INT (*lookUpTable)[CODE_BOOK_ESC_NDX + 1]; |
| |
| static INT FDKaacEnc_getSideInfoBits(const SECTION_INFO* const huffsection, |
| const SHORT* const sideInfoTab, |
| const INT useHCR) { |
| INT sideInfoBits; |
| |
| if (useHCR && |
| ((huffsection->codeBook == 11) || (huffsection->codeBook >= 16))) { |
| sideInfoBits = 5; |
| } else { |
| sideInfoBits = sideInfoTab[huffsection->sfbCnt]; |
| } |
| |
| return (sideInfoBits); |
| } |
| |
| /* count bits using all possible tables */ |
| static void FDKaacEnc_buildBitLookUp( |
| const SHORT* const quantSpectrum, const INT maxSfb, |
| const INT* const sfbOffset, const UINT* const sfbMax, |
| INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], |
| SECTION_INFO* const huffsection) { |
| INT i, sfbWidth; |
| |
| for (i = 0; i < maxSfb; i++) { |
| huffsection[i].sfbCnt = 1; |
| huffsection[i].sfbStart = i; |
| huffsection[i].sectionBits = INVALID_BITCOUNT; |
| huffsection[i].codeBook = -1; |
| sfbWidth = sfbOffset[i + 1] - sfbOffset[i]; |
| FDKaacEnc_bitCount(quantSpectrum + sfbOffset[i], sfbWidth, sfbMax[i], |
| bitLookUp[i]); |
| } |
| } |
| |
| /* essential helper functions */ |
| static inline INT FDKaacEnc_findBestBook(const INT* const bc, INT* const book, |
| const INT useVCB11) { |
| INT minBits = INVALID_BITCOUNT, j; |
| |
| int end = CODE_BOOK_ESC_NDX; |
| |
| for (j = 0; j <= end; j++) { |
| if (bc[j] < minBits) { |
| minBits = bc[j]; |
| *book = j; |
| } |
| } |
| return (minBits); |
| } |
| |
| static inline INT FDKaacEnc_findMinMergeBits(const INT* const bc1, |
| const INT* const bc2, |
| const INT useVCB11) { |
| INT minBits = INVALID_BITCOUNT, j; |
| |
| DWORD_ALIGNED(bc1); |
| DWORD_ALIGNED(bc2); |
| |
| for (j = 0; j <= CODE_BOOK_ESC_NDX; j++) { |
| minBits = fixMin(minBits, bc1[j] + bc2[j]); |
| } |
| return (minBits); |
| } |
| |
| static inline void FDKaacEnc_mergeBitLookUp(INT* const RESTRICT bc1, |
| const INT* const RESTRICT bc2) { |
| int j; |
| |
| for (j = 0; j <= CODE_BOOK_ESC_NDX; j++) { |
| FDK_ASSERT(INVALID_BITCOUNT == 0x1FFFFFFF); |
| bc1[j] = fixMin(bc1[j] + bc2[j], INVALID_BITCOUNT); |
| } |
| } |
| |
| static inline INT FDKaacEnc_findMaxMerge(const INT* const mergeGainLookUp, |
| const SECTION_INFO* const huffsection, |
| const INT maxSfb, INT* const maxNdx) { |
| INT i, maxMergeGain = 0; |
| int lastMaxNdx = 0; |
| |
| for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) { |
| if (mergeGainLookUp[i] > maxMergeGain) { |
| maxMergeGain = mergeGainLookUp[i]; |
| lastMaxNdx = i; |
| } |
| } |
| *maxNdx = lastMaxNdx; |
| return (maxMergeGain); |
| } |
| |
| static inline INT FDKaacEnc_CalcMergeGain( |
| const SECTION_INFO* const huffsection, |
| const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], |
| const SHORT* const sideInfoTab, const INT ndx1, const INT ndx2, |
| const INT useVCB11) { |
| INT MergeGain, MergeBits, SplitBits; |
| |
| MergeBits = |
| sideInfoTab[huffsection[ndx1].sfbCnt + huffsection[ndx2].sfbCnt] + |
| FDKaacEnc_findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2], useVCB11); |
| SplitBits = |
| huffsection[ndx1].sectionBits + |
| huffsection[ndx2].sectionBits; /* Bit amount for splitted huffsections */ |
| MergeGain = SplitBits - MergeBits; |
| |
| if ((huffsection[ndx1].codeBook == CODE_BOOK_PNS_NO) || |
| (huffsection[ndx2].codeBook == CODE_BOOK_PNS_NO) || |
| (huffsection[ndx1].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || |
| (huffsection[ndx2].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || |
| (huffsection[ndx1].codeBook == CODE_BOOK_IS_IN_PHASE_NO) || |
| (huffsection[ndx2].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) { |
| MergeGain = -1; |
| } |
| |
| return (MergeGain); |
| } |
| |
| /* sectioning Stage 0:find minimum codbooks */ |
| static void FDKaacEnc_gmStage0( |
| SECTION_INFO* const RESTRICT huffsection, |
| const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb, |
| const INT* const noiseNrg, const INT* const isBook) { |
| INT i; |
| |
| for (i = 0; i < maxSfb; i++) { |
| /* Side-Info bits will be calculated in Stage 1! */ |
| if (huffsection[i].sectionBits == INVALID_BITCOUNT) { |
| /* intensity and pns codebooks are already allocated in bitcount.c */ |
| if (noiseNrg[i] != NO_NOISE_PNS) { |
| huffsection[i].codeBook = CODE_BOOK_PNS_NO; |
| huffsection[i].sectionBits = 0; |
| } else if (isBook[i]) { |
| huffsection[i].codeBook = isBook[i]; |
| huffsection[i].sectionBits = 0; |
| } else { |
| huffsection[i].sectionBits = |
| FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), |
| 0); /* useVCB11 must be 0!!! */ |
| } |
| } |
| } |
| } |
| |
| /* |
| sectioning Stage 1:merge all connected regions with the same code book and |
| calculate side info |
| */ |
| static void FDKaacEnc_gmStage1( |
| SECTION_INFO* const RESTRICT huffsection, |
| INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb, |
| const SHORT* const sideInfoTab, const INT useVCB11) { |
| INT mergeStart = 0, mergeEnd; |
| |
| do { |
| for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++) { |
| if (huffsection[mergeStart].codeBook != huffsection[mergeEnd].codeBook) |
| break; |
| |
| /* we can merge. update tables, side info bits will be updated outside of |
| * this loop */ |
| huffsection[mergeStart].sfbCnt++; |
| huffsection[mergeStart].sectionBits += huffsection[mergeEnd].sectionBits; |
| |
| /* update bit look up for all code books */ |
| FDKaacEnc_mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]); |
| } |
| |
| /* add side info info bits */ |
| huffsection[mergeStart].sectionBits += FDKaacEnc_getSideInfoBits( |
| &huffsection[mergeStart], sideInfoTab, useVCB11); |
| huffsection[mergeEnd - 1].sfbStart = |
| huffsection[mergeStart].sfbStart; /* speed up prev search */ |
| |
| mergeStart = mergeEnd; |
| |
| } while (mergeStart < maxSfb); |
| } |
| |
| /* |
| sectioning Stage 2:greedy merge algorithm, merge connected sections with |
| maximum bit gain until no more gain is possible |
| */ |
| static inline void FDKaacEnc_gmStage2( |
| SECTION_INFO* const RESTRICT huffsection, |
| INT* const RESTRICT mergeGainLookUp, |
| INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb, |
| const SHORT* const sideInfoTab, const INT useVCB11) { |
| INT i; |
| |
| for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) { |
| mergeGainLookUp[i] = |
| FDKaacEnc_CalcMergeGain(huffsection, bitLookUp, sideInfoTab, i, |
| i + huffsection[i].sfbCnt, useVCB11); |
| } |
| |
| while (TRUE) { |
| INT maxMergeGain, maxNdx, maxNdxNext, maxNdxLast; |
| |
| maxMergeGain = |
| FDKaacEnc_findMaxMerge(mergeGainLookUp, huffsection, maxSfb, &maxNdx); |
| |
| /* exit while loop if no more gain is possible */ |
| if (maxMergeGain <= 0) break; |
| |
| maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt; |
| |
| /* merge sections with maximum bit gain */ |
| huffsection[maxNdx].sfbCnt += huffsection[maxNdxNext].sfbCnt; |
| huffsection[maxNdx].sectionBits += |
| huffsection[maxNdxNext].sectionBits - maxMergeGain; |
| |
| /* update bit look up table for merged huffsection */ |
| FDKaacEnc_mergeBitLookUp(bitLookUp[maxNdx], bitLookUp[maxNdxNext]); |
| |
| /* update mergeLookUpTable */ |
| if (maxNdx != 0) { |
| maxNdxLast = huffsection[maxNdx - 1].sfbStart; |
| mergeGainLookUp[maxNdxLast] = FDKaacEnc_CalcMergeGain( |
| huffsection, bitLookUp, sideInfoTab, maxNdxLast, maxNdx, useVCB11); |
| } |
| maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt; |
| |
| huffsection[maxNdxNext - 1].sfbStart = huffsection[maxNdx].sfbStart; |
| |
| if (maxNdxNext < maxSfb) |
| mergeGainLookUp[maxNdx] = FDKaacEnc_CalcMergeGain( |
| huffsection, bitLookUp, sideInfoTab, maxNdx, maxNdxNext, useVCB11); |
| } |
| } |
| |
| /* count bits used by the noiseless coder */ |
| static void FDKaacEnc_noiselessCounter( |
| SECTION_DATA* const RESTRICT sectionData, INT mergeGainLookUp[MAX_SFB_LONG], |
| INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], |
| const SHORT* const quantSpectrum, const UINT* const maxValueInSfb, |
| const INT* const sfbOffset, const INT blockType, const INT* const noiseNrg, |
| const INT* const isBook, const INT useVCB11) { |
| INT grpNdx, i; |
| const SHORT* sideInfoTab = NULL; |
| SECTION_INFO* huffsection; |
| |
| /* use appropriate side info table */ |
| switch (blockType) { |
| case LONG_WINDOW: |
| case START_WINDOW: |
| case STOP_WINDOW: |
| default: |
| sideInfoTab = FDKaacEnc_sideInfoTabLong; |
| break; |
| case SHORT_WINDOW: |
| sideInfoTab = FDKaacEnc_sideInfoTabShort; |
| break; |
| } |
| |
| sectionData->noOfSections = 0; |
| sectionData->huffmanBits = 0; |
| sectionData->sideInfoBits = 0; |
| |
| if (sectionData->maxSfbPerGroup == 0) return; |
| |
| /* loop trough groups */ |
| for (grpNdx = 0; grpNdx < sectionData->sfbCnt; |
| grpNdx += sectionData->sfbPerGroup) { |
| huffsection = sectionData->huffsection + sectionData->noOfSections; |
| |
| /* count bits in this group */ |
| FDKaacEnc_buildBitLookUp(quantSpectrum, sectionData->maxSfbPerGroup, |
| sfbOffset + grpNdx, maxValueInSfb + grpNdx, |
| bitLookUp, huffsection); |
| |
| /* 0.Stage :Find minimum Codebooks */ |
| FDKaacEnc_gmStage0(huffsection, bitLookUp, sectionData->maxSfbPerGroup, |
| noiseNrg + grpNdx, isBook + grpNdx); |
| |
| /* 1.Stage :Merge all connected regions with the same code book */ |
| FDKaacEnc_gmStage1(huffsection, bitLookUp, sectionData->maxSfbPerGroup, |
| sideInfoTab, useVCB11); |
| |
| /* |
| 2.Stage |
| greedy merge algorithm, merge connected huffsections with maximum bit |
| gain until no more gain is possible |
| */ |
| |
| FDKaacEnc_gmStage2(huffsection, mergeGainLookUp, bitLookUp, |
| sectionData->maxSfbPerGroup, sideInfoTab, useVCB11); |
| |
| /* |
| compress output, calculate total huff and side bits |
| since we did not update the actual codebook in stage 2 |
| to save time, we must set it here for later use in bitenc |
| */ |
| |
| for (i = 0; i < sectionData->maxSfbPerGroup; i += huffsection[i].sfbCnt) { |
| if ((huffsection[i].codeBook == CODE_BOOK_PNS_NO) || |
| (huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || |
| (huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) { |
| huffsection[i].sectionBits = 0; |
| } else { |
| /* the sections in the sectionData are now marked with the optimal code |
| * book */ |
| |
| FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), |
| useVCB11); |
| |
| sectionData->huffmanBits += |
| huffsection[i].sectionBits - |
| FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11); |
| } |
| |
| huffsection[i].sfbStart += grpNdx; |
| |
| /* sum up side info bits (section data bits) */ |
| sectionData->sideInfoBits += |
| FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11); |
| sectionData->huffsection[sectionData->noOfSections++] = huffsection[i]; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| |
| functionname: FDKaacEnc_scfCount |
| returns : --- |
| description : count bits used by scalefactors. |
| |
| not in all cases if maxValueInSfb[] == 0 we set deltaScf |
| to zero. only if the difference of the last and future |
| scalefacGain is not greater then CODE_BOOK_SCF_LAV (60). |
| |
| example: |
| ^ |
| scalefacGain | |
| | |
| | last 75 |
| | | |
| | | |
| | | |
| | | current 50 |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | future 5 |
| | | | | |
| --- ... ---------------------------- ... ---------> |
| sfb |
| |
| |
| if maxValueInSfb[] of current is zero because of a |
| notfallstrategie, we do not save bits and transmit a |
| deltaScf of 25. otherwise the deltaScf between the last |
| scalfacGain (75) and the future scalefacGain (5) is 70. |
| |
| ********************************************************************************/ |
| static void FDKaacEnc_scfCount(const INT* const scalefacGain, |
| const UINT* const maxValueInSfb, |
| SECTION_DATA* const RESTRICT sectionData, |
| const INT* const isScale) { |
| INT i, j, k, m, n; |
| |
| INT lastValScf = 0; |
| INT deltaScf = 0; |
| INT found = 0; |
| INT scfSkipCounter = 0; |
| INT lastValIs = 0; |
| |
| sectionData->scalefacBits = 0; |
| |
| if (scalefacGain == NULL) return; |
| |
| sectionData->firstScf = 0; |
| |
| for (i = 0; i < sectionData->noOfSections; i++) { |
| if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) { |
| sectionData->firstScf = sectionData->huffsection[i].sfbStart; |
| lastValScf = scalefacGain[sectionData->firstScf]; |
| break; |
| } |
| } |
| |
| for (i = 0; i < sectionData->noOfSections; i++) { |
| if ((sectionData->huffsection[i].codeBook == |
| CODE_BOOK_IS_OUT_OF_PHASE_NO) || |
| (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) { |
| for (j = sectionData->huffsection[i].sfbStart; |
| j < sectionData->huffsection[i].sfbStart + |
| sectionData->huffsection[i].sfbCnt; |
| j++) { |
| INT deltaIs = isScale[j] - lastValIs; |
| lastValIs = isScale[j]; |
| sectionData->scalefacBits += |
| FDKaacEnc_bitCountScalefactorDelta(deltaIs); |
| } |
| } /* Intensity */ |
| else if ((sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) && |
| (sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO)) { |
| INT tmp = sectionData->huffsection[i].sfbStart + |
| sectionData->huffsection[i].sfbCnt; |
| for (j = sectionData->huffsection[i].sfbStart; j < tmp; j++) { |
| /* check if we can repeat the last value to save bits */ |
| if (maxValueInSfb[j] == 0) { |
| found = 0; |
| /* are scalefactors skipped? */ |
| if (scfSkipCounter == 0) { |
| /* end of section */ |
| if (j == (tmp - 1)) |
| found = 0; /* search in other sections for maxValueInSfb != 0 */ |
| else { |
| /* search in this section for the next maxValueInSfb[] != 0 */ |
| for (k = (j + 1); k < tmp; k++) { |
| if (maxValueInSfb[k] != 0) { |
| found = 1; |
| if ((fixp_abs(scalefacGain[k] - lastValScf)) <= |
| CODE_BOOK_SCF_LAV) |
| deltaScf = 0; /* save bits */ |
| else { |
| /* do not save bits */ |
| deltaScf = lastValScf - scalefacGain[j]; |
| lastValScf = scalefacGain[j]; |
| scfSkipCounter = 0; |
| } |
| break; |
| } |
| /* count scalefactor skip */ |
| scfSkipCounter++; |
| } |
| } |
| |
| /* search for the next maxValueInSfb[] != 0 in all other sections */ |
| for (m = (i + 1); (m < sectionData->noOfSections) && (found == 0); |
| m++) { |
| if ((sectionData->huffsection[m].codeBook != CODE_BOOK_ZERO_NO) && |
| (sectionData->huffsection[m].codeBook != CODE_BOOK_PNS_NO)) { |
| INT end = sectionData->huffsection[m].sfbStart + |
| sectionData->huffsection[m].sfbCnt; |
| for (n = sectionData->huffsection[m].sfbStart; n < end; n++) { |
| if (maxValueInSfb[n] != 0) { |
| found = 1; |
| if (fixp_abs(scalefacGain[n] - lastValScf) <= |
| CODE_BOOK_SCF_LAV) |
| deltaScf = 0; /* save bits */ |
| else { |
| /* do not save bits */ |
| deltaScf = lastValScf - scalefacGain[j]; |
| lastValScf = scalefacGain[j]; |
| scfSkipCounter = 0; |
| } |
| break; |
| } |
| /* count scalefactor skip */ |
| scfSkipCounter++; |
| } |
| } |
| } |
| /* no maxValueInSfb[] != 0 found */ |
| if (found == 0) { |
| deltaScf = 0; |
| scfSkipCounter = 0; |
| } |
| } else { |
| /* consider skipped scalefactors */ |
| deltaScf = 0; |
| scfSkipCounter--; |
| } |
| } else { |
| deltaScf = lastValScf - scalefacGain[j]; |
| lastValScf = scalefacGain[j]; |
| } |
| sectionData->scalefacBits += |
| FDKaacEnc_bitCountScalefactorDelta(deltaScf); |
| } |
| } |
| } /* for (i=0; i<sectionData->noOfSections; i++) */ |
| } |
| |
| /* count bits used by pns */ |
| static void FDKaacEnc_noiseCount(SECTION_DATA* const RESTRICT sectionData, |
| const INT* const noiseNrg) { |
| INT noisePCMFlag = TRUE; |
| INT lastValPns = 0, deltaPns; |
| int i, j; |
| |
| sectionData->noiseNrgBits = 0; |
| |
| for (i = 0; i < sectionData->noOfSections; i++) { |
| if (sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) { |
| int sfbStart = sectionData->huffsection[i].sfbStart; |
| int sfbEnd = sfbStart + sectionData->huffsection[i].sfbCnt; |
| for (j = sfbStart; j < sfbEnd; j++) { |
| if (noisePCMFlag) { |
| sectionData->noiseNrgBits += PNS_PCM_BITS; |
| lastValPns = noiseNrg[j]; |
| noisePCMFlag = FALSE; |
| } else { |
| deltaPns = noiseNrg[j] - lastValPns; |
| lastValPns = noiseNrg[j]; |
| sectionData->noiseNrgBits += |
| FDKaacEnc_bitCountScalefactorDelta(deltaPns); |
| } |
| } |
| } |
| } |
| } |
| |
| INT FDKaacEnc_dynBitCount(BITCNTR_STATE* const hBC, |
| const SHORT* const quantSpectrum, |
| const UINT* const maxValueInSfb, |
| const INT* const scalefac, const INT blockType, |
| const INT sfbCnt, const INT maxSfbPerGroup, |
| const INT sfbPerGroup, const INT* const sfbOffset, |
| SECTION_DATA* const RESTRICT sectionData, |
| const INT* const noiseNrg, const INT* const isBook, |
| const INT* const isScale, const UINT syntaxFlags) { |
| sectionData->blockType = blockType; |
| sectionData->sfbCnt = sfbCnt; |
| sectionData->sfbPerGroup = sfbPerGroup; |
| sectionData->noOfGroups = sfbCnt / sfbPerGroup; |
| sectionData->maxSfbPerGroup = maxSfbPerGroup; |
| |
| FDKaacEnc_noiselessCounter(sectionData, hBC->mergeGainLookUp, |
| (lookUpTable)hBC->bitLookUp, quantSpectrum, |
| maxValueInSfb, sfbOffset, blockType, noiseNrg, |
| isBook, (syntaxFlags & AC_ER_VCB11) ? 1 : 0); |
| |
| FDKaacEnc_scfCount(scalefac, maxValueInSfb, sectionData, isScale); |
| |
| FDKaacEnc_noiseCount(sectionData, noiseNrg); |
| |
| return (sectionData->huffmanBits + sectionData->sideInfoBits + |
| sectionData->scalefacBits + sectionData->noiseNrgBits); |
| } |
| |
| INT FDKaacEnc_BCNew(BITCNTR_STATE** phBC, UCHAR* dynamic_RAM) { |
| BITCNTR_STATE* hBC = GetRam_aacEnc_BitCntrState(); |
| |
| if (hBC) { |
| *phBC = hBC; |
| hBC->bitLookUp = GetRam_aacEnc_BitLookUp(0, dynamic_RAM); |
| hBC->mergeGainLookUp = GetRam_aacEnc_MergeGainLookUp(0, dynamic_RAM); |
| if (hBC->bitLookUp == 0 || hBC->mergeGainLookUp == 0) { |
| return 1; |
| } |
| } |
| return (hBC == 0) ? 1 : 0; |
| } |
| |
| void FDKaacEnc_BCClose(BITCNTR_STATE** phBC) { |
| if (*phBC != NULL) { |
| FreeRam_aacEnc_BitCntrState(phBC); |
| } |
| } |
