| /* ----------------------------------------------------------------------------- |
| 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: Scale factor estimation |
| |
| *******************************************************************************/ |
| |
| #include "sf_estim.h" |
| #include "aacEnc_rom.h" |
| #include "quantize.h" |
| #include "bit_cnt.h" |
| |
| #ifdef __arm__ |
| #endif |
| |
| #define UPCOUNT_LIMIT 1 |
| #define AS_PE_FAC_SHIFT 7 |
| #define DIST_FAC_SHIFT 3 |
| #define AS_PE_FAC_FLOAT (float)(1 << AS_PE_FAC_SHIFT) |
| static const INT MAX_SCF_DELTA = 60; |
| |
| static const FIXP_DBL PE_C1 = FL2FXCONST_DBL( |
| 3.0f / AS_PE_FAC_FLOAT); /* (log(8.0)/log(2)) >> AS_PE_FAC_SHIFT */ |
| static const FIXP_DBL PE_C2 = FL2FXCONST_DBL( |
| 1.3219281f / AS_PE_FAC_FLOAT); /* (log(2.5)/log(2)) >> AS_PE_FAC_SHIFT */ |
| static const FIXP_DBL PE_C3 = FL2FXCONST_DBL(0.5593573f); /* 1-C2/C1 */ |
| |
| /* |
| Function; FDKaacEnc_FDKaacEnc_CalcFormFactorChannel |
| |
| Description: Calculates the formfactor |
| |
| sf: scale factor of the mdct spectrum |
| sfbFormFactorLdData is scaled with the factor 1/(((2^sf)^0.5) * |
| (2^FORM_FAC_SHIFT)) |
| */ |
| static void FDKaacEnc_FDKaacEnc_CalcFormFactorChannel( |
| FIXP_DBL *RESTRICT sfbFormFactorLdData, |
| PSY_OUT_CHANNEL *RESTRICT psyOutChan) { |
| INT j, sfb, sfbGrp; |
| FIXP_DBL formFactor; |
| |
| int tmp0 = psyOutChan->sfbCnt; |
| int tmp1 = psyOutChan->maxSfbPerGroup; |
| int step = psyOutChan->sfbPerGroup; |
| for (sfbGrp = 0; sfbGrp < tmp0; sfbGrp += step) { |
| for (sfb = 0; sfb < tmp1; sfb++) { |
| formFactor = FL2FXCONST_DBL(0.0f); |
| /* calc sum of sqrt(spec) */ |
| for (j = psyOutChan->sfbOffsets[sfbGrp + sfb]; |
| j < psyOutChan->sfbOffsets[sfbGrp + sfb + 1]; j++) { |
| formFactor += |
| sqrtFixp(fixp_abs(psyOutChan->mdctSpectrum[j])) >> FORM_FAC_SHIFT; |
| } |
| sfbFormFactorLdData[sfbGrp + sfb] = CalcLdData(formFactor); |
| } |
| /* set sfbFormFactor for sfbs with zero spec to zero. Just for debugging. */ |
| for (; sfb < psyOutChan->sfbPerGroup; sfb++) { |
| sfbFormFactorLdData[sfbGrp + sfb] = FL2FXCONST_DBL(-1.0f); |
| } |
| } |
| } |
| |
| /* |
| Function: FDKaacEnc_CalcFormFactor |
| |
| Description: Calls FDKaacEnc_FDKaacEnc_CalcFormFactorChannel() for each |
| channel |
| */ |
| |
| void FDKaacEnc_CalcFormFactor(QC_OUT_CHANNEL *qcOutChannel[(2)], |
| PSY_OUT_CHANNEL *psyOutChannel[(2)], |
| const INT nChannels) { |
| INT j; |
| for (j = 0; j < nChannels; j++) { |
| FDKaacEnc_FDKaacEnc_CalcFormFactorChannel( |
| qcOutChannel[j]->sfbFormFactorLdData, psyOutChannel[j]); |
| } |
| } |
| |
| /* |
| Function: FDKaacEnc_calcSfbRelevantLines |
| |
| Description: Calculates sfbNRelevantLines |
| |
| sfbNRelevantLines is scaled with the factor 1/((2^FORM_FAC_SHIFT) * 2.0) |
| */ |
| static void FDKaacEnc_calcSfbRelevantLines( |
| const FIXP_DBL *const sfbFormFactorLdData, |
| const FIXP_DBL *const sfbEnergyLdData, |
| const FIXP_DBL *const sfbThresholdLdData, const INT *const sfbOffsets, |
| const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup, |
| FIXP_DBL *sfbNRelevantLines) { |
| INT sfbOffs, sfb; |
| FIXP_DBL sfbWidthLdData; |
| FIXP_DBL asPeFacLdData = |
| FL2FXCONST_DBL(0.109375); /* AS_PE_FAC_SHIFT*ld64(2) */ |
| FIXP_DBL accu; |
| |
| /* sfbNRelevantLines[i] = 2^( (sfbFormFactorLdData[i] - 0.25 * |
| * (sfbEnergyLdData[i] - ld64(sfbWidth[i]/(2^7)) - AS_PE_FAC_SHIFT*ld64(2)) * |
| * 64); */ |
| |
| FDKmemclear(sfbNRelevantLines, sfbCnt * sizeof(FIXP_DBL)); |
| |
| for (sfbOffs = 0; sfbOffs < sfbCnt; sfbOffs += sfbPerGroup) { |
| for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { |
| /* calc sum of sqrt(spec) */ |
| if ((FIXP_DBL)sfbEnergyLdData[sfbOffs + sfb] > |
| (FIXP_DBL)sfbThresholdLdData[sfbOffs + sfb]) { |
| INT sfbWidth = |
| sfbOffsets[sfbOffs + sfb + 1] - sfbOffsets[sfbOffs + sfb]; |
| |
| /* avgFormFactorLdData = |
| * sqrtFixp(sqrtFixp(sfbEnergyLdData[sfbOffs+sfb]/sfbWidth)); */ |
| /* sfbNRelevantLines[sfbOffs+sfb] = sfbFormFactor[sfbOffs+sfb] / |
| * avgFormFactorLdData; */ |
| sfbWidthLdData = |
| (FIXP_DBL)(sfbWidth << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT)); |
| sfbWidthLdData = CalcLdData(sfbWidthLdData); |
| |
| accu = sfbEnergyLdData[sfbOffs + sfb] - sfbWidthLdData - asPeFacLdData; |
| accu = sfbFormFactorLdData[sfbOffs + sfb] - (accu >> 2); |
| |
| sfbNRelevantLines[sfbOffs + sfb] = CalcInvLdData(accu) >> 1; |
| } |
| } |
| } |
| } |
| |
| /* |
| Function: FDKaacEnc_countSingleScfBits |
| |
| Description: |
| |
| scfBitsFract is scaled by 1/(2^(2*AS_PE_FAC_SHIFT)) |
| */ |
| static FIXP_DBL FDKaacEnc_countSingleScfBits(INT scf, INT scfLeft, |
| INT scfRight) { |
| FIXP_DBL scfBitsFract; |
| |
| scfBitsFract = (FIXP_DBL)(FDKaacEnc_bitCountScalefactorDelta(scfLeft - scf) + |
| FDKaacEnc_bitCountScalefactorDelta(scf - scfRight)); |
| |
| scfBitsFract = scfBitsFract << (DFRACT_BITS - 1 - (2 * AS_PE_FAC_SHIFT)); |
| |
| return scfBitsFract; /* output scaled by 1/(2^(2*AS_PE_FAC)) */ |
| } |
| |
| /* |
| Function: FDKaacEnc_calcSingleSpecPe |
| |
| specPe is scaled by 1/(2^(2*AS_PE_FAC_SHIFT)) |
| */ |
| static FIXP_DBL FDKaacEnc_calcSingleSpecPe(INT scf, FIXP_DBL sfbConstPePart, |
| FIXP_DBL nLines) { |
| FIXP_DBL specPe = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL ldRatio; |
| FIXP_DBL scfFract; |
| |
| scfFract = (FIXP_DBL)(scf << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT)); |
| |
| ldRatio = sfbConstPePart - fMult(FL2FXCONST_DBL(0.375f), scfFract); |
| |
| if (ldRatio >= PE_C1) { |
| specPe = fMult(FL2FXCONST_DBL(0.7f), fMult(nLines, ldRatio)); |
| } else { |
| specPe = fMult(FL2FXCONST_DBL(0.7f), |
| fMult(nLines, (PE_C2 + fMult(PE_C3, ldRatio)))); |
| } |
| |
| return specPe; /* output scaled by 1/(2^(2*AS_PE_FAC)) */ |
| } |
| |
| /* |
| Function: FDKaacEnc_countScfBitsDiff |
| |
| scfBitsDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT)) |
| */ |
| static FIXP_DBL FDKaacEnc_countScfBitsDiff(INT *scfOld, INT *scfNew, INT sfbCnt, |
| INT startSfb, INT stopSfb) { |
| FIXP_DBL scfBitsFract; |
| INT scfBitsDiff = 0; |
| INT sfb = 0, sfbLast; |
| INT sfbPrev, sfbNext; |
| |
| /* search for first relevant sfb */ |
| sfbLast = startSfb; |
| while ((sfbLast < stopSfb) && (scfOld[sfbLast] == FDK_INT_MIN)) sfbLast++; |
| /* search for previous relevant sfb and count diff */ |
| sfbPrev = startSfb - 1; |
| while ((sfbPrev >= 0) && (scfOld[sfbPrev] == FDK_INT_MIN)) sfbPrev--; |
| if (sfbPrev >= 0) |
| scfBitsDiff += |
| FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbPrev] - scfNew[sfbLast]) - |
| FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbPrev] - scfOld[sfbLast]); |
| /* now loop through all sfbs and count diffs of relevant sfbs */ |
| for (sfb = sfbLast + 1; sfb < stopSfb; sfb++) { |
| if (scfOld[sfb] != FDK_INT_MIN) { |
| scfBitsDiff += |
| FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast] - scfNew[sfb]) - |
| FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast] - scfOld[sfb]); |
| sfbLast = sfb; |
| } |
| } |
| /* search for next relevant sfb and count diff */ |
| sfbNext = stopSfb; |
| while ((sfbNext < sfbCnt) && (scfOld[sfbNext] == FDK_INT_MIN)) sfbNext++; |
| if (sfbNext < sfbCnt) |
| scfBitsDiff += |
| FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast] - scfNew[sfbNext]) - |
| FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast] - scfOld[sfbNext]); |
| |
| scfBitsFract = |
| (FIXP_DBL)(scfBitsDiff << (DFRACT_BITS - 1 - (2 * AS_PE_FAC_SHIFT))); |
| |
| return scfBitsFract; |
| } |
| |
| /* |
| Function: FDKaacEnc_calcSpecPeDiff |
| |
| specPeDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT)) |
| */ |
| static FIXP_DBL FDKaacEnc_calcSpecPeDiff( |
| PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, INT *scfOld, |
| INT *scfNew, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData, |
| FIXP_DBL *sfbNRelevantLines, INT startSfb, INT stopSfb) { |
| FIXP_DBL specPeDiff = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL scfFract = FL2FXCONST_DBL(0.0f); |
| INT sfb; |
| |
| /* loop through all sfbs and count pe difference */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfOld[sfb] != FDK_INT_MIN) { |
| FIXP_DBL ldRatioOld, ldRatioNew, pOld, pNew; |
| |
| /* sfbConstPePart[sfb] = (float)log(psyOutChan->sfbEnergy[sfb] * 6.75f / |
| * sfbFormFactor[sfb]) * LOG2_1; */ |
| /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for |
| * log2 */ |
| /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */ |
| if (sfbConstPePart[sfb] == (FIXP_DBL)FDK_INT_MIN) |
| sfbConstPePart[sfb] = |
| ((psyOutChan->sfbEnergyLdData[sfb] - sfbFormFactorLdData[sfb] - |
| FL2FXCONST_DBL(0.09375f)) >> |
| 1) + |
| FL2FXCONST_DBL(0.02152255861f); |
| |
| scfFract = (FIXP_DBL)(scfOld[sfb] << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT)); |
| ldRatioOld = |
| sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f), scfFract); |
| |
| scfFract = (FIXP_DBL)(scfNew[sfb] << (DFRACT_BITS - 1 - AS_PE_FAC_SHIFT)); |
| ldRatioNew = |
| sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f), scfFract); |
| |
| if (ldRatioOld >= PE_C1) |
| pOld = ldRatioOld; |
| else |
| pOld = PE_C2 + fMult(PE_C3, ldRatioOld); |
| |
| if (ldRatioNew >= PE_C1) |
| pNew = ldRatioNew; |
| else |
| pNew = PE_C2 + fMult(PE_C3, ldRatioNew); |
| |
| specPeDiff += fMult(FL2FXCONST_DBL(0.7f), |
| fMult(sfbNRelevantLines[sfb], (pNew - pOld))); |
| } |
| } |
| |
| return specPeDiff; |
| } |
| |
| /* |
| Function: FDKaacEnc_improveScf |
| |
| Description: Calculate the distortion by quantization and inverse quantization |
| of the spectrum with various scalefactors. The scalefactor which provides the |
| best results will be used. |
| */ |
| static INT FDKaacEnc_improveScf(const FIXP_DBL *spec, SHORT *quantSpec, |
| SHORT *quantSpecTmp, INT sfbWidth, |
| FIXP_DBL threshLdData, INT scf, INT minScf, |
| FIXP_DBL *distLdData, INT *minScfCalculated, |
| INT dZoneQuantEnable) { |
| FIXP_DBL sfbDistLdData; |
| INT scfBest = scf; |
| INT k; |
| FIXP_DBL distFactorLdData = FL2FXCONST_DBL(-0.0050301265); /* ld64(1/1.25) */ |
| |
| /* calc real distortion */ |
| sfbDistLdData = |
| FDKaacEnc_calcSfbDist(spec, quantSpec, sfbWidth, scf, dZoneQuantEnable); |
| *minScfCalculated = scf; |
| /* nmr > 1.25 -> try to improve nmr */ |
| if (sfbDistLdData > (threshLdData - distFactorLdData)) { |
| INT scfEstimated = scf; |
| FIXP_DBL sfbDistBestLdData = sfbDistLdData; |
| INT cnt; |
| /* improve by bigger scf ? */ |
| cnt = 0; |
| |
| while ((sfbDistLdData > (threshLdData - distFactorLdData)) && |
| (cnt++ < UPCOUNT_LIMIT)) { |
| scf++; |
| sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf, |
| dZoneQuantEnable); |
| |
| if (sfbDistLdData < sfbDistBestLdData) { |
| scfBest = scf; |
| sfbDistBestLdData = sfbDistLdData; |
| for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k]; |
| } |
| } |
| /* improve by smaller scf ? */ |
| cnt = 0; |
| scf = scfEstimated; |
| sfbDistLdData = sfbDistBestLdData; |
| while ((sfbDistLdData > (threshLdData - distFactorLdData)) && (cnt++ < 1) && |
| (scf > minScf)) { |
| scf--; |
| sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf, |
| dZoneQuantEnable); |
| |
| if (sfbDistLdData < sfbDistBestLdData) { |
| scfBest = scf; |
| sfbDistBestLdData = sfbDistLdData; |
| for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k]; |
| } |
| *minScfCalculated = scf; |
| } |
| *distLdData = sfbDistBestLdData; |
| } else { /* nmr <= 1.25 -> try to find bigger scf to use less bits */ |
| FIXP_DBL sfbDistBestLdData = sfbDistLdData; |
| FIXP_DBL sfbDistAllowedLdData = |
| fixMin(sfbDistLdData - distFactorLdData, threshLdData); |
| int cnt; |
| for (cnt = 0; cnt < UPCOUNT_LIMIT; cnt++) { |
| scf++; |
| sfbDistLdData = FDKaacEnc_calcSfbDist(spec, quantSpecTmp, sfbWidth, scf, |
| dZoneQuantEnable); |
| |
| if (sfbDistLdData < sfbDistAllowedLdData) { |
| *minScfCalculated = scfBest + 1; |
| scfBest = scf; |
| sfbDistBestLdData = sfbDistLdData; |
| for (k = 0; k < sfbWidth; k++) quantSpec[k] = quantSpecTmp[k]; |
| } |
| } |
| *distLdData = sfbDistBestLdData; |
| } |
| |
| /* return best scalefactor */ |
| return scfBest; |
| } |
| |
| /* |
| Function: FDKaacEnc_assimilateSingleScf |
| |
| */ |
| static void FDKaacEnc_assimilateSingleScf( |
| const PSY_OUT_CHANNEL *psyOutChan, const QC_OUT_CHANNEL *qcOutChannel, |
| SHORT *quantSpec, SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf, |
| const INT *minScf, FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart, |
| const FIXP_DBL *sfbFormFactorLdData, const FIXP_DBL *sfbNRelevantLines, |
| INT *minScfCalculated, INT restartOnSuccess) { |
| INT sfbLast, sfbAct, sfbNext; |
| INT scfAct, *scfLast, *scfNext, scfMin, scfMax; |
| INT sfbWidth, sfbOffs; |
| FIXP_DBL enLdData; |
| FIXP_DBL sfbPeOld, sfbPeNew; |
| FIXP_DBL sfbDistNew; |
| INT i, k; |
| INT success = 0; |
| FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL deltaPeNew, deltaPeTmp; |
| INT prevScfLast[MAX_GROUPED_SFB], prevScfNext[MAX_GROUPED_SFB]; |
| FIXP_DBL deltaPeLast[MAX_GROUPED_SFB]; |
| INT updateMinScfCalculated; |
| |
| for (i = 0; i < psyOutChan->sfbCnt; i++) { |
| prevScfLast[i] = FDK_INT_MAX; |
| prevScfNext[i] = FDK_INT_MAX; |
| deltaPeLast[i] = (FIXP_DBL)FDK_INT_MAX; |
| } |
| |
| sfbLast = -1; |
| sfbAct = -1; |
| sfbNext = -1; |
| scfLast = 0; |
| scfNext = 0; |
| scfMin = FDK_INT_MAX; |
| scfMax = FDK_INT_MAX; |
| do { |
| /* search for new relevant sfb */ |
| sfbNext++; |
| while ((sfbNext < psyOutChan->sfbCnt) && (scf[sfbNext] == FDK_INT_MIN)) |
| sfbNext++; |
| if ((sfbLast >= 0) && (sfbAct >= 0) && (sfbNext < psyOutChan->sfbCnt)) { |
| /* relevant scfs to the left and to the right */ |
| scfAct = scf[sfbAct]; |
| scfLast = scf + sfbLast; |
| scfNext = scf + sfbNext; |
| scfMin = fixMin(*scfLast, *scfNext); |
| scfMax = fixMax(*scfLast, *scfNext); |
| } else if ((sfbLast == -1) && (sfbAct >= 0) && |
| (sfbNext < psyOutChan->sfbCnt)) { |
| /* first relevant scf */ |
| scfAct = scf[sfbAct]; |
| scfLast = &scfAct; |
| scfNext = scf + sfbNext; |
| scfMin = *scfNext; |
| scfMax = *scfNext; |
| } else if ((sfbLast >= 0) && (sfbAct >= 0) && |
| (sfbNext == psyOutChan->sfbCnt)) { |
| /* last relevant scf */ |
| scfAct = scf[sfbAct]; |
| scfLast = scf + sfbLast; |
| scfNext = &scfAct; |
| scfMin = *scfLast; |
| scfMax = *scfLast; |
| } |
| if (sfbAct >= 0) scfMin = fixMax(scfMin, minScf[sfbAct]); |
| |
| if ((sfbAct >= 0) && (sfbLast >= 0 || sfbNext < psyOutChan->sfbCnt) && |
| (scfAct > scfMin) && (scfAct <= scfMin + MAX_SCF_DELTA) && |
| (scfAct >= scfMax - MAX_SCF_DELTA) && |
| (scfAct <= |
| fixMin(scfMin, fixMin(*scfLast, *scfNext)) + MAX_SCF_DELTA) && |
| (*scfLast != prevScfLast[sfbAct] || *scfNext != prevScfNext[sfbAct] || |
| deltaPe < deltaPeLast[sfbAct])) { |
| /* bigger than neighbouring scf found, try to use smaller scf */ |
| success = 0; |
| |
| sfbWidth = |
| psyOutChan->sfbOffsets[sfbAct + 1] - psyOutChan->sfbOffsets[sfbAct]; |
| sfbOffs = psyOutChan->sfbOffsets[sfbAct]; |
| |
| /* estimate required bits for actual scf */ |
| enLdData = qcOutChannel->sfbEnergyLdData[sfbAct]; |
| |
| /* sfbConstPePart[sfbAct] = (float)log(6.75f*en/sfbFormFactor[sfbAct]) * |
| * LOG2_1; */ |
| /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for |
| * log2 */ |
| /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */ |
| if (sfbConstPePart[sfbAct] == (FIXP_DBL)FDK_INT_MIN) { |
| sfbConstPePart[sfbAct] = ((enLdData - sfbFormFactorLdData[sfbAct] - |
| FL2FXCONST_DBL(0.09375f)) >> |
| 1) + |
| FL2FXCONST_DBL(0.02152255861f); |
| } |
| |
| sfbPeOld = FDKaacEnc_calcSingleSpecPe(scfAct, sfbConstPePart[sfbAct], |
| sfbNRelevantLines[sfbAct]) + |
| FDKaacEnc_countSingleScfBits(scfAct, *scfLast, *scfNext); |
| |
| deltaPeNew = deltaPe; |
| updateMinScfCalculated = 1; |
| |
| do { |
| /* estimate required bits for smaller scf */ |
| scfAct--; |
| /* check only if the same check was not done before */ |
| if (scfAct < minScfCalculated[sfbAct] && |
| scfAct >= scfMax - MAX_SCF_DELTA) { |
| /* estimate required bits for new scf */ |
| sfbPeNew = FDKaacEnc_calcSingleSpecPe(scfAct, sfbConstPePart[sfbAct], |
| sfbNRelevantLines[sfbAct]) + |
| FDKaacEnc_countSingleScfBits(scfAct, *scfLast, *scfNext); |
| |
| /* use new scf if no increase in pe and |
| quantization error is smaller */ |
| deltaPeTmp = deltaPe + sfbPeNew - sfbPeOld; |
| /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */ |
| if (deltaPeTmp < FL2FXCONST_DBL(0.0006103515625f)) { |
| /* distortion of new scf */ |
| sfbDistNew = FDKaacEnc_calcSfbDist( |
| qcOutChannel->mdctSpectrum + sfbOffs, quantSpecTmp + sfbOffs, |
| sfbWidth, scfAct, dZoneQuantEnable); |
| |
| if (sfbDistNew < sfbDist[sfbAct]) { |
| /* success, replace scf by new one */ |
| scf[sfbAct] = scfAct; |
| sfbDist[sfbAct] = sfbDistNew; |
| |
| for (k = 0; k < sfbWidth; k++) |
| quantSpec[sfbOffs + k] = quantSpecTmp[sfbOffs + k]; |
| |
| deltaPeNew = deltaPeTmp; |
| success = 1; |
| } |
| /* mark as already checked */ |
| if (updateMinScfCalculated) minScfCalculated[sfbAct] = scfAct; |
| } else { |
| /* from this scf value on not all new values have been checked */ |
| updateMinScfCalculated = 0; |
| } |
| } |
| } while (scfAct > scfMin); |
| |
| deltaPe = deltaPeNew; |
| |
| /* save parameters to avoid multiple computations of the same sfb */ |
| prevScfLast[sfbAct] = *scfLast; |
| prevScfNext[sfbAct] = *scfNext; |
| deltaPeLast[sfbAct] = deltaPe; |
| } |
| |
| if (success && restartOnSuccess) { |
| /* start again at first sfb */ |
| sfbLast = -1; |
| sfbAct = -1; |
| sfbNext = -1; |
| scfLast = 0; |
| scfNext = 0; |
| scfMin = FDK_INT_MAX; |
| scfMax = FDK_INT_MAX; |
| success = 0; |
| } else { |
| /* shift sfbs for next band */ |
| sfbLast = sfbAct; |
| sfbAct = sfbNext; |
| } |
| } while (sfbNext < psyOutChan->sfbCnt); |
| } |
| |
| /* |
| Function: FDKaacEnc_assimilateMultipleScf |
| |
| */ |
| static void FDKaacEnc_assimilateMultipleScf( |
| PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, SHORT *quantSpec, |
| SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf, const INT *minScf, |
| FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData, |
| FIXP_DBL *sfbNRelevantLines) { |
| INT sfb, startSfb, stopSfb; |
| INT scfTmp[MAX_GROUPED_SFB], scfMin, scfMax, scfAct; |
| INT possibleRegionFound; |
| INT sfbWidth, sfbOffs, i, k; |
| FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], distOldSum, distNewSum; |
| INT deltaScfBits; |
| FIXP_DBL deltaSpecPe; |
| FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL deltaPeNew; |
| INT sfbCnt = psyOutChan->sfbCnt; |
| |
| /* calc min and max scalfactors */ |
| scfMin = FDK_INT_MAX; |
| scfMax = FDK_INT_MIN; |
| for (sfb = 0; sfb < sfbCnt; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| scfMin = fixMin(scfMin, scf[sfb]); |
| scfMax = fixMax(scfMax, scf[sfb]); |
| } |
| } |
| |
| if (scfMax != FDK_INT_MIN && scfMax <= scfMin + MAX_SCF_DELTA) { |
| scfAct = scfMax; |
| |
| do { |
| /* try smaller scf */ |
| scfAct--; |
| for (i = 0; i < MAX_GROUPED_SFB; i++) scfTmp[i] = scf[i]; |
| stopSfb = 0; |
| do { |
| /* search for region where all scfs are bigger than scfAct */ |
| sfb = stopSfb; |
| while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN || scf[sfb] <= scfAct)) |
| sfb++; |
| startSfb = sfb; |
| sfb++; |
| while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN || scf[sfb] > scfAct)) |
| sfb++; |
| stopSfb = sfb; |
| |
| /* check if in all sfb of a valid region scfAct >= minScf[sfb] */ |
| possibleRegionFound = 0; |
| if (startSfb < sfbCnt) { |
| possibleRegionFound = 1; |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) |
| if (scfAct < minScf[sfb]) { |
| possibleRegionFound = 0; |
| break; |
| } |
| } |
| } |
| |
| if (possibleRegionFound) { /* region found */ |
| |
| /* replace scfs in region by scfAct */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) scfTmp[sfb] = scfAct; |
| } |
| |
| /* estimate change in bit demand for new scfs */ |
| deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt, |
| startSfb, stopSfb); |
| |
| deltaSpecPe = FDKaacEnc_calcSpecPeDiff( |
| psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart, |
| sfbFormFactorLdData, sfbNRelevantLines, startSfb, stopSfb); |
| |
| deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe; |
| |
| /* new bit demand small enough ? */ |
| /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */ |
| if (deltaPeNew < FL2FXCONST_DBL(0.0006103515625f)) { |
| /* quantize and calc sum of new distortion */ |
| distOldSum = distNewSum = FL2FXCONST_DBL(0.0f); |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) { |
| distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT; |
| |
| sfbWidth = psyOutChan->sfbOffsets[sfb + 1] - |
| psyOutChan->sfbOffsets[sfb]; |
| sfbOffs = psyOutChan->sfbOffsets[sfb]; |
| |
| sfbDistNew[sfb] = FDKaacEnc_calcSfbDist( |
| qcOutChannel->mdctSpectrum + sfbOffs, |
| quantSpecTmp + sfbOffs, sfbWidth, scfAct, dZoneQuantEnable); |
| |
| if (sfbDistNew[sfb] > qcOutChannel->sfbThresholdLdData[sfb]) { |
| /* no improvement, skip further dist. calculations */ |
| distNewSum = distOldSum << 1; |
| break; |
| } |
| distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT; |
| } |
| } |
| /* distortion smaller ? -> use new scalefactors */ |
| if (distNewSum < distOldSum) { |
| deltaPe = deltaPeNew; |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| sfbWidth = psyOutChan->sfbOffsets[sfb + 1] - |
| psyOutChan->sfbOffsets[sfb]; |
| sfbOffs = psyOutChan->sfbOffsets[sfb]; |
| scf[sfb] = scfAct; |
| sfbDist[sfb] = sfbDistNew[sfb]; |
| |
| for (k = 0; k < sfbWidth; k++) |
| quantSpec[sfbOffs + k] = quantSpecTmp[sfbOffs + k]; |
| } |
| } |
| } |
| } |
| } |
| |
| } while (stopSfb <= sfbCnt); |
| |
| } while (scfAct > scfMin); |
| } |
| } |
| |
| /* |
| Function: FDKaacEnc_FDKaacEnc_assimilateMultipleScf2 |
| |
| */ |
| static void FDKaacEnc_FDKaacEnc_assimilateMultipleScf2( |
| PSY_OUT_CHANNEL *psyOutChan, QC_OUT_CHANNEL *qcOutChannel, SHORT *quantSpec, |
| SHORT *quantSpecTmp, INT dZoneQuantEnable, INT *scf, const INT *minScf, |
| FIXP_DBL *sfbDist, FIXP_DBL *sfbConstPePart, FIXP_DBL *sfbFormFactorLdData, |
| FIXP_DBL *sfbNRelevantLines) { |
| INT sfb, startSfb, stopSfb; |
| INT scfTmp[MAX_GROUPED_SFB], scfAct, scfNew; |
| INT scfPrev, scfNext, scfPrevNextMin, scfPrevNextMax, scfLo, scfHi; |
| INT scfMin, scfMax; |
| INT *sfbOffs = psyOutChan->sfbOffsets; |
| FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], sfbDistMax[MAX_GROUPED_SFB]; |
| FIXP_DBL distOldSum, distNewSum; |
| INT deltaScfBits; |
| FIXP_DBL deltaSpecPe; |
| FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f); |
| FIXP_DBL deltaPeNew = FL2FXCONST_DBL(0.0f); |
| INT sfbCnt = psyOutChan->sfbCnt; |
| INT bSuccess, bCheckScf; |
| INT i, k; |
| |
| /* calc min and max scalfactors */ |
| scfMin = FDK_INT_MAX; |
| scfMax = FDK_INT_MIN; |
| for (sfb = 0; sfb < sfbCnt; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| scfMin = fixMin(scfMin, scf[sfb]); |
| scfMax = fixMax(scfMax, scf[sfb]); |
| } |
| } |
| |
| stopSfb = 0; |
| scfAct = FDK_INT_MIN; |
| do { |
| /* search for region with same scf values scfAct */ |
| scfPrev = scfAct; |
| |
| sfb = stopSfb; |
| while (sfb < sfbCnt && (scf[sfb] == FDK_INT_MIN)) sfb++; |
| startSfb = sfb; |
| scfAct = scf[startSfb]; |
| sfb++; |
| while (sfb < sfbCnt && |
| ((scf[sfb] == FDK_INT_MIN) || (scf[sfb] == scf[startSfb]))) |
| sfb++; |
| stopSfb = sfb; |
| |
| if (stopSfb < sfbCnt) |
| scfNext = scf[stopSfb]; |
| else |
| scfNext = scfAct; |
| |
| if (scfPrev == FDK_INT_MIN) scfPrev = scfAct; |
| |
| scfPrevNextMax = fixMax(scfPrev, scfNext); |
| scfPrevNextMin = fixMin(scfPrev, scfNext); |
| |
| /* try to reduce bits by checking scf values in the range |
| scf[startSfb]...scfHi */ |
| scfHi = fixMax(scfPrevNextMax, scfAct); |
| /* try to find a better solution by reducing the scf difference to |
| the nearest possible lower scf */ |
| if (scfPrevNextMax >= scfAct) |
| scfLo = fixMin(scfAct, scfPrevNextMin); |
| else |
| scfLo = scfPrevNextMax; |
| |
| if (startSfb < sfbCnt && |
| scfHi - scfLo <= MAX_SCF_DELTA) { /* region found */ |
| /* 1. try to save bits by coarser quantization */ |
| if (scfHi > scf[startSfb]) { |
| /* calculate the allowed distortion */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| /* sfbDistMax[sfb] = |
| * (float)pow(qcOutChannel->sfbThreshold[sfb]*sfbDist[sfb]*sfbDist[sfb],1.0f/3.0f); |
| */ |
| /* sfbDistMax[sfb] = |
| * fixMax(sfbDistMax[sfb],qcOutChannel->sfbEnergy[sfb]*FL2FXCONST_DBL(1.e-3f)); |
| */ |
| /* -0.15571537944 = ld64(1.e-3f)*/ |
| sfbDistMax[sfb] = fMult(FL2FXCONST_DBL(1.0f / 3.0f), |
| qcOutChannel->sfbThresholdLdData[sfb]) + |
| fMult(FL2FXCONST_DBL(1.0f / 3.0f), sfbDist[sfb]) + |
| fMult(FL2FXCONST_DBL(1.0f / 3.0f), sfbDist[sfb]); |
| sfbDistMax[sfb] = |
| fixMax(sfbDistMax[sfb], qcOutChannel->sfbEnergyLdData[sfb] - |
| FL2FXCONST_DBL(0.15571537944)); |
| sfbDistMax[sfb] = |
| fixMin(sfbDistMax[sfb], qcOutChannel->sfbThresholdLdData[sfb]); |
| } |
| } |
| |
| /* loop over all possible scf values for this region */ |
| bCheckScf = 1; |
| for (scfNew = scf[startSfb] + 1; scfNew <= scfHi; scfNew++) { |
| for (k = 0; k < MAX_GROUPED_SFB; k++) scfTmp[k] = scf[k]; |
| |
| /* replace scfs in region by scfNew */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) scfTmp[sfb] = scfNew; |
| } |
| |
| /* estimate change in bit demand for new scfs */ |
| deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt, |
| startSfb, stopSfb); |
| |
| deltaSpecPe = FDKaacEnc_calcSpecPeDiff( |
| psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart, |
| sfbFormFactorLdData, sfbNRelevantLines, startSfb, stopSfb); |
| |
| deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe; |
| |
| /* new bit demand small enough ? */ |
| if (deltaPeNew < FL2FXCONST_DBL(0.0f)) { |
| bSuccess = 1; |
| |
| /* quantize and calc sum of new distortion */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) { |
| sfbDistNew[sfb] = FDKaacEnc_calcSfbDist( |
| qcOutChannel->mdctSpectrum + sfbOffs[sfb], |
| quantSpecTmp + sfbOffs[sfb], |
| sfbOffs[sfb + 1] - sfbOffs[sfb], scfNew, dZoneQuantEnable); |
| |
| if (sfbDistNew[sfb] > sfbDistMax[sfb]) { |
| /* no improvement, skip further dist. calculations */ |
| bSuccess = 0; |
| if (sfbDistNew[sfb] == qcOutChannel->sfbEnergyLdData[sfb]) { |
| /* if whole sfb is already quantized to 0, further |
| checks with even coarser quant. are useless*/ |
| bCheckScf = 0; |
| } |
| break; |
| } |
| } |
| } |
| if (bCheckScf == 0) /* further calculations useless ? */ |
| break; |
| /* distortion small enough ? -> use new scalefactors */ |
| if (bSuccess) { |
| deltaPe = deltaPeNew; |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| scf[sfb] = scfNew; |
| sfbDist[sfb] = sfbDistNew[sfb]; |
| |
| for (k = 0; k < sfbOffs[sfb + 1] - sfbOffs[sfb]; k++) |
| quantSpec[sfbOffs[sfb] + k] = |
| quantSpecTmp[sfbOffs[sfb] + k]; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /* 2. only if coarser quantization was not successful, try to find |
| a better solution by finer quantization and reducing bits for |
| scalefactor coding */ |
| if (scfAct == scf[startSfb] && scfLo < scfAct && |
| scfMax - scfMin <= MAX_SCF_DELTA) { |
| int bminScfViolation = 0; |
| |
| for (k = 0; k < MAX_GROUPED_SFB; k++) scfTmp[k] = scf[k]; |
| |
| scfNew = scfLo; |
| |
| /* replace scfs in region by scfNew and |
| check if in all sfb scfNew >= minScf[sfb] */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) { |
| scfTmp[sfb] = scfNew; |
| if (scfNew < minScf[sfb]) bminScfViolation = 1; |
| } |
| } |
| |
| if (!bminScfViolation) { |
| /* estimate change in bit demand for new scfs */ |
| deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt, |
| startSfb, stopSfb); |
| |
| deltaSpecPe = FDKaacEnc_calcSpecPeDiff( |
| psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart, |
| sfbFormFactorLdData, sfbNRelevantLines, startSfb, stopSfb); |
| |
| deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe; |
| } |
| |
| /* new bit demand small enough ? */ |
| if (!bminScfViolation && deltaPeNew < FL2FXCONST_DBL(0.0f)) { |
| /* quantize and calc sum of new distortion */ |
| distOldSum = distNewSum = FL2FXCONST_DBL(0.0f); |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) { |
| distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT; |
| |
| sfbDistNew[sfb] = FDKaacEnc_calcSfbDist( |
| qcOutChannel->mdctSpectrum + sfbOffs[sfb], |
| quantSpecTmp + sfbOffs[sfb], sfbOffs[sfb + 1] - sfbOffs[sfb], |
| scfNew, dZoneQuantEnable); |
| |
| if (sfbDistNew[sfb] > qcOutChannel->sfbThresholdLdData[sfb]) { |
| /* no improvement, skip further dist. calculations */ |
| distNewSum = distOldSum << 1; |
| break; |
| } |
| distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT; |
| } |
| } |
| /* distortion smaller ? -> use new scalefactors */ |
| if (distNewSum < fMult(FL2FXCONST_DBL(0.8f), distOldSum)) { |
| deltaPe = deltaPeNew; |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| scf[sfb] = scfNew; |
| sfbDist[sfb] = sfbDistNew[sfb]; |
| |
| for (k = 0; k < sfbOffs[sfb + 1] - sfbOffs[sfb]; k++) |
| quantSpec[sfbOffs[sfb] + k] = quantSpecTmp[sfbOffs[sfb] + k]; |
| } |
| } |
| } |
| } |
| } |
| |
| /* 3. try to find a better solution (save bits) by only reducing the |
| scalefactor without new quantization */ |
| if (scfMax - scfMin <= |
| MAX_SCF_DELTA - 3) { /* 3 bec. scf is reduced 3 times, |
| see for loop below */ |
| |
| for (k = 0; k < sfbCnt; k++) scfTmp[k] = scf[k]; |
| |
| for (i = 0; i < 3; i++) { |
| scfNew = scfTmp[startSfb] - 1; |
| /* replace scfs in region by scfNew */ |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) scfTmp[sfb] = scfNew; |
| } |
| /* estimate change in bit demand for new scfs */ |
| deltaScfBits = FDKaacEnc_countScfBitsDiff(scf, scfTmp, sfbCnt, |
| startSfb, stopSfb); |
| deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits; |
| /* new bit demand small enough ? */ |
| if (deltaPeNew <= FL2FXCONST_DBL(0.0f)) { |
| bSuccess = 1; |
| distOldSum = distNewSum = FL2FXCONST_DBL(0.0f); |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scfTmp[sfb] != FDK_INT_MIN) { |
| FIXP_DBL sfbEnQ; |
| /* calc the energy and distortion of the quantized spectrum for |
| a smaller scf */ |
| FDKaacEnc_calcSfbQuantEnergyAndDist( |
| qcOutChannel->mdctSpectrum + sfbOffs[sfb], |
| quantSpec + sfbOffs[sfb], sfbOffs[sfb + 1] - sfbOffs[sfb], |
| scfNew, &sfbEnQ, &sfbDistNew[sfb]); |
| |
| distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT; |
| distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT; |
| |
| /* 0.00259488556167 = ld64(1.122f) */ |
| /* -0.00778722686652 = ld64(0.7079f) */ |
| if ((sfbDistNew[sfb] > |
| (sfbDist[sfb] + FL2FXCONST_DBL(0.00259488556167f))) || |
| (sfbEnQ < (qcOutChannel->sfbEnergyLdData[sfb] - |
| FL2FXCONST_DBL(0.00778722686652f)))) { |
| bSuccess = 0; |
| break; |
| } |
| } |
| } |
| /* distortion smaller ? -> use new scalefactors */ |
| if (distNewSum < distOldSum && bSuccess) { |
| deltaPe = deltaPeNew; |
| for (sfb = startSfb; sfb < stopSfb; sfb++) { |
| if (scf[sfb] != FDK_INT_MIN) { |
| scf[sfb] = scfNew; |
| sfbDist[sfb] = sfbDistNew[sfb]; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } while (stopSfb <= sfbCnt); |
| } |
| |
| static void FDKaacEnc_EstimateScaleFactorsChannel( |
| QC_OUT_CHANNEL *qcOutChannel, PSY_OUT_CHANNEL *psyOutChannel, |
| INT *RESTRICT scf, INT *RESTRICT globalGain, |
| FIXP_DBL *RESTRICT sfbFormFactorLdData, const INT invQuant, |
| SHORT *RESTRICT quantSpec, const INT dZoneQuantEnable) { |
| INT i, j, sfb, sfbOffs; |
| INT scfInt; |
| INT maxSf; |
| INT minSf; |
| FIXP_DBL threshLdData; |
| FIXP_DBL energyLdData; |
| FIXP_DBL energyPartLdData; |
| FIXP_DBL thresholdPartLdData; |
| FIXP_DBL scfFract; |
| FIXP_DBL maxSpec; |
| INT minScfCalculated[MAX_GROUPED_SFB]; |
| FIXP_DBL sfbDistLdData[MAX_GROUPED_SFB]; |
| C_ALLOC_SCRATCH_START(quantSpecTmp, SHORT, (1024)) |
| INT minSfMaxQuant[MAX_GROUPED_SFB]; |
| |
| FIXP_DBL threshConstLdData = |
| FL2FXCONST_DBL(0.04304511722f); /* log10(6.75)/log10(2.0)/64.0 */ |
| FIXP_DBL convConst = FL2FXCONST_DBL(0.30102999566f); /* log10(2.0) */ |
| FIXP_DBL c1Const = |
| FL2FXCONST_DBL(-0.27083183594f); /* C1 = -69.33295 => C1/2^8 */ |
| |
| if (invQuant > 0) { |
| FDKmemclear(quantSpec, (1024) * sizeof(SHORT)); |
| } |
| |
| /* scfs without energy or with thresh>energy are marked with FDK_INT_MIN */ |
| for (i = 0; i < psyOutChannel->sfbCnt; i++) { |
| scf[i] = FDK_INT_MIN; |
| } |
| |
| for (i = 0; i < MAX_GROUPED_SFB; i++) { |
| minSfMaxQuant[i] = FDK_INT_MIN; |
| } |
| |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| threshLdData = qcOutChannel->sfbThresholdLdData[sfbOffs + sfb]; |
| energyLdData = qcOutChannel->sfbEnergyLdData[sfbOffs + sfb]; |
| |
| sfbDistLdData[sfbOffs + sfb] = energyLdData; |
| |
| if (energyLdData > threshLdData) { |
| FIXP_DBL tmp; |
| |
| /* energyPart = (float)log10(sfbFormFactor[sfbOffs+sfb]); */ |
| /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */ |
| energyPartLdData = |
| sfbFormFactorLdData[sfbOffs + sfb] + FL2FXCONST_DBL(0.09375f); |
| |
| /* influence of allowed distortion */ |
| /* thresholdPart = (float)log10(6.75*thresh+FLT_MIN); */ |
| thresholdPartLdData = threshConstLdData + threshLdData; |
| |
| /* scf calc */ |
| /* scfFloat = 8.8585f * (thresholdPart - energyPart); */ |
| scfFract = thresholdPartLdData - energyPartLdData; |
| /* conversion from log2 to log10 */ |
| scfFract = fMult(convConst, scfFract); |
| /* (8.8585f * scfFract)/8 = 8/8 * scfFract + 0.8585 * scfFract/8 */ |
| scfFract = scfFract + fMult(FL2FXCONST_DBL(0.8585f), scfFract >> 3); |
| |
| /* integer scalefactor */ |
| /* scfInt = (int)floor(scfFloat); */ |
| scfInt = |
| (INT)(scfFract >> |
| ((DFRACT_BITS - 1) - 3 - |
| LD_DATA_SHIFT)); /* 3 bits => scfFract/8.0; 6 bits => ld64 */ |
| |
| /* maximum of spectrum */ |
| maxSpec = FL2FXCONST_DBL(0.0f); |
| |
| /* Unroll by 4, allow dual memory access */ |
| DWORD_ALIGNED(qcOutChannel->mdctSpectrum); |
| for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb]; |
| j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j += 4) { |
| maxSpec = fMax(maxSpec, |
| fMax(fMax(fAbs(qcOutChannel->mdctSpectrum[j + 0]), |
| fAbs(qcOutChannel->mdctSpectrum[j + 1])), |
| fMax(fAbs(qcOutChannel->mdctSpectrum[j + 2]), |
| fAbs(qcOutChannel->mdctSpectrum[j + 3])))); |
| } |
| /* lower scf limit to avoid quantized values bigger than MAX_QUANT */ |
| /* C1 = -69.33295f, C2 = 5.77078f = 4/log(2) */ |
| /* minSfMaxQuant[sfbOffs+sfb] = (int)ceil(C1 + C2*log(maxSpec)); */ |
| /* C1/2^8 + 4/log(2.0)*log(maxSpec)/2^8 => C1/2^8 + |
| * log(maxSpec)/log(2.0)*4/2^8 => C1/2^8 + log(maxSpec)/log(2.0)/64.0 */ |
| |
| // minSfMaxQuant[sfbOffs+sfb] = ((INT) ((c1Const + CalcLdData(maxSpec)) |
| // >> ((DFRACT_BITS-1)-8))) + 1; |
| tmp = CalcLdData(maxSpec); |
| if (c1Const > FL2FXCONST_DBL(-1.f) - tmp) { |
| minSfMaxQuant[sfbOffs + sfb] = |
| ((INT)((c1Const + tmp) >> ((DFRACT_BITS - 1) - 8))) + 1; |
| } else { |
| minSfMaxQuant[sfbOffs + sfb] = |
| ((INT)(FL2FXCONST_DBL(-1.f) >> ((DFRACT_BITS - 1) - 8))) + 1; |
| } |
| |
| scfInt = fixMax(scfInt, minSfMaxQuant[sfbOffs + sfb]); |
| |
| /* find better scalefactor with analysis by synthesis */ |
| if (invQuant > 0) { |
| scfInt = FDKaacEnc_improveScf( |
| qcOutChannel->mdctSpectrum + |
| psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| quantSpec + psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| quantSpecTmp + psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| psyOutChannel->sfbOffsets[sfbOffs + sfb + 1] - |
| psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| threshLdData, scfInt, minSfMaxQuant[sfbOffs + sfb], |
| &sfbDistLdData[sfbOffs + sfb], &minScfCalculated[sfbOffs + sfb], |
| dZoneQuantEnable); |
| } |
| scf[sfbOffs + sfb] = scfInt; |
| } |
| } |
| } |
| |
| if (invQuant > 0) { |
| /* try to decrease scf differences */ |
| FIXP_DBL sfbConstPePart[MAX_GROUPED_SFB]; |
| FIXP_DBL sfbNRelevantLines[MAX_GROUPED_SFB]; |
| |
| for (i = 0; i < psyOutChannel->sfbCnt; i++) |
| sfbConstPePart[i] = (FIXP_DBL)FDK_INT_MIN; |
| |
| FDKaacEnc_calcSfbRelevantLines( |
| sfbFormFactorLdData, qcOutChannel->sfbEnergyLdData, |
| qcOutChannel->sfbThresholdLdData, psyOutChannel->sfbOffsets, |
| psyOutChannel->sfbCnt, psyOutChannel->sfbPerGroup, |
| psyOutChannel->maxSfbPerGroup, sfbNRelevantLines); |
| |
| FDKaacEnc_assimilateSingleScf( |
| psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, dZoneQuantEnable, |
| scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart, sfbFormFactorLdData, |
| sfbNRelevantLines, minScfCalculated, 1); |
| |
| if (invQuant > 1) { |
| FDKaacEnc_assimilateMultipleScf( |
| psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, |
| dZoneQuantEnable, scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart, |
| sfbFormFactorLdData, sfbNRelevantLines); |
| |
| FDKaacEnc_FDKaacEnc_assimilateMultipleScf2( |
| psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, |
| dZoneQuantEnable, scf, minSfMaxQuant, sfbDistLdData, sfbConstPePart, |
| sfbFormFactorLdData, sfbNRelevantLines); |
| } |
| } |
| |
| /* get min scalefac */ |
| minSf = FDK_INT_MAX; |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| if (scf[sfbOffs + sfb] != FDK_INT_MIN) |
| minSf = fixMin(minSf, scf[sfbOffs + sfb]); |
| } |
| } |
| |
| /* limit scf delta */ |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| if ((scf[sfbOffs + sfb] != FDK_INT_MIN) && |
| (minSf + MAX_SCF_DELTA) < scf[sfbOffs + sfb]) { |
| scf[sfbOffs + sfb] = minSf + MAX_SCF_DELTA; |
| if (invQuant > 0) { /* changed bands need to be quantized again */ |
| sfbDistLdData[sfbOffs + sfb] = FDKaacEnc_calcSfbDist( |
| qcOutChannel->mdctSpectrum + |
| psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| quantSpec + psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| psyOutChannel->sfbOffsets[sfbOffs + sfb + 1] - |
| psyOutChannel->sfbOffsets[sfbOffs + sfb], |
| scf[sfbOffs + sfb], dZoneQuantEnable); |
| } |
| } |
| } |
| } |
| |
| /* get max scalefac for global gain */ |
| maxSf = FDK_INT_MIN; |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| maxSf = fixMax(maxSf, scf[sfbOffs + sfb]); |
| } |
| } |
| |
| /* calc loop scalefactors, if spec is not all zero (i.e. maxSf == -99) */ |
| if (maxSf > FDK_INT_MIN) { |
| *globalGain = maxSf; |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| if (scf[sfbOffs + sfb] == FDK_INT_MIN) { |
| scf[sfbOffs + sfb] = 0; |
| /* set band explicitely to zero */ |
| for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb]; |
| j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j++) { |
| qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f); |
| } |
| } else { |
| scf[sfbOffs + sfb] = maxSf - scf[sfbOffs + sfb]; |
| } |
| } |
| } |
| } else { |
| *globalGain = 0; |
| /* set spectrum explicitely to zero */ |
| for (sfbOffs = 0; sfbOffs < psyOutChannel->sfbCnt; |
| sfbOffs += psyOutChannel->sfbPerGroup) { |
| for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) { |
| scf[sfbOffs + sfb] = 0; |
| /* set band explicitely to zero */ |
| for (j = psyOutChannel->sfbOffsets[sfbOffs + sfb]; |
| j < psyOutChannel->sfbOffsets[sfbOffs + sfb + 1]; j++) { |
| qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f); |
| } |
| } |
| } |
| } |
| |
| /* free quantSpecTmp from scratch */ |
| C_ALLOC_SCRATCH_END(quantSpecTmp, SHORT, (1024)) |
| } |
| |
| void FDKaacEnc_EstimateScaleFactors(PSY_OUT_CHANNEL *psyOutChannel[], |
| QC_OUT_CHANNEL *qcOutChannel[], |
| const INT invQuant, |
| const INT dZoneQuantEnable, |
| const INT nChannels) { |
| int ch; |
| |
| for (ch = 0; ch < nChannels; ch++) { |
| FDKaacEnc_EstimateScaleFactorsChannel( |
| qcOutChannel[ch], psyOutChannel[ch], qcOutChannel[ch]->scf, |
| &qcOutChannel[ch]->globalGain, qcOutChannel[ch]->sfbFormFactorLdData, |
| invQuant, qcOutChannel[ch]->quantSpec, dZoneQuantEnable); |
| } |
| } |
