| /* ----------------------------------------------------------------------------- | |
| 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): A. Horndasch (code originally from lwr) / Josef Hoepfl (FDK) | |
| Description: intensity stereo processing | |
| *******************************************************************************/ | |
| #include "intensity.h" | |
| #include "interface.h" | |
| #include "psy_configuration.h" | |
| #include "psy_const.h" | |
| #include "qc_main.h" | |
| #include "bit_cnt.h" | |
| /* only set an IS seed it left/right channel correlation is above IS_CORR_THRESH | |
| */ | |
| #define IS_CORR_THRESH FL2FXCONST_DBL(0.95f) | |
| /* when expanding the IS region to more SFBs only accept an error that is | |
| * not more than IS_TOTAL_ERROR_THRESH overall and | |
| * not more than IS_LOCAL_ERROR_THRESH for the current SFB */ | |
| #define IS_TOTAL_ERROR_THRESH FL2FXCONST_DBL(0.04f) | |
| #define IS_LOCAL_ERROR_THRESH FL2FXCONST_DBL(0.01f) | |
| /* the maximum allowed change of the intensity direction (unit: IS scale) - | |
| * scaled with factor 0.25 - */ | |
| #define IS_DIRECTION_DEVIATION_THRESH_SF 2 | |
| #define IS_DIRECTION_DEVIATION_THRESH \ | |
| FL2FXCONST_DBL(2.0f / (1 << IS_DIRECTION_DEVIATION_THRESH_SF)) | |
| /* IS regions need to have a minimal percentage of the overall loudness, e.g. | |
| * 0.06 == 6% */ | |
| #define IS_REGION_MIN_LOUDNESS FL2FXCONST_DBL(0.1f) | |
| /* only perform IS if IS_MIN_SFBS neighboring SFBs can be processed */ | |
| #define IS_MIN_SFBS 6 | |
| /* only do IS if | |
| * if IS_LEFT_RIGHT_RATIO_THRESH < sfbEnergyLeft[sfb]/sfbEnergyRight[sfb] < 1 / | |
| * IS_LEFT_RIGHT_RATIO_THRESH | |
| * -> no IS if the panning angle is not far from the middle, MS will do */ | |
| /* this is equivalent to a scale of +/-1.02914634566 */ | |
| #define IS_LEFT_RIGHT_RATIO_THRESH FL2FXCONST_DBL(0.7f) | |
| /* scalefactor of realScale */ | |
| #define REAL_SCALE_SF 1 | |
| /* scalefactor overallLoudness */ | |
| #define OVERALL_LOUDNESS_SF 6 | |
| /* scalefactor for sum over max samples per goup */ | |
| #define MAX_SFB_PER_GROUP_SF 6 | |
| /* scalefactor for sum of mdct spectrum */ | |
| #define MDCT_SPEC_SF 6 | |
| typedef struct { | |
| FIXP_DBL corr_thresh; /*!< Only set an IS seed it left/right channel | |
| correlation is above corr_thresh */ | |
| FIXP_DBL total_error_thresh; /*!< When expanding the IS region to more SFBs | |
| only accept an error that is not more than | |
| 'total_error_thresh' overall. */ | |
| FIXP_DBL local_error_thresh; /*!< When expanding the IS region to more SFBs | |
| only accept an error that is not more than | |
| 'local_error_thresh' for the current SFB. */ | |
| FIXP_DBL direction_deviation_thresh; /*!< The maximum allowed change of the | |
| intensity direction (unit: IS scale) | |
| */ | |
| FIXP_DBL is_region_min_loudness; /*!< IS regions need to have a minimal | |
| percentage of the overall loudness, e.g. | |
| 0.06 == 6% */ | |
| INT min_is_sfbs; /*!< Only perform IS if 'min_is_sfbs' neighboring SFBs can be | |
| processed */ | |
| FIXP_DBL left_right_ratio_threshold; /*!< No IS if the panning angle is not | |
| far from the middle, MS will do */ | |
| } INTENSITY_PARAMETERS; | |
| /***************************************************************************** | |
| functionname: calcSfbMaxScale | |
| description: Calc max value in scalefactor band | |
| input: *mdctSpectrum | |
| l1 | |
| l2 | |
| output: none | |
| returns: scalefactor | |
| *****************************************************************************/ | |
| static INT calcSfbMaxScale(const FIXP_DBL *mdctSpectrum, const INT l1, | |
| const INT l2) { | |
| INT i; | |
| INT sfbMaxScale; | |
| FIXP_DBL maxSpc; | |
| maxSpc = FL2FXCONST_DBL(0.0); | |
| for (i = l1; i < l2; i++) { | |
| FIXP_DBL tmp = fixp_abs((FIXP_DBL)mdctSpectrum[i]); | |
| maxSpc = fixMax(maxSpc, tmp); | |
| } | |
| sfbMaxScale = (maxSpc == FL2FXCONST_DBL(0.0)) ? (DFRACT_BITS - 2) | |
| : CntLeadingZeros(maxSpc) - 1; | |
| return sfbMaxScale; | |
| } | |
| /***************************************************************************** | |
| functionname: FDKaacEnc_initIsParams | |
| description: Initialization of intensity parameters | |
| input: isParams | |
| output: isParams | |
| returns: none | |
| *****************************************************************************/ | |
| static void FDKaacEnc_initIsParams(INTENSITY_PARAMETERS *isParams) { | |
| isParams->corr_thresh = IS_CORR_THRESH; | |
| isParams->total_error_thresh = IS_TOTAL_ERROR_THRESH; | |
| isParams->local_error_thresh = IS_LOCAL_ERROR_THRESH; | |
| isParams->direction_deviation_thresh = IS_DIRECTION_DEVIATION_THRESH; | |
| isParams->is_region_min_loudness = IS_REGION_MIN_LOUDNESS; | |
| isParams->min_is_sfbs = IS_MIN_SFBS; | |
| isParams->left_right_ratio_threshold = IS_LEFT_RIGHT_RATIO_THRESH; | |
| } | |
| /***************************************************************************** | |
| functionname: FDKaacEnc_prepareIntensityDecision | |
| description: Prepares intensity decision | |
| input: sfbEnergyLeft | |
| sfbEnergyRight | |
| sfbEnergyLdDataLeft | |
| sfbEnergyLdDataRight | |
| mdctSpectrumLeft | |
| sfbEnergyLdDataRight | |
| isParams | |
| output: hrrErr scale: none | |
| isMask scale: none | |
| realScale scale: LD_DATA_SHIFT + REAL_SCALE_SF | |
| normSfbLoudness scale: none | |
| returns: none | |
| *****************************************************************************/ | |
| static void FDKaacEnc_prepareIntensityDecision( | |
| const FIXP_DBL *sfbEnergyLeft, const FIXP_DBL *sfbEnergyRight, | |
| const FIXP_DBL *sfbEnergyLdDataLeft, const FIXP_DBL *sfbEnergyLdDataRight, | |
| const FIXP_DBL *mdctSpectrumLeft, const FIXP_DBL *mdctSpectrumRight, | |
| const INTENSITY_PARAMETERS *isParams, FIXP_DBL *hrrErr, INT *isMask, | |
| FIXP_DBL *realScale, FIXP_DBL *normSfbLoudness, const INT sfbCnt, | |
| const INT sfbPerGroup, const INT maxSfbPerGroup, const INT *sfbOffset) { | |
| INT j, sfb, sfboffs; | |
| INT grpCounter; | |
| /* temporary variables to compute loudness */ | |
| FIXP_DBL overallLoudness[MAX_NO_OF_GROUPS]; | |
| /* temporary variables to compute correlation */ | |
| FIXP_DBL channelCorr[MAX_GROUPED_SFB]; | |
| FIXP_DBL ml, mr; | |
| FIXP_DBL prod_lr; | |
| FIXP_DBL square_l, square_r; | |
| FIXP_DBL tmp_l, tmp_r; | |
| FIXP_DBL inv_n; | |
| FDKmemclear(channelCorr, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); | |
| FDKmemclear(normSfbLoudness, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); | |
| FDKmemclear(overallLoudness, MAX_NO_OF_GROUPS * sizeof(FIXP_DBL)); | |
| FDKmemclear(realScale, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); | |
| for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; | |
| sfboffs += sfbPerGroup, grpCounter++) { | |
| overallLoudness[grpCounter] = FL2FXCONST_DBL(0.0f); | |
| for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { | |
| INT sL, sR, s; | |
| FIXP_DBL isValue = sfbEnergyLdDataLeft[sfb + sfboffs] - | |
| sfbEnergyLdDataRight[sfb + sfboffs]; | |
| /* delimitate intensity scale value to representable range */ | |
| realScale[sfb + sfboffs] = fixMin( | |
| FL2FXCONST_DBL(60.f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT))), | |
| fixMax(FL2FXCONST_DBL(-60.f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT))), | |
| isValue)); | |
| sL = fixMax(0, (CntLeadingZeros(sfbEnergyLeft[sfb + sfboffs]) - 1)); | |
| sR = fixMax(0, (CntLeadingZeros(sfbEnergyRight[sfb + sfboffs]) - 1)); | |
| s = (fixMin(sL, sR) >> 2) << 2; | |
| normSfbLoudness[sfb + sfboffs] = | |
| sqrtFixp(sqrtFixp(((sfbEnergyLeft[sfb + sfboffs] << s) >> 1) + | |
| ((sfbEnergyRight[sfb + sfboffs] << s) >> 1))) >> | |
| (s >> 2); | |
| overallLoudness[grpCounter] += | |
| normSfbLoudness[sfb + sfboffs] >> OVERALL_LOUDNESS_SF; | |
| /* don't do intensity if | |
| * - panning angle is too close to the middle or | |
| * - one channel is non-existent or | |
| * - if it is dual mono */ | |
| if ((sfbEnergyLeft[sfb + sfboffs] >= | |
| fMult(isParams->left_right_ratio_threshold, | |
| sfbEnergyRight[sfb + sfboffs])) && | |
| (fMult(isParams->left_right_ratio_threshold, | |
| sfbEnergyLeft[sfb + sfboffs]) <= | |
| sfbEnergyRight[sfb + sfboffs])) { | |
| /* this will prevent post processing from considering this SFB for | |
| * merging */ | |
| hrrErr[sfb + sfboffs] = FL2FXCONST_DBL(1.0 / 8.0); | |
| } | |
| } | |
| } | |
| for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; | |
| sfboffs += sfbPerGroup, grpCounter++) { | |
| INT invOverallLoudnessSF; | |
| FIXP_DBL invOverallLoudness; | |
| if (overallLoudness[grpCounter] == FL2FXCONST_DBL(0.0)) { | |
| invOverallLoudness = FL2FXCONST_DBL(0.0); | |
| invOverallLoudnessSF = 0; | |
| } else { | |
| invOverallLoudness = | |
| fDivNorm((FIXP_DBL)MAXVAL_DBL, overallLoudness[grpCounter], | |
| &invOverallLoudnessSF); | |
| invOverallLoudnessSF = | |
| invOverallLoudnessSF - OVERALL_LOUDNESS_SF + | |
| 1; /* +1: compensate fMultDiv2() in subsequent loop */ | |
| } | |
| invOverallLoudnessSF = fixMin( | |
| fixMax(invOverallLoudnessSF, -(DFRACT_BITS - 1)), DFRACT_BITS - 1); | |
| for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { | |
| FIXP_DBL tmp; | |
| tmp = fMultDiv2((normSfbLoudness[sfb + sfboffs] >> OVERALL_LOUDNESS_SF) | |
| << OVERALL_LOUDNESS_SF, | |
| invOverallLoudness); | |
| normSfbLoudness[sfb + sfboffs] = scaleValue(tmp, invOverallLoudnessSF); | |
| channelCorr[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); | |
| /* max width of scalefactorband is 96; width's are always even */ | |
| /* inv_n is scaled with factor 2 to compensate fMultDiv2() in subsequent | |
| * loops */ | |
| inv_n = GetInvInt( | |
| (sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs]) >> 1); | |
| if (inv_n > FL2FXCONST_DBL(0.0f)) { | |
| INT s, sL, sR; | |
| /* correlation := Pearson's product-moment coefficient */ | |
| /* compute correlation between channels and check if it is over | |
| * threshold */ | |
| ml = FL2FXCONST_DBL(0.0f); | |
| mr = FL2FXCONST_DBL(0.0f); | |
| prod_lr = FL2FXCONST_DBL(0.0f); | |
| square_l = FL2FXCONST_DBL(0.0f); | |
| square_r = FL2FXCONST_DBL(0.0f); | |
| sL = calcSfbMaxScale(mdctSpectrumLeft, sfbOffset[sfb + sfboffs], | |
| sfbOffset[sfb + sfboffs + 1]); | |
| sR = calcSfbMaxScale(mdctSpectrumRight, sfbOffset[sfb + sfboffs], | |
| sfbOffset[sfb + sfboffs + 1]); | |
| s = fixMin(sL, sR); | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| ml += fMultDiv2((mdctSpectrumLeft[j] << s), | |
| inv_n); // scaled with mdctScale - s + inv_n | |
| mr += fMultDiv2((mdctSpectrumRight[j] << s), | |
| inv_n); // scaled with mdctScale - s + inv_n | |
| } | |
| ml = fMultDiv2(ml, inv_n); // scaled with mdctScale - s + inv_n | |
| mr = fMultDiv2(mr, inv_n); // scaled with mdctScale - s + inv_n | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| tmp_l = fMultDiv2((mdctSpectrumLeft[j] << s), inv_n) - | |
| ml; // scaled with mdctScale - s + inv_n | |
| tmp_r = fMultDiv2((mdctSpectrumRight[j] << s), inv_n) - | |
| mr; // scaled with mdctScale - s + inv_n | |
| prod_lr += fMultDiv2( | |
| tmp_l, tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1 | |
| square_l += | |
| fPow2Div2(tmp_l); // scaled with 2*(mdctScale - s + inv_n) + 1 | |
| square_r += | |
| fPow2Div2(tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1 | |
| } | |
| prod_lr = prod_lr << 1; // scaled with 2*(mdctScale - s + inv_n) | |
| square_l = square_l << 1; // scaled with 2*(mdctScale - s + inv_n) | |
| square_r = square_r << 1; // scaled with 2*(mdctScale - s + inv_n) | |
| if (square_l > FL2FXCONST_DBL(0.0f) && | |
| square_r > FL2FXCONST_DBL(0.0f)) { | |
| INT channelCorrSF = 0; | |
| /* local scaling of square_l and square_r is compensated after sqrt | |
| * calculation */ | |
| sL = fixMax(0, (CntLeadingZeros(square_l) - 1)); | |
| sR = fixMax(0, (CntLeadingZeros(square_r) - 1)); | |
| s = ((sL + sR) >> 1) << 1; | |
| sL = fixMin(sL, s); | |
| sR = s - sL; | |
| tmp = fMult(square_l << sL, square_r << sR); | |
| tmp = sqrtFixp(tmp); | |
| FDK_ASSERT(tmp > FL2FXCONST_DBL(0.0f)); | |
| /* numerator and denominator have the same scaling */ | |
| if (prod_lr < FL2FXCONST_DBL(0.0f)) { | |
| channelCorr[sfb + sfboffs] = | |
| -(fDivNorm(-prod_lr, tmp, &channelCorrSF)); | |
| } else { | |
| channelCorr[sfb + sfboffs] = | |
| (fDivNorm(prod_lr, tmp, &channelCorrSF)); | |
| } | |
| channelCorrSF = fixMin( | |
| fixMax((channelCorrSF + ((sL + sR) >> 1)), -(DFRACT_BITS - 1)), | |
| DFRACT_BITS - 1); | |
| if (channelCorrSF < 0) { | |
| channelCorr[sfb + sfboffs] = | |
| channelCorr[sfb + sfboffs] >> (-channelCorrSF); | |
| } else { | |
| /* avoid overflows due to limited computational accuracy */ | |
| if (fAbs(channelCorr[sfb + sfboffs]) > | |
| (((FIXP_DBL)MAXVAL_DBL) >> channelCorrSF)) { | |
| if (channelCorr[sfb + sfboffs] < FL2FXCONST_DBL(0.0f)) | |
| channelCorr[sfb + sfboffs] = -(FIXP_DBL)MAXVAL_DBL; | |
| else | |
| channelCorr[sfb + sfboffs] = (FIXP_DBL)MAXVAL_DBL; | |
| } else { | |
| channelCorr[sfb + sfboffs] = channelCorr[sfb + sfboffs] | |
| << channelCorrSF; | |
| } | |
| } | |
| } | |
| } | |
| /* for post processing: hrrErr is the error in terms of (too little) | |
| * correlation weighted with the loudness of the SFB; SFBs with small | |
| * hrrErr can be merged */ | |
| if (hrrErr[sfb + sfboffs] == FL2FXCONST_DBL(1.0 / 8.0)) { | |
| continue; | |
| } | |
| hrrErr[sfb + sfboffs] = | |
| fMultDiv2((FL2FXCONST_DBL(0.25f) - (channelCorr[sfb + sfboffs] >> 2)), | |
| normSfbLoudness[sfb + sfboffs]); | |
| /* set IS mask/vector to 1, if correlation is high enough */ | |
| if (fAbs(channelCorr[sfb + sfboffs]) >= isParams->corr_thresh) { | |
| isMask[sfb + sfboffs] = 1; | |
| } | |
| } | |
| } | |
| } | |
| /***************************************************************************** | |
| functionname: FDKaacEnc_finalizeIntensityDecision | |
| description: Finalizes intensity decision | |
| input: isParams scale: none | |
| hrrErr scale: none | |
| realIsScale scale: LD_DATA_SHIFT + REAL_SCALE_SF | |
| normSfbLoudness scale: none | |
| output: isMask scale: none | |
| returns: none | |
| *****************************************************************************/ | |
| static void FDKaacEnc_finalizeIntensityDecision( | |
| const FIXP_DBL *hrrErr, INT *isMask, const FIXP_DBL *realIsScale, | |
| const FIXP_DBL *normSfbLoudness, const INTENSITY_PARAMETERS *isParams, | |
| const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup) { | |
| INT sfb, sfboffs, j; | |
| FIXP_DBL isScaleLast = FL2FXCONST_DBL(0.0f); | |
| INT isStartValueFound = 0; | |
| for (sfboffs = 0; sfboffs < sfbCnt; sfboffs += sfbPerGroup) { | |
| INT startIsSfb = 0; | |
| INT inIsBlock = 0; | |
| INT currentIsSfbCount = 0; | |
| FIXP_DBL overallHrrError = FL2FXCONST_DBL(0.0f); | |
| FIXP_DBL isRegionLoudness = FL2FXCONST_DBL(0.0f); | |
| for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { | |
| if (isMask[sfboffs + sfb] == 1) { | |
| if (currentIsSfbCount == 0) { | |
| startIsSfb = sfboffs + sfb; | |
| } | |
| if (isStartValueFound == 0) { | |
| isScaleLast = realIsScale[sfboffs + sfb]; | |
| isStartValueFound = 1; | |
| } | |
| inIsBlock = 1; | |
| currentIsSfbCount++; | |
| overallHrrError += hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF - 3); | |
| isRegionLoudness += | |
| normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF; | |
| } else { | |
| /* based on correlation, IS should not be used | |
| * -> use it anyway, if overall error is below threshold | |
| * and if local error does not exceed threshold | |
| * otherwise: check if there are enough IS SFBs | |
| */ | |
| if (inIsBlock) { | |
| overallHrrError += | |
| hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF - 3); | |
| isRegionLoudness += | |
| normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF; | |
| if ((hrrErr[sfboffs + sfb] < (isParams->local_error_thresh >> 3)) && | |
| (overallHrrError < | |
| (isParams->total_error_thresh >> MAX_SFB_PER_GROUP_SF))) { | |
| currentIsSfbCount++; | |
| /* overwrite correlation based decision */ | |
| isMask[sfboffs + sfb] = 1; | |
| } else { | |
| inIsBlock = 0; | |
| } | |
| } | |
| } | |
| /* check for large direction deviation */ | |
| if (inIsBlock) { | |
| if (fAbs(isScaleLast - realIsScale[sfboffs + sfb]) < | |
| (isParams->direction_deviation_thresh >> | |
| (REAL_SCALE_SF + LD_DATA_SHIFT - | |
| IS_DIRECTION_DEVIATION_THRESH_SF))) { | |
| isScaleLast = realIsScale[sfboffs + sfb]; | |
| } else { | |
| isMask[sfboffs + sfb] = 0; | |
| inIsBlock = 0; | |
| currentIsSfbCount--; | |
| } | |
| } | |
| if (currentIsSfbCount > 0 && (!inIsBlock || sfb == maxSfbPerGroup - 1)) { | |
| /* not enough SFBs -> do not use IS */ | |
| if (currentIsSfbCount < isParams->min_is_sfbs || | |
| (isRegionLoudness<isParams->is_region_min_loudness>> | |
| MAX_SFB_PER_GROUP_SF)) { | |
| for (j = startIsSfb; j <= sfboffs + sfb; j++) { | |
| isMask[j] = 0; | |
| } | |
| isScaleLast = FL2FXCONST_DBL(0.0f); | |
| isStartValueFound = 0; | |
| for (j = 0; j < startIsSfb; j++) { | |
| if (isMask[j] != 0) { | |
| isScaleLast = realIsScale[j]; | |
| isStartValueFound = 1; | |
| } | |
| } | |
| } | |
| currentIsSfbCount = 0; | |
| overallHrrError = FL2FXCONST_DBL(0.0f); | |
| isRegionLoudness = FL2FXCONST_DBL(0.0f); | |
| } | |
| } | |
| } | |
| } | |
| /***************************************************************************** | |
| functionname: FDKaacEnc_IntensityStereoProcessing | |
| description: Intensity stereo processing tool | |
| input: sfbEnergyLeft | |
| sfbEnergyRight | |
| mdctSpectrumLeft | |
| mdctSpectrumRight | |
| sfbThresholdLeft | |
| sfbThresholdRight | |
| sfbSpreadEnLeft | |
| sfbSpreadEnRight | |
| sfbEnergyLdDataLeft | |
| sfbEnergyLdDataRight | |
| output: isBook | |
| isScale | |
| pnsData->pnsFlag | |
| msDigest zeroed from start to sfbCnt | |
| msMask zeroed from start to sfbCnt | |
| mdctSpectrumRight zeroed where isBook!=0 | |
| sfbEnergyRight zeroed where isBook!=0 | |
| sfbSpreadEnRight zeroed where isBook!=0 | |
| sfbThresholdRight zeroed where isBook!=0 | |
| sfbEnergyLdDataRight FL2FXCONST_DBL(-1.0) where isBook!=0 | |
| sfbThresholdLdDataRight FL2FXCONST_DBL(-0.515625f) where | |
| isBook!=0 | |
| returns: none | |
| *****************************************************************************/ | |
| void FDKaacEnc_IntensityStereoProcessing( | |
| FIXP_DBL *sfbEnergyLeft, FIXP_DBL *sfbEnergyRight, | |
| FIXP_DBL *mdctSpectrumLeft, FIXP_DBL *mdctSpectrumRight, | |
| FIXP_DBL *sfbThresholdLeft, FIXP_DBL *sfbThresholdRight, | |
| FIXP_DBL *sfbThresholdLdDataRight, FIXP_DBL *sfbSpreadEnLeft, | |
| FIXP_DBL *sfbSpreadEnRight, FIXP_DBL *sfbEnergyLdDataLeft, | |
| FIXP_DBL *sfbEnergyLdDataRight, INT *msDigest, INT *msMask, | |
| const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup, | |
| const INT *sfbOffset, const INT allowIS, INT *isBook, INT *isScale, | |
| PNS_DATA *RESTRICT pnsData[2]) { | |
| INT sfb, sfboffs, j; | |
| FIXP_DBL scale; | |
| FIXP_DBL lr; | |
| FIXP_DBL hrrErr[MAX_GROUPED_SFB]; | |
| FIXP_DBL normSfbLoudness[MAX_GROUPED_SFB]; | |
| FIXP_DBL realIsScale[MAX_GROUPED_SFB]; | |
| INTENSITY_PARAMETERS isParams; | |
| INT isMask[MAX_GROUPED_SFB]; | |
| FDKmemclear((void *)isBook, sfbCnt * sizeof(INT)); | |
| FDKmemclear((void *)isMask, sfbCnt * sizeof(INT)); | |
| FDKmemclear((void *)realIsScale, sfbCnt * sizeof(FIXP_DBL)); | |
| FDKmemclear((void *)isScale, sfbCnt * sizeof(INT)); | |
| FDKmemclear((void *)hrrErr, sfbCnt * sizeof(FIXP_DBL)); | |
| if (!allowIS) return; | |
| FDKaacEnc_initIsParams(&isParams); | |
| /* compute / set the following values per SFB: | |
| * - left/right ratio between channels | |
| * - normalized loudness | |
| * + loudness == average of energy in channels to 0.25 | |
| * + normalization: division by sum of all SFB loudnesses | |
| * - isMask (is set to 0 if channels are the same or one is 0) | |
| */ | |
| FDKaacEnc_prepareIntensityDecision( | |
| sfbEnergyLeft, sfbEnergyRight, sfbEnergyLdDataLeft, sfbEnergyLdDataRight, | |
| mdctSpectrumLeft, mdctSpectrumRight, &isParams, hrrErr, isMask, | |
| realIsScale, normSfbLoudness, sfbCnt, sfbPerGroup, maxSfbPerGroup, | |
| sfbOffset); | |
| FDKaacEnc_finalizeIntensityDecision(hrrErr, isMask, realIsScale, | |
| normSfbLoudness, &isParams, sfbCnt, | |
| sfbPerGroup, maxSfbPerGroup); | |
| for (sfb = 0; sfb < sfbCnt; sfb += sfbPerGroup) { | |
| for (sfboffs = 0; sfboffs < maxSfbPerGroup; sfboffs++) { | |
| INT sL, sR; | |
| FIXP_DBL inv_n; | |
| msMask[sfb + sfboffs] = 0; | |
| if (isMask[sfb + sfboffs] == 0) { | |
| continue; | |
| } | |
| if ((sfbEnergyLeft[sfb + sfboffs] < sfbThresholdLeft[sfb + sfboffs]) && | |
| (fMult(FL2FXCONST_DBL(1.0f / 1.5f), sfbEnergyRight[sfb + sfboffs]) > | |
| sfbThresholdRight[sfb + sfboffs])) { | |
| continue; | |
| } | |
| /* NEW: if there is a big-enough IS region, switch off PNS */ | |
| if (pnsData[0]) { | |
| if (pnsData[0]->pnsFlag[sfb + sfboffs]) { | |
| pnsData[0]->pnsFlag[sfb + sfboffs] = 0; | |
| } | |
| if (pnsData[1]->pnsFlag[sfb + sfboffs]) { | |
| pnsData[1]->pnsFlag[sfb + sfboffs] = 0; | |
| } | |
| } | |
| inv_n = GetInvInt( | |
| (sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs]) >> | |
| 1); // scaled with 2 to compensate fMultDiv2() in subsequent loop | |
| sL = calcSfbMaxScale(mdctSpectrumLeft, sfbOffset[sfb + sfboffs], | |
| sfbOffset[sfb + sfboffs + 1]); | |
| sR = calcSfbMaxScale(mdctSpectrumRight, sfbOffset[sfb + sfboffs], | |
| sfbOffset[sfb + sfboffs + 1]); | |
| lr = FL2FXCONST_DBL(0.0f); | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; j++) | |
| lr += fMultDiv2( | |
| fMultDiv2(mdctSpectrumLeft[j] << sL, mdctSpectrumRight[j] << sR), | |
| inv_n); | |
| lr = lr << 1; | |
| if (lr < FL2FXCONST_DBL(0.0f)) { | |
| /* This means OUT OF phase intensity stereo, cf. standard */ | |
| INT s0, s1, s2; | |
| FIXP_DBL tmp, d, ed = FL2FXCONST_DBL(0.0f); | |
| s0 = fixMin(sL, sR); | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| d = ((mdctSpectrumLeft[j] << s0) >> 1) - | |
| ((mdctSpectrumRight[j] << s0) >> 1); | |
| ed += fMultDiv2(d, d) >> (MDCT_SPEC_SF - 1); | |
| } | |
| msMask[sfb + sfboffs] = 1; | |
| tmp = fDivNorm(sfbEnergyLeft[sfb + sfboffs], ed, &s1); | |
| s2 = (s1) + (2 * s0) - 2 - MDCT_SPEC_SF; | |
| if (s2 & 1) { | |
| tmp = tmp >> 1; | |
| s2 = s2 + 1; | |
| } | |
| s2 = (s2 >> 1) + 1; // +1 compensate fMultDiv2() in subsequent loop | |
| s2 = fixMin(fixMax(s2, -(DFRACT_BITS - 1)), (DFRACT_BITS - 1)); | |
| scale = sqrtFixp(tmp); | |
| if (s2 < 0) { | |
| s2 = -s2; | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) - | |
| fMultDiv2(mdctSpectrumRight[j], scale)) >> | |
| s2; | |
| mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); | |
| } | |
| } else { | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) - | |
| fMultDiv2(mdctSpectrumRight[j], scale)) | |
| << s2; | |
| mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); | |
| } | |
| } | |
| } else { | |
| /* This means IN phase intensity stereo, cf. standard */ | |
| INT s0, s1, s2; | |
| FIXP_DBL tmp, s, es = FL2FXCONST_DBL(0.0f); | |
| s0 = fixMin(sL, sR); | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| s = ((mdctSpectrumLeft[j] << s0) >> 1) + | |
| ((mdctSpectrumRight[j] << s0) >> 1); | |
| es += fMultDiv2(s, s) >> | |
| (MDCT_SPEC_SF - | |
| 1); // scaled 2*(mdctScale - s0 + 1) + MDCT_SPEC_SF | |
| } | |
| msMask[sfb + sfboffs] = 0; | |
| tmp = fDivNorm(sfbEnergyLeft[sfb + sfboffs], es, &s1); | |
| s2 = (s1) + (2 * s0) - 2 - MDCT_SPEC_SF; | |
| if (s2 & 1) { | |
| tmp = tmp >> 1; | |
| s2 = s2 + 1; | |
| } | |
| s2 = (s2 >> 1) + 1; // +1 compensate fMultDiv2() in subsequent loop | |
| s2 = fixMin(fixMax(s2, -(DFRACT_BITS - 1)), (DFRACT_BITS - 1)); | |
| scale = sqrtFixp(tmp); | |
| if (s2 < 0) { | |
| s2 = -s2; | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) + | |
| fMultDiv2(mdctSpectrumRight[j], scale)) >> | |
| s2; | |
| mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); | |
| } | |
| } else { | |
| for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; | |
| j++) { | |
| mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) + | |
| fMultDiv2(mdctSpectrumRight[j], scale)) | |
| << s2; | |
| mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); | |
| } | |
| } | |
| } | |
| isBook[sfb + sfboffs] = CODE_BOOK_IS_IN_PHASE_NO; | |
| if (realIsScale[sfb + sfboffs] < FL2FXCONST_DBL(0.0f)) { | |
| isScale[sfb + sfboffs] = | |
| (INT)(((realIsScale[sfb + sfboffs] >> 1) - | |
| FL2FXCONST_DBL( | |
| 0.5f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT + 1)))) >> | |
| (DFRACT_BITS - 1 - REAL_SCALE_SF - LD_DATA_SHIFT - 1)) + | |
| 1; | |
| } else { | |
| isScale[sfb + sfboffs] = | |
| (INT)(((realIsScale[sfb + sfboffs] >> 1) + | |
| FL2FXCONST_DBL( | |
| 0.5f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT + 1)))) >> | |
| (DFRACT_BITS - 1 - REAL_SCALE_SF - LD_DATA_SHIFT - 1)); | |
| } | |
| sfbEnergyRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); | |
| sfbEnergyLdDataRight[sfb + sfboffs] = FL2FXCONST_DBL(-1.0f); | |
| sfbThresholdRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); | |
| sfbThresholdLdDataRight[sfb + sfboffs] = FL2FXCONST_DBL(-0.515625f); | |
| sfbSpreadEnRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); | |
| *msDigest = MS_SOME; | |
| } | |
| } | |
| } |