1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5© Copyright 1995 - 2012 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16of the MPEG specifications. 17 18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20individually for the purpose of encoding or decoding bit streams in products that are compliant with 21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27applications information and documentation. 28 292. COPYRIGHT LICENSE 30 31Redistribution and use in source and binary forms, with or without modification, are permitted without 32payment of copyright license fees provided that you satisfy the following conditions: 33 34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35your modifications thereto in source code form. 36 37You must retain the complete text of this software license in the documentation and/or other materials 38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40modifications thereto to recipients of copies in binary form. 41 42The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43prior written permission. 44 45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46software or your modifications thereto. 47 48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49and the date of any change. For modified versions of the FDK AAC Codec, the term 50"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 533. NO PATENT LICENSE 54 55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57respect to this software. 58 59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60by appropriate patent licenses. 61 624. DISCLAIMER 63 64This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69or business interruption, however caused and on any theory of liability, whether in contract, strict 70liability, or tort (including negligence), arising in any way out of the use of this software, even if 71advised of the possibility of such damage. 72 735. CONTACT INFORMATION 74 75Fraunhofer Institute for Integrated Circuits IIS 76Attention: Audio and Multimedia Departments - FDK AAC LL 77Am Wolfsmantel 33 7891058 Erlangen, Germany 79 80www.iis.fraunhofer.de/amm 81amm-info@iis.fraunhofer.de 82----------------------------------------------------------------------------------------------------------- */ 83 84/******************************** MPEG Audio Encoder ************************** 85 86 Initial author: M. Werner 87 contents/description: Threshold compensation 88 89******************************************************************************/ 90 91#include "common_fix.h" 92 93#include "adj_thr_data.h" 94#include "adj_thr.h" 95#include "qc_data.h" 96#include "sf_estim.h" 97#include "aacEnc_ram.h" 98 99 100 101 102#define INV_INT_TAB_SIZE (8) 103static const FIXP_DBL invInt[INV_INT_TAB_SIZE] = 104{ 105 0x7fffffff, 0x7fffffff, 0x40000000, 0x2aaaaaaa, 0x20000000, 0x19999999, 0x15555555, 0x12492492 106}; 107 108 109#define INV_SQRT4_TAB_SIZE (8) 110static const FIXP_DBL invSqrt4[INV_SQRT4_TAB_SIZE] = 111{ 112 0x7fffffff, 0x7fffffff, 0x6ba27e65, 0x61424bb5, 0x5a827999, 0x55994845, 0x51c8e33c, 0x4eb160d1 113}; 114 115 116/*static const INT invRedExp = 4;*/ 117static const FIXP_DBL SnrLdMin1 = (FIXP_DBL)0xfcad0ddf; /*FL2FXCONST_DBL(FDKlog(0.316)/FDKlog(2.0)/LD_DATA_SCALING);*/ 118static const FIXP_DBL SnrLdMin2 = (FIXP_DBL)0x0351e1a2; /*FL2FXCONST_DBL(FDKlog(3.16) /FDKlog(2.0)/LD_DATA_SCALING);*/ 119static const FIXP_DBL SnrLdFac = (FIXP_DBL)0xff5b2c3e; /*FL2FXCONST_DBL(FDKlog(0.8) /FDKlog(2.0)/LD_DATA_SCALING);*/ 120 121static const FIXP_DBL SnrLdMin3 = (FIXP_DBL)0xfe000000; /*FL2FXCONST_DBL(FDKlog(0.5) /FDKlog(2.0)/LD_DATA_SCALING);*/ 122static const FIXP_DBL SnrLdMin4 = (FIXP_DBL)0x02000000; /*FL2FXCONST_DBL(FDKlog(2.0) /FDKlog(2.0)/LD_DATA_SCALING);*/ 123static const FIXP_DBL SnrLdMin5 = (FIXP_DBL)0xfc000000; /*FL2FXCONST_DBL(FDKlog(0.25) /FDKlog(2.0)/LD_DATA_SCALING);*/ 124 125 126/* values for avoid hole flag */ 127enum _avoid_hole_state { 128 NO_AH =0, 129 AH_INACTIVE =1, 130 AH_ACTIVE =2 131}; 132 133 134/* Q format definitions */ 135#define Q_BITFAC (24) /* Q scaling used in FDKaacEnc_bitresCalcBitFac() calculation */ 136#define Q_AVGBITS (17) /* scale bit values */ 137 138static INT FDKaacEnc_bits2pe2( 139 const INT bits, 140 const FIXP_DBL factor_m, 141 const INT factor_e 142 ) 143{ 144 return (INT)(fMult(factor_m, (FIXP_DBL)(bits<<Q_AVGBITS)) >> (Q_AVGBITS-factor_e)); 145} 146 147/***************************************************************************** 148functionname: FDKaacEnc_calcThreshExp 149description: loudness calculation (threshold to the power of redExp) 150*****************************************************************************/ 151static void FDKaacEnc_calcThreshExp(FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB], 152 QC_OUT_CHANNEL* qcOutChannel[(2)], 153 PSY_OUT_CHANNEL* psyOutChannel[(2)], 154 const INT nChannels) 155{ 156 INT ch, sfb, sfbGrp; 157 FIXP_DBL thrExpLdData; 158 159 for (ch=0; ch<nChannels; ch++) { 160 for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup) { 161 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 162 thrExpLdData = psyOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb]>>2 ; 163 thrExp[ch][sfbGrp+sfb] = CalcInvLdData(thrExpLdData); 164 } 165 } 166 } 167} 168 169 170/***************************************************************************** 171 functionname: FDKaacEnc_adaptMinSnr 172 description: reduce minSnr requirements for bands with relative low energies 173*****************************************************************************/ 174static void FDKaacEnc_adaptMinSnr(QC_OUT_CHANNEL *qcOutChannel[(2)], 175 PSY_OUT_CHANNEL *psyOutChannel[(2)], 176 MINSNR_ADAPT_PARAM *msaParam, 177 const INT nChannels) 178{ 179 INT ch, sfb, sfbGrp, nSfb; 180 FIXP_DBL avgEnLD64, dbRatio, minSnrRed; 181 FIXP_DBL minSnrLimitLD64 = FL2FXCONST_DBL(-0.00503012648262f); /* ld64(0.8f) */ 182 FIXP_DBL nSfbLD64; 183 FIXP_DBL accu; 184 185 for (ch=0; ch<nChannels; ch++) { 186 /* calc average energy per scalefactor band */ 187 nSfb = 0; 188 accu = FL2FXCONST_DBL(0.0f); 189 190 for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) { 191 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 192 accu += psyOutChannel[ch]->sfbEnergy[sfbGrp+sfb]>>6; 193 nSfb++; 194 } 195 } 196 197 if ((accu == FL2FXCONST_DBL(0.0f)) || (nSfb == 0)) { 198 avgEnLD64 = FL2FXCONST_DBL(-1.0f); 199 } 200 else { 201 nSfbLD64 = CalcLdInt(nSfb); 202 avgEnLD64 = CalcLdData(accu); 203 avgEnLD64 = avgEnLD64 + FL2FXCONST_DBL(0.09375f) - nSfbLD64; /* 0.09375f: compensate shift with 6 */ 204 } 205 206 /* reduce minSnr requirement by minSnr^minSnrRed dependent on avgEn/sfbEn */ 207 for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) { 208 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 209 if ( (msaParam->startRatio + qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]) < avgEnLD64 ) { 210 dbRatio = fMult((avgEnLD64 - qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]),FL2FXCONST_DBL(0.3010299956f)); /* scaled by (1.0f/(10.0f*64.0f)) */ 211 minSnrRed = msaParam->redOffs + fMult(msaParam->redRatioFac,dbRatio); /* scaled by 1.0f/64.0f*/ 212 minSnrRed = fixMax(minSnrRed, msaParam->maxRed); /* scaled by 1.0f/64.0f*/ 213 qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb] = (fMult(qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb],minSnrRed)) << 6; 214 qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(minSnrLimitLD64, qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb]); 215 } 216 } 217 } 218 } 219} 220 221 222/***************************************************************************** 223functionname: FDKaacEnc_initAvoidHoleFlag 224description: determine bands where avoid hole is not necessary resp. possible 225*****************************************************************************/ 226static void FDKaacEnc_initAvoidHoleFlag(QC_OUT_CHANNEL *qcOutChannel[(2)], 227 PSY_OUT_CHANNEL *psyOutChannel[(2)], 228 UCHAR ahFlag[(2)][MAX_GROUPED_SFB], 229 struct TOOLSINFO *toolsInfo, 230 const INT nChannels, 231 const PE_DATA *peData, 232 AH_PARAM *ahParam) 233{ 234 INT ch, sfb, sfbGrp; 235 FIXP_DBL sfbEn, sfbEnm1; 236 FIXP_DBL sfbEnLdData; 237 FIXP_DBL avgEnLdData; 238 239 /* decrease spread energy by 3dB for long blocks, resp. 2dB for shorts 240 (avoid more holes in long blocks) */ 241 for (ch=0; ch<nChannels; ch++) { 242 INT sfbGrp, sfb; 243 QC_OUT_CHANNEL* qcOutChan = qcOutChannel[ch]; 244 245 if (psyOutChannel[ch]->lastWindowSequence != SHORT_WINDOW) { 246 for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup) 247 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) 248 qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] >>= 1 ; 249 } 250 else { 251 for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup) 252 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) 253 qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] = 254 fMult(FL2FXCONST_DBL(0.63f), 255 qcOutChan->sfbSpreadEnergy[sfbGrp+sfb]) ; 256 } 257 } 258 259 /* increase minSnr for local peaks, decrease it for valleys */ 260 if (ahParam->modifyMinSnr) { 261 for(ch=0; ch<nChannels; ch++) { 262 QC_OUT_CHANNEL* qcOutChan = qcOutChannel[ch]; 263 for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup){ 264 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 265 FIXP_DBL sfbEnp1, avgEn; 266 if (sfb > 0) 267 sfbEnm1 = qcOutChan->sfbEnergy[sfbGrp+sfb-1]; 268 else 269 sfbEnm1 = qcOutChan->sfbEnergy[sfbGrp+sfb]; 270 271 if (sfb < psyOutChannel[ch]->maxSfbPerGroup-1) 272 sfbEnp1 = qcOutChan->sfbEnergy[sfbGrp+sfb+1]; 273 else 274 sfbEnp1 = qcOutChan->sfbEnergy[sfbGrp+sfb]; 275 276 avgEn = (sfbEnm1>>1) + (sfbEnp1>>1); 277 avgEnLdData = CalcLdData(avgEn); 278 sfbEn = qcOutChan->sfbEnergy[sfbGrp+sfb]; 279 sfbEnLdData = qcOutChan->sfbEnergyLdData[sfbGrp+sfb]; 280 /* peak ? */ 281 if (sfbEn > avgEn) { 282 FIXP_DBL tmpMinSnrLdData; 283 if (psyOutChannel[ch]->lastWindowSequence==LONG_WINDOW) 284 tmpMinSnrLdData = fixMax( SnrLdFac + (FIXP_DBL)(avgEnLdData - sfbEnLdData), (FIXP_DBL)SnrLdMin1 ) ; 285 else 286 tmpMinSnrLdData = fixMax( SnrLdFac + (FIXP_DBL)(avgEnLdData - sfbEnLdData), (FIXP_DBL)SnrLdMin3 ) ; 287 288 qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] = 289 fixMin(qcOutChan->sfbMinSnrLdData[sfbGrp+sfb], tmpMinSnrLdData); 290 } 291 /* valley ? */ 292 if ( ((sfbEnLdData+(FIXP_DBL)SnrLdMin4) < (FIXP_DBL)avgEnLdData) && (sfbEn > FL2FXCONST_DBL(0.0)) ) { 293 FIXP_DBL tmpMinSnrLdData = avgEnLdData - sfbEnLdData -(FIXP_DBL)SnrLdMin4 + qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]; 294 tmpMinSnrLdData = fixMin((FIXP_DBL)SnrLdFac, tmpMinSnrLdData); 295 qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(tmpMinSnrLdData, 296 (FIXP_DBL)(qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + SnrLdMin2 )); 297 } 298 } 299 } 300 } 301 } 302 303 /* stereo: adapt the minimum requirements sfbMinSnr of mid and 304 side channels to avoid spending unnoticable bits */ 305 if (nChannels == 2) { 306 QC_OUT_CHANNEL* qcOutChanM = qcOutChannel[0]; 307 QC_OUT_CHANNEL* qcOutChanS = qcOutChannel[1]; 308 PSY_OUT_CHANNEL* psyOutChanM = psyOutChannel[0]; 309 for(sfbGrp = 0;sfbGrp < psyOutChanM->sfbCnt;sfbGrp+= psyOutChanM->sfbPerGroup){ 310 for (sfb=0; sfb<psyOutChanM->maxSfbPerGroup; sfb++) { 311 if (toolsInfo->msMask[sfbGrp+sfb]) { 312 FIXP_DBL maxSfbEnLd = fixMax(qcOutChanM->sfbEnergyLdData[sfbGrp+sfb],qcOutChanS->sfbEnergyLdData[sfbGrp+sfb]); 313 FIXP_DBL maxThrLd, sfbMinSnrTmpLd; 314 315 if ( ((SnrLdMin5>>1) + (maxSfbEnLd>>1) + (qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb]>>1)) <= FL2FXCONST_DBL(-0.5f)) 316 maxThrLd = FL2FXCONST_DBL(-1.0f) ; 317 else 318 maxThrLd = SnrLdMin5 + maxSfbEnLd + qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb]; 319 320 if (qcOutChanM->sfbEnergy[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f)) 321 sfbMinSnrTmpLd = maxThrLd - qcOutChanM->sfbEnergyLdData[sfbGrp+sfb]; 322 else 323 sfbMinSnrTmpLd = FL2FXCONST_DBL(0.0f); 324 325 qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] = fixMax(qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb],sfbMinSnrTmpLd); 326 327 if (qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] <= FL2FXCONST_DBL(0.0f)) 328 qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb], (FIXP_DBL)SnrLdFac); 329 330 if (qcOutChanS->sfbEnergy[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f)) 331 sfbMinSnrTmpLd = maxThrLd - qcOutChanS->sfbEnergyLdData[sfbGrp+sfb]; 332 else 333 sfbMinSnrTmpLd = FL2FXCONST_DBL(0.0f); 334 335 qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] = fixMax(qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb],sfbMinSnrTmpLd); 336 337 if (qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] <= FL2FXCONST_DBL(0.0f)) 338 qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb],(FIXP_DBL)SnrLdFac); 339 340 if (qcOutChanM->sfbEnergy[sfbGrp+sfb]>qcOutChanM->sfbSpreadEnergy[sfbGrp+sfb]) 341 qcOutChanS->sfbSpreadEnergy[sfbGrp+sfb] = 342 fMult(qcOutChanS->sfbEnergy[sfbGrp+sfb], FL2FXCONST_DBL(0.9f)); 343 344 if (qcOutChanS->sfbEnergy[sfbGrp+sfb]>qcOutChanS->sfbSpreadEnergy[sfbGrp+sfb]) 345 qcOutChanM->sfbSpreadEnergy[sfbGrp+sfb] = 346 fMult(qcOutChanM->sfbEnergy[sfbGrp+sfb], FL2FXCONST_DBL(0.9f)); 347 } 348 } 349 } 350 } 351 352 /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */ 353 for(ch=0; ch<nChannels; ch++) { 354 QC_OUT_CHANNEL *qcOutChan = qcOutChannel[ch]; 355 PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch]; 356 for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){ 357 for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) { 358 if ((qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] > qcOutChan->sfbEnergy[sfbGrp+sfb]) 359 || (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f))) { 360 ahFlag[ch][sfbGrp+sfb] = NO_AH; 361 } 362 else { 363 ahFlag[ch][sfbGrp+sfb] = AH_INACTIVE; 364 } 365 } 366 } 367 } 368} 369 370 371 372/** 373 * \brief Calculate constants that do not change during successive pe calculations. 374 * 375 * \param peData Pointer to structure containing PE data of current element. 376 * \param psyOutChannel Pointer to PSY_OUT_CHANNEL struct holding nChannels elements. 377 * \param qcOutChannel Pointer to QC_OUT_CHANNEL struct holding nChannels elements. 378 * \param nChannels Number of channels in element. 379 * \param peOffset Fixed PE offset defined while FDKaacEnc_AdjThrInit() depending on bitrate. 380 * 381 * \return void 382 */ 383static 384void FDKaacEnc_preparePe(PE_DATA *peData, 385 PSY_OUT_CHANNEL* psyOutChannel[(2)], 386 QC_OUT_CHANNEL* qcOutChannel[(2)], 387 const INT nChannels, 388 const INT peOffset) 389{ 390 INT ch; 391 392 for(ch=0; ch<nChannels; ch++) { 393 PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch]; 394 FDKaacEnc_prepareSfbPe(&peData->peChannelData[ch], 395 psyOutChan->sfbEnergyLdData, 396 psyOutChan->sfbThresholdLdData, 397 qcOutChannel[ch]->sfbFormFactorLdData, 398 psyOutChan->sfbOffsets, 399 psyOutChan->sfbCnt, 400 psyOutChan->sfbPerGroup, 401 psyOutChan->maxSfbPerGroup); 402 } 403 peData->offset = peOffset; 404} 405 406/** 407 * \brief Calculate weighting factor for threshold adjustment. 408 * 409 * Calculate weighting factor to be applied at energies and thresholds in ld64 format. 410 * 411 * \param peData, Pointer to PE data in current element. 412 * \param psyOutChannel Pointer to PSY_OUT_CHANNEL struct holding nChannels elements. 413 * \param qcOutChannel Pointer to QC_OUT_CHANNEL struct holding nChannels elements. 414 * \param toolsInfo Pointer to tools info struct of current element. 415 * \param adjThrStateElement Pointer to ATS_ELEMENT holding enFacPatch states. 416 * \param nChannels Number of channels in element. 417 * \param usePatchTool Apply the weighting tool 0 (no) else (yes). 418 * 419 * \return void 420 */ 421static 422void FDKaacEnc_calcWeighting(PE_DATA *peData, 423 PSY_OUT_CHANNEL* psyOutChannel[(2)], 424 QC_OUT_CHANNEL* qcOutChannel[(2)], 425 struct TOOLSINFO *toolsInfo, 426 ATS_ELEMENT* adjThrStateElement, 427 const INT nChannels, 428 const INT usePatchTool) 429{ 430 int ch, noShortWindowInFrame = TRUE; 431 INT exePatchM = 0; 432 433 for (ch=0; ch<nChannels; ch++) { 434 if (psyOutChannel[ch]->lastWindowSequence == SHORT_WINDOW) { 435 noShortWindowInFrame = FALSE; 436 } 437 FDKmemclear(qcOutChannel[ch]->sfbEnFacLd, MAX_GROUPED_SFB*sizeof(FIXP_DBL)); 438 } 439 440 if (usePatchTool==0) { 441 return; /* tool is disabled */ 442 } 443 444 for (ch=0; ch<nChannels; ch++) { 445 446 PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch]; 447 448 if (noShortWindowInFrame) { /* retain energy ratio between blocks of different length */ 449 450 FIXP_DBL nrgSum14, nrgSum12, nrgSum34, nrgTotal; 451 FIXP_DBL nrgFacLd_14, nrgFacLd_12, nrgFacLd_34; 452 INT usePatch, exePatch; 453 int sfb, nLinesSum = 0; 454 455 nrgSum14 = nrgSum12 = nrgSum34 = nrgTotal = FL2FXCONST_DBL(0.f); 456 457 /* calculate flatness of audible spectrum, i.e. spectrum above masking threshold. */ 458 for (sfb = 0; sfb < psyOutChan->sfbCnt; sfb++) { 459 460 FIXP_DBL nrgFac12 = CalcInvLdData(psyOutChan->sfbEnergyLdData[sfb]>>1); /* nrg^(1/2) */ 461 FIXP_DBL nrgFac14 = CalcInvLdData(psyOutChan->sfbEnergyLdData[sfb]>>2); /* nrg^(1/4) */ 462 463 /* maximal number of bands is 64, results scaling factor 6 */ 464 nLinesSum += peData->peChannelData[ch].sfbNLines[sfb]; /* relevant lines */ 465 nrgTotal += ( psyOutChan->sfbEnergy[sfb] >> 6 ); /* sum up nrg */ 466 nrgSum12 += ( nrgFac12 >> 6 ); /* sum up nrg^(2/4) */ 467 nrgSum14 += ( nrgFac14 >> 6 ); /* sum up nrg^(1/4) */ 468 nrgSum34 += ( fMult(nrgFac14, nrgFac12) >> 6 ); /* sum up nrg^(3/4) */ 469 } 470 471 nrgTotal = CalcLdData(nrgTotal); /* get ld64 of total nrg */ 472 473 nrgFacLd_14 = CalcLdData(nrgSum14) - nrgTotal; /* ld64(nrgSum14/nrgTotal) */ 474 nrgFacLd_12 = CalcLdData(nrgSum12) - nrgTotal; /* ld64(nrgSum12/nrgTotal) */ 475 nrgFacLd_34 = CalcLdData(nrgSum34) - nrgTotal; /* ld64(nrgSum34/nrgTotal) */ 476 477 adjThrStateElement->chaosMeasureEnFac[ch] = FDKmax( FL2FXCONST_DBL(0.1875f), fDivNorm(nLinesSum,psyOutChan->sfbOffsets[psyOutChan->sfbCnt]) ); 478 479 usePatch = (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.78125f)); 480 exePatch = ((usePatch) && (adjThrStateElement->lastEnFacPatch[ch])); 481 482 for (sfb = 0; sfb < psyOutChan->sfbCnt; sfb++) { 483 INT sfbExePatch; 484 485 /* for MS coupled SFBs, also execute patch in side channel if done in mid channel */ 486 if ((ch == 1) && (toolsInfo->msMask[sfb])) { 487 sfbExePatch = exePatchM; 488 } 489 else { 490 sfbExePatch = exePatch; 491 } 492 493 if ( (sfbExePatch) && (psyOutChan->sfbEnergy[sfb]>FL2FXCONST_DBL(0.f)) ) 494 { 495 /* execute patch based on spectral flatness calculated above */ 496 if (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.8125f)) { 497 qcOutChannel[ch]->sfbEnFacLd[sfb] = ( (nrgFacLd_14 + (psyOutChan->sfbEnergyLdData[sfb]+(psyOutChan->sfbEnergyLdData[sfb]>>1)))>>1 ); /* sfbEnergy^(3/4) */ 498 } 499 else if (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.796875f)) { 500 qcOutChannel[ch]->sfbEnFacLd[sfb] = ( (nrgFacLd_12 + psyOutChan->sfbEnergyLdData[sfb])>>1 ); /* sfbEnergy^(2/4) */ 501 } 502 else { 503 qcOutChannel[ch]->sfbEnFacLd[sfb] = ( (nrgFacLd_34 + (psyOutChan->sfbEnergyLdData[sfb]>>1))>>1 ); /* sfbEnergy^(1/4) */ 504 } 505 qcOutChannel[ch]->sfbEnFacLd[sfb] = fixMin(qcOutChannel[ch]->sfbEnFacLd[sfb],(FIXP_DBL)0); 506 507 } 508 } /* sfb loop */ 509 510 adjThrStateElement->lastEnFacPatch[ch] = usePatch; 511 exePatchM = exePatch; 512 } 513 else { 514 /* !noShortWindowInFrame */ 515 adjThrStateElement->chaosMeasureEnFac[ch] = FL2FXCONST_DBL(0.75f); 516 adjThrStateElement->lastEnFacPatch[ch] = TRUE; /* allow use of sfbEnFac patch in upcoming frame */ 517 } 518 519 } /* ch loop */ 520 521} 522 523 524 525 526/***************************************************************************** 527functionname: FDKaacEnc_calcPe 528description: calculate pe for both channels 529*****************************************************************************/ 530static 531void FDKaacEnc_calcPe(PSY_OUT_CHANNEL* psyOutChannel[(2)], 532 QC_OUT_CHANNEL* qcOutChannel[(2)], 533 PE_DATA *peData, 534 const INT nChannels) 535{ 536 INT ch; 537 538 peData->pe = peData->offset; 539 peData->constPart = 0; 540 peData->nActiveLines = 0; 541 for(ch=0; ch<nChannels; ch++) { 542 PE_CHANNEL_DATA *peChanData = &peData->peChannelData[ch]; 543 FDKaacEnc_calcSfbPe(&peData->peChannelData[ch], 544 qcOutChannel[ch]->sfbWeightedEnergyLdData, 545 qcOutChannel[ch]->sfbThresholdLdData, 546 psyOutChannel[ch]->sfbCnt, 547 psyOutChannel[ch]->sfbPerGroup, 548 psyOutChannel[ch]->maxSfbPerGroup, 549 psyOutChannel[ch]->isBook, 550 psyOutChannel[ch]->isScale); 551 552 peData->pe += peChanData->pe; 553 peData->constPart += peChanData->constPart; 554 peData->nActiveLines += peChanData->nActiveLines; 555 } 556} 557 558void FDKaacEnc_peCalculation(PE_DATA *peData, 559 PSY_OUT_CHANNEL* psyOutChannel[(2)], 560 QC_OUT_CHANNEL* qcOutChannel[(2)], 561 struct TOOLSINFO *toolsInfo, 562 ATS_ELEMENT* adjThrStateElement, 563 const INT nChannels) 564{ 565 /* constants that will not change during successive pe calculations */ 566 FDKaacEnc_preparePe(peData, psyOutChannel, qcOutChannel, nChannels, adjThrStateElement->peOffset); 567 568 /* calculate weighting factor for threshold adjustment */ 569 FDKaacEnc_calcWeighting(peData, psyOutChannel, qcOutChannel, toolsInfo, adjThrStateElement, nChannels, 1); 570{ 571 /* no weighting of threholds and energies for mlout */ 572 /* weight energies and thresholds */ 573 int ch; 574 for (ch=0; ch<nChannels; ch++) { 575 576 int sfb, sfbGrp; 577 QC_OUT_CHANNEL* pQcOutCh = qcOutChannel[ch]; 578 579 for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) { 580 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 581 pQcOutCh->sfbWeightedEnergyLdData[sfb+sfbGrp] = pQcOutCh->sfbEnergyLdData[sfb+sfbGrp] - pQcOutCh->sfbEnFacLd[sfb+sfbGrp]; 582 pQcOutCh->sfbThresholdLdData[sfb+sfbGrp] -= pQcOutCh->sfbEnFacLd[sfb+sfbGrp]; 583 } 584 } 585 } 586} 587 588 /* pe without reduction */ 589 FDKaacEnc_calcPe(psyOutChannel, qcOutChannel, peData, nChannels); 590} 591 592 593 594/***************************************************************************** 595functionname: FDKaacEnc_FDKaacEnc_calcPeNoAH 596description: sum the pe data only for bands where avoid hole is inactive 597*****************************************************************************/ 598static void FDKaacEnc_FDKaacEnc_calcPeNoAH(INT *pe, 599 INT *constPart, 600 INT *nActiveLines, 601 PE_DATA *peData, 602 UCHAR ahFlag[(2)][MAX_GROUPED_SFB], 603 PSY_OUT_CHANNEL* psyOutChannel[(2)], 604 const INT nChannels) 605{ 606 INT ch, sfb,sfbGrp; 607 608 INT pe_tmp = peData->offset; 609 INT constPart_tmp = 0; 610 INT nActiveLines_tmp = 0; 611 for(ch=0; ch<nChannels; ch++) { 612 PE_CHANNEL_DATA *peChanData = &peData->peChannelData[ch]; 613 for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup){ 614 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 615 if(ahFlag[ch][sfbGrp+sfb] < AH_ACTIVE) { 616 pe_tmp += peChanData->sfbPe[sfbGrp+sfb]; 617 constPart_tmp += peChanData->sfbConstPart[sfbGrp+sfb]; 618 nActiveLines_tmp += peChanData->sfbNActiveLines[sfbGrp+sfb]; 619 } 620 } 621 } 622 } 623 /* correct scaled pe and constPart values */ 624 *pe = pe_tmp >> PE_CONSTPART_SHIFT; 625 *constPart = constPart_tmp >> PE_CONSTPART_SHIFT; 626 627 *nActiveLines = nActiveLines_tmp; 628} 629 630 631/***************************************************************************** 632functionname: FDKaacEnc_reduceThresholdsCBR 633description: apply reduction formula 634*****************************************************************************/ 635static const FIXP_DBL limitThrReducedLdData = (FIXP_DBL)0x00008000; /*FL2FXCONST_DBL(FDKpow(2.0,-LD_DATA_SCALING/4.0));*/ 636 637static void FDKaacEnc_reduceThresholdsCBR(QC_OUT_CHANNEL* qcOutChannel[(2)], 638 PSY_OUT_CHANNEL* psyOutChannel[(2)], 639 UCHAR ahFlag[(2)][MAX_GROUPED_SFB], 640 FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB], 641 const INT nChannels, 642 const FIXP_DBL redVal, 643 const SCHAR redValScaling) 644{ 645 INT ch, sfb, sfbGrp; 646 FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrReducedLdData; 647 FIXP_DBL sfbThrExp; 648 649 for(ch=0; ch<nChannels; ch++) { 650 QC_OUT_CHANNEL *qcOutChan = qcOutChannel[ch]; 651 for(sfbGrp = 0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+= psyOutChannel[ch]->sfbPerGroup){ 652 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 653 sfbEnLdData = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb]; 654 sfbThrLdData = qcOutChan->sfbThresholdLdData[sfbGrp+sfb]; 655 sfbThrExp = thrExp[ch][sfbGrp+sfb]; 656 if ((sfbEnLdData > sfbThrLdData) && (ahFlag[ch][sfbGrp+sfb] != AH_ACTIVE)) { 657 658 /* threshold reduction formula: 659 float tmp = thrExp[ch][sfb]+redVal; 660 tmp *= tmp; 661 sfbThrReduced = tmp*tmp; 662 */ 663 int minScale = fixMin(CountLeadingBits(sfbThrExp), CountLeadingBits(redVal) - (DFRACT_BITS-1-redValScaling) )-1; 664 665 /* 4*log( sfbThrExp + redVal ) */ 666 sfbThrReducedLdData = CalcLdData(fAbs(scaleValue(sfbThrExp, minScale) + scaleValue(redVal,(DFRACT_BITS-1-redValScaling)+minScale))) 667 - (FIXP_DBL)(minScale<<(DFRACT_BITS-1-LD_DATA_SHIFT)); 668 sfbThrReducedLdData <<= 2; 669 670 /* avoid holes */ 671 if ( ((sfbThrReducedLdData - sfbEnLdData) > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] ) 672 && (ahFlag[ch][sfbGrp+sfb] != NO_AH) ) 673 { 674 if (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > (FL2FXCONST_DBL(-1.0f) - sfbEnLdData) ){ 675 sfbThrReducedLdData = fixMax((qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData), sfbThrLdData); 676 } 677 else sfbThrReducedLdData = sfbThrLdData; 678 ahFlag[ch][sfbGrp+sfb] = AH_ACTIVE; 679 } 680 681 /* minimum of 29 dB Ratio for Thresholds */ 682 if ((sfbEnLdData+(FIXP_DBL)MAXVAL_DBL) > FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)){ 683 sfbThrReducedLdData = fixMax(sfbThrReducedLdData, (sfbEnLdData - FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING))); 684 } 685 686 qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData; 687 } 688 } 689 } 690 } 691} 692 693/* similar to prepareSfbPe1() */ 694static FIXP_DBL FDKaacEnc_calcChaosMeasure(PSY_OUT_CHANNEL *psyOutChannel, 695 const FIXP_DBL *sfbFormFactorLdData) 696{ 697 #define SCALE_FORM_FAC (4) /* (SCALE_FORM_FAC+FORM_FAC_SHIFT) >= ld(FRAME_LENGTH)*/ 698 #define SCALE_NRGS (8) 699 #define SCALE_NLINES (16) 700 #define SCALE_NRGS_SQRT4 (2) /* 0.25 * SCALE_NRGS */ 701 #define SCALE_NLINES_P34 (12) /* 0.75 * SCALE_NLINES */ 702 703 INT sfbGrp, sfb; 704 FIXP_DBL chaosMeasure; 705 INT frameNLines = 0; 706 FIXP_DBL frameFormFactor = FL2FXCONST_DBL(0.f); 707 FIXP_DBL frameEnergy = FL2FXCONST_DBL(0.f); 708 709 for (sfbGrp=0; sfbGrp<psyOutChannel->sfbCnt; sfbGrp+=psyOutChannel->sfbPerGroup) { 710 for (sfb=0; sfb<psyOutChannel->maxSfbPerGroup; sfb++){ 711 if (psyOutChannel->sfbEnergyLdData[sfbGrp+sfb] > psyOutChannel->sfbThresholdLdData[sfbGrp+sfb]) { 712 frameFormFactor += (CalcInvLdData(sfbFormFactorLdData[sfbGrp+sfb])>>SCALE_FORM_FAC); 713 frameNLines += (psyOutChannel->sfbOffsets[sfbGrp+sfb+1] - psyOutChannel->sfbOffsets[sfbGrp+sfb]); 714 frameEnergy += (psyOutChannel->sfbEnergy[sfbGrp+sfb]>>SCALE_NRGS); 715 } 716 } 717 } 718 719 if(frameNLines > 0){ 720 721 /* frameNActiveLines = frameFormFactor*2^FORM_FAC_SHIFT * ((frameEnergy *2^SCALE_NRGS)/frameNLines)^-0.25 722 chaosMeasure = frameNActiveLines / frameNLines */ 723 chaosMeasure = 724 CalcInvLdData( (((CalcLdData(frameFormFactor)>>1) - 725 (CalcLdData(frameEnergy)>>(2+1))) - 726 (fMultDiv2(FL2FXCONST_DBL(0.75f),CalcLdData((FIXP_DBL)frameNLines<<(DFRACT_BITS-1-SCALE_NLINES))) - 727 (((FIXP_DBL)(SCALE_FORM_FAC-SCALE_NRGS_SQRT4+FORM_FAC_SHIFT-(SCALE_NLINES_P34))<<(DFRACT_BITS-1-LD_DATA_SHIFT))>>1)) 728 )<<1 ); 729 } else { 730 731 /* assuming total chaos, if no sfb is above thresholds */ 732 chaosMeasure = FL2FXCONST_DBL(1.f); 733 } 734 735 return chaosMeasure; 736} 737 738 739/* apply reduction formula for VBR-mode */ 740static void FDKaacEnc_reduceThresholdsVBR(QC_OUT_CHANNEL* qcOutChannel[(2)], 741 PSY_OUT_CHANNEL* psyOutChannel[(2)], 742 UCHAR ahFlag[(2)][MAX_GROUPED_SFB], 743 FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB], 744 const INT nChannels, 745 const FIXP_DBL vbrQualFactor, 746 FIXP_DBL* chaosMeasureOld) 747{ 748 INT ch, sfbGrp, sfb; 749 FIXP_DBL chGroupEnergy[TRANS_FAC][2];/*energy for each group and channel*/ 750 FIXP_DBL chChaosMeasure[2]; 751 FIXP_DBL frameEnergy = FL2FXCONST_DBL(1e-10f); 752 FIXP_DBL chaosMeasure = FL2FXCONST_DBL(0.f); 753 FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrExp; 754 FIXP_DBL sfbThrReducedLdData; 755 FIXP_DBL chaosMeasureAvg; 756 INT groupCnt; /* loop counter */ 757 FIXP_DBL redVal[TRANS_FAC]; /* reduction values; in short-block case one redVal for each group */ 758 QC_OUT_CHANNEL *qcOutChan = NULL; 759 PSY_OUT_CHANNEL *psyOutChan = NULL; 760 761#define SCALE_GROUP_ENERGY (8) 762 763#define CONST_CHAOS_MEAS_AVG_FAC_0 (FL2FXCONST_DBL(0.25f)) 764#define CONST_CHAOS_MEAS_AVG_FAC_1 (FL2FXCONST_DBL(1.f-0.25f)) 765 766#define MIN_LDTHRESH (FL2FXCONST_DBL(-0.515625f)) 767 768 769 for(ch=0; ch<nChannels; ch++){ 770 qcOutChan = qcOutChannel[ch]; 771 psyOutChan = psyOutChannel[ch]; 772 773 /* adding up energy for each channel and each group separately */ 774 FIXP_DBL chEnergy = FL2FXCONST_DBL(0.f); 775 groupCnt=0; 776 777 for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup, groupCnt++) { 778 chGroupEnergy[groupCnt][ch] = FL2FXCONST_DBL(0.f); 779 for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++){ 780 chGroupEnergy[groupCnt][ch] += (psyOutChan->sfbEnergy[sfbGrp+sfb]>>SCALE_GROUP_ENERGY); 781 } 782 chEnergy += chGroupEnergy[groupCnt][ch]; 783 } 784 frameEnergy += chEnergy; 785 786 /* chaosMeasure */ 787 if (psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW) { 788 chChaosMeasure[ch] = FL2FXCONST_DBL(0.5f); /* assume a constant chaos measure of 0.5f for short blocks */ 789 } else { 790 chChaosMeasure[ch] = FDKaacEnc_calcChaosMeasure(psyOutChannel[ch], qcOutChannel[ch]->sfbFormFactorLdData); 791 } 792 chaosMeasure += fMult(chChaosMeasure[ch], chEnergy); 793 } 794 795 if(frameEnergy > chaosMeasure) { 796 INT scale = CntLeadingZeros(frameEnergy) - 1; 797 FIXP_DBL num = chaosMeasure<<scale; 798 FIXP_DBL denum = frameEnergy<<scale; 799 chaosMeasure = schur_div(num,denum,16); 800 } 801 else { 802 chaosMeasure = FL2FXCONST_DBL(1.f); 803 } 804 805 chaosMeasureAvg = fMult(CONST_CHAOS_MEAS_AVG_FAC_0, chaosMeasure) + 806 fMult(CONST_CHAOS_MEAS_AVG_FAC_1, *chaosMeasureOld); /* averaging chaos measure */ 807 *chaosMeasureOld = chaosMeasure = (fixMin(chaosMeasure, chaosMeasureAvg)); /* use min-value, safe for next frame */ 808 809 /* characteristic curve 810 chaosMeasure = 0.2f + 0.7f/0.3f * (chaosMeasure - 0.2f); 811 chaosMeasure = fixMin(1.0f, fixMax(0.1f, chaosMeasure)); 812 constants scaled by 4.f 813 */ 814 chaosMeasure = ((FL2FXCONST_DBL(0.2f)>>2) + fMult(FL2FXCONST_DBL(0.7f/(4.f*0.3f)), (chaosMeasure - FL2FXCONST_DBL(0.2f)))); 815 chaosMeasure = (fixMin((FIXP_DBL)(FL2FXCONST_DBL(1.0f)>>2), fixMax((FIXP_DBL)(FL2FXCONST_DBL(0.1f)>>2), chaosMeasure)))<<2; 816 817 /* calculation of reduction value */ 818 if (psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW){ /* short-blocks */ 819 FDK_ASSERT(TRANS_FAC==8); 820 #define WIN_TYPE_SCALE (3) 821 822 INT sfbGrp, groupCnt=0; 823 for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup,groupCnt++) { 824 825 FIXP_DBL groupEnergy = FL2FXCONST_DBL(0.f); 826 827 for(ch=0;ch<nChannels;ch++){ 828 groupEnergy += chGroupEnergy[groupCnt][ch]; /* adding up the channels groupEnergy */ 829 } 830 831 FDK_ASSERT(psyOutChannel[0]->groupLen[groupCnt]<=INV_INT_TAB_SIZE); 832 groupEnergy = fMult(groupEnergy,invInt[psyOutChannel[0]->groupLen[groupCnt]]); /* correction of group energy */ 833 groupEnergy = fixMin(groupEnergy, frameEnergy>>WIN_TYPE_SCALE); /* do not allow an higher redVal as calculated framewise */ 834 835 groupEnergy>>=2; /* 2*WIN_TYPE_SCALE = 6 => 6+2 = 8 ==> 8/4 = int number */ 836 837 redVal[groupCnt] = fMult(fMult(vbrQualFactor,chaosMeasure), 838 CalcInvLdData(CalcLdData(groupEnergy)>>2) ) 839 << (int)( ( 2 + (2*WIN_TYPE_SCALE) + SCALE_GROUP_ENERGY )>>2 ) ; 840 841 } 842 } else { /* long-block */ 843 844 redVal[0] = fMult( fMult(vbrQualFactor,chaosMeasure), 845 CalcInvLdData(CalcLdData(frameEnergy)>>2) ) 846 << (int)( SCALE_GROUP_ENERGY>>2 ) ; 847 } 848 849 for(ch=0; ch<nChannels; ch++) { 850 qcOutChan = qcOutChannel[ch]; 851 psyOutChan = psyOutChannel[ch]; 852 853 for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup) { 854 for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++){ 855 856 sfbEnLdData = (qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb]); 857 sfbThrLdData = (qcOutChan->sfbThresholdLdData[sfbGrp+sfb]); 858 sfbThrExp = thrExp[ch][sfbGrp+sfb]; 859 860 if ( (sfbThrLdData>=MIN_LDTHRESH) && (sfbEnLdData > sfbThrLdData) && (ahFlag[ch][sfbGrp+sfb] != AH_ACTIVE)) { 861 862 /* Short-Window */ 863 if (psyOutChannel[ch]->lastWindowSequence == SHORT_WINDOW) { 864 const int groupNumber = (int) sfb/psyOutChan->sfbPerGroup; 865 866 FDK_ASSERT(INV_SQRT4_TAB_SIZE>psyOutChan->groupLen[groupNumber]); 867 868 sfbThrExp = fMult(sfbThrExp, fMult( FL2FXCONST_DBL(2.82f/4.f), invSqrt4[psyOutChan->groupLen[groupNumber]]))<<2 ; 869 870 if ( sfbThrExp <= (limitThrReducedLdData-redVal[groupNumber]) ) { 871 sfbThrReducedLdData = FL2FXCONST_DBL(-1.0f); 872 } 873 else { 874 if ((FIXP_DBL)redVal[groupNumber] >= FL2FXCONST_DBL(1.0f)-sfbThrExp) 875 sfbThrReducedLdData = FL2FXCONST_DBL(0.0f); 876 else { 877 /* threshold reduction formula */ 878 sfbThrReducedLdData = CalcLdData(sfbThrExp + redVal[groupNumber]); 879 sfbThrReducedLdData <<= 2; 880 } 881 } 882 sfbThrReducedLdData += ( CalcLdInt(psyOutChan->groupLen[groupNumber]) - 883 ((FIXP_DBL)6<<(DFRACT_BITS-1-LD_DATA_SHIFT)) ); 884 } 885 886 /* Long-Window */ 887 else { 888 if ((FIXP_DBL)redVal[0] >= FL2FXCONST_DBL(1.0f)-sfbThrExp) { 889 sfbThrReducedLdData = FL2FXCONST_DBL(0.0f); 890 } 891 else { 892 /* threshold reduction formula */ 893 sfbThrReducedLdData = CalcLdData(sfbThrExp + redVal[0]); 894 sfbThrReducedLdData <<= 2; 895 } 896 } 897 898 /* avoid holes */ 899 if ( ((sfbThrReducedLdData - sfbEnLdData) > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] ) 900 && (ahFlag[ch][sfbGrp+sfb] != NO_AH) ) 901 { 902 if (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > (FL2FXCONST_DBL(-1.0f) - sfbEnLdData) ){ 903 sfbThrReducedLdData = fixMax((qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData), sfbThrLdData); 904 } 905 else sfbThrReducedLdData = sfbThrLdData; 906 ahFlag[ch][sfbGrp+sfb] = AH_ACTIVE; 907 } 908 909 if (sfbThrReducedLdData<FL2FXCONST_DBL(-0.5f)) 910 sfbThrReducedLdData = FL2FXCONST_DBL(-1.f); 911 912 /* minimum of 29 dB Ratio for Thresholds */ 913 if ((sfbEnLdData+FL2FXCONST_DBL(1.0f)) > FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)){ 914 sfbThrReducedLdData = fixMax(sfbThrReducedLdData, sfbEnLdData - FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)); 915 } 916 917 sfbThrReducedLdData = fixMax(MIN_LDTHRESH,sfbThrReducedLdData); 918 919 qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData; 920 } 921 } 922 } 923 } 924} 925 926 927/***************************************************************************** 928functionname: FDKaacEnc_correctThresh 929description: if pe difference deltaPe between desired pe and real pe is small enough, 930the difference can be distributed among the scale factor bands. 931New thresholds can be derived from this pe-difference 932*****************************************************************************/ 933static void FDKaacEnc_correctThresh(CHANNEL_MAPPING* cm, 934 QC_OUT_ELEMENT* qcElement[(6)], 935 PSY_OUT_ELEMENT* psyOutElement[(6)], 936 UCHAR ahFlag[(6)][(2)][MAX_GROUPED_SFB], 937 FIXP_DBL thrExp[(6)][(2)][MAX_GROUPED_SFB], 938 const FIXP_DBL redVal[(6)], 939 const SCHAR redValScaling[(6)], 940 const INT deltaPe, 941 const INT processElements, 942 const INT elementOffset) 943{ 944 INT ch, sfb, sfbGrp; 945 QC_OUT_CHANNEL *qcOutChan; 946 PSY_OUT_CHANNEL *psyOutChan; 947 PE_CHANNEL_DATA *peChanData; 948 FIXP_DBL thrFactorLdData; 949 FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrReducedLdData; 950 FIXP_DBL *sfbPeFactorsLdData[(6)][(2)]; 951 FIXP_DBL sfbNActiveLinesLdData[(2)][MAX_GROUPED_SFB]; 952 INT normFactorInt; 953 FIXP_DBL normFactorLdData; 954 955 INT nElements = elementOffset+processElements; 956 INT elementId; 957 958 /* scratch is empty; use temporal memory from quantSpec in QC_OUT_CHANNEL */ 959 for(elementId=elementOffset;elementId<nElements;elementId++) { 960 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 961 SHORT* ptr = qcElement[elementId]->qcOutChannel[ch]->quantSpec; 962 sfbPeFactorsLdData[elementId][ch] = (FIXP_DBL*)ptr; 963 } 964 } 965 966 /* for each sfb calc relative factors for pe changes */ 967 normFactorInt = 0; 968 969 for(elementId=elementOffset;elementId<nElements;elementId++) { 970 if (cm->elInfo[elementId].elType != ID_DSE) { 971 972 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 973 974 qcOutChan = qcElement[elementId]->qcOutChannel[ch]; 975 psyOutChan = psyOutElement[elementId]->psyOutChannel[ch]; 976 peChanData = &qcElement[elementId]->peData.peChannelData[ch]; 977 978 for(sfbGrp = 0; sfbGrp < psyOutChan->sfbCnt; sfbGrp+= psyOutChan->sfbPerGroup){ 979 for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) { 980 981 if ( peChanData->sfbNActiveLines[sfbGrp+sfb] == 0 ) { 982 sfbNActiveLinesLdData[ch][sfbGrp+sfb] = FL2FXCONST_DBL(-1.0f); 983 } 984 else { 985 /* Both CalcLdInt and CalcLdData can be used! 986 * No offset has to be subtracted, because sfbNActiveLinesLdData 987 * is shorted while thrFactor calculation */ 988 sfbNActiveLinesLdData[ch][sfbGrp+sfb] = CalcLdInt(peChanData->sfbNActiveLines[sfbGrp+sfb]); 989 } 990 if ( ((ahFlag[elementId][ch][sfbGrp+sfb] < AH_ACTIVE) || (deltaPe > 0)) && 991 peChanData->sfbNActiveLines[sfbGrp+sfb] != 0 ) 992 { 993 if (thrExp[elementId][ch][sfbGrp+sfb] > -redVal[elementId]) { 994 995 /* sfbPeFactors[ch][sfbGrp+sfb] = peChanData->sfbNActiveLines[sfbGrp+sfb] / 996 (thrExp[elementId][ch][sfbGrp+sfb] + redVal[elementId]); */ 997 998 int minScale = fixMin(CountLeadingBits(thrExp[elementId][ch][sfbGrp+sfb]), CountLeadingBits(redVal[elementId]) - (DFRACT_BITS-1-redValScaling[elementId]) ) - 1; 999 1000 /* sumld = ld64( sfbThrExp + redVal ) */ 1001 FIXP_DBL sumLd = CalcLdData(scaleValue(thrExp[elementId][ch][sfbGrp+sfb], minScale) + scaleValue(redVal[elementId], (DFRACT_BITS-1-redValScaling[elementId])+minScale)) 1002 - (FIXP_DBL)(minScale<<(DFRACT_BITS-1-LD_DATA_SHIFT)); 1003 1004 if (sumLd < FL2FXCONST_DBL(0.f)) { 1005 sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[ch][sfbGrp+sfb] - sumLd; 1006 } 1007 else { 1008 if ( sfbNActiveLinesLdData[ch][sfbGrp+sfb] > (FL2FXCONST_DBL(-1.f) + sumLd) ) { 1009 sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[ch][sfbGrp+sfb] - sumLd; 1010 } 1011 else { 1012 sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[ch][sfbGrp+sfb]; 1013 } 1014 } 1015 1016 normFactorInt += (INT)CalcInvLdData(sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb]); 1017 } 1018 else sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = FL2FXCONST_DBL(1.0f); 1019 } 1020 else sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = FL2FXCONST_DBL(-1.0f); 1021 } 1022 } 1023 } 1024 } 1025 } 1026 1027 /* normFactorLdData = ld64(deltaPe/normFactorInt) */ 1028 normFactorLdData = CalcLdData((FIXP_DBL)((deltaPe<0) ? (-deltaPe) : (deltaPe))) - CalcLdData((FIXP_DBL)normFactorInt); 1029 1030 /* distribute the pe difference to the scalefactors 1031 and calculate the according thresholds */ 1032 for(elementId=elementOffset;elementId<nElements;elementId++) { 1033 if (cm->elInfo[elementId].elType != ID_DSE) { 1034 1035 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 1036 qcOutChan = qcElement[elementId]->qcOutChannel[ch]; 1037 psyOutChan = psyOutElement[elementId]->psyOutChannel[ch]; 1038 peChanData = &qcElement[elementId]->peData.peChannelData[ch]; 1039 1040 for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){ 1041 for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) { 1042 1043 if (peChanData->sfbNActiveLines[sfbGrp+sfb] > 0) { 1044 1045 /* pe difference for this sfb */ 1046 if ( (sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb]==FL2FXCONST_DBL(-1.0f)) || 1047 (deltaPe==0) ) 1048 { 1049 thrFactorLdData = FL2FXCONST_DBL(0.f); 1050 } 1051 else { 1052 /* new threshold */ 1053 FIXP_DBL tmp = CalcInvLdData(sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] + normFactorLdData - sfbNActiveLinesLdData[ch][sfbGrp+sfb] - FL2FXCONST_DBL((float)LD_DATA_SHIFT/LD_DATA_SCALING)); 1054 1055 /* limit thrFactor to 60dB */ 1056 tmp = (deltaPe<0) ? tmp : (-tmp); 1057 thrFactorLdData = FDKmin(tmp, FL2FXCONST_DBL(20.f/LD_DATA_SCALING)); 1058 } 1059 1060 /* new threshold */ 1061 sfbThrLdData = qcOutChan->sfbThresholdLdData[sfbGrp+sfb]; 1062 sfbEnLdData = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb]; 1063 1064 if (thrFactorLdData < FL2FXCONST_DBL(0.f)) { 1065 if( sfbThrLdData > (FL2FXCONST_DBL(-1.f)-thrFactorLdData) ) { 1066 sfbThrReducedLdData = sfbThrLdData + thrFactorLdData; 1067 } 1068 else { 1069 sfbThrReducedLdData = FL2FXCONST_DBL(-1.f); 1070 } 1071 } 1072 else{ 1073 sfbThrReducedLdData = sfbThrLdData + thrFactorLdData; 1074 } 1075 1076 /* avoid hole */ 1077 if ( (sfbThrReducedLdData - sfbEnLdData > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]) && 1078 (ahFlag[elementId][ch][sfbGrp+sfb] == AH_INACTIVE) ) 1079 { 1080 /* sfbThrReduced = max(psyOutChan[ch]->sfbMinSnr[i] * sfbEn, sfbThr); */ 1081 if ( sfbEnLdData > (sfbThrLdData-qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]) ) { 1082 sfbThrReducedLdData = qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData; 1083 } 1084 else { 1085 sfbThrReducedLdData = sfbThrLdData; 1086 } 1087 ahFlag[elementId][ch][sfbGrp+sfb] = AH_ACTIVE; 1088 } 1089 1090 qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData; 1091 } 1092 } 1093 } 1094 } 1095 } 1096 } 1097} 1098 1099/***************************************************************************** 1100 functionname: FDKaacEnc_reduceMinSnr 1101 description: if the desired pe can not be reached, reduce pe by 1102 reducing minSnr 1103*****************************************************************************/ 1104void FDKaacEnc_reduceMinSnr(CHANNEL_MAPPING* cm, 1105 QC_OUT_ELEMENT* qcElement[(6)], 1106 PSY_OUT_ELEMENT* psyOutElement[(6)], 1107 UCHAR ahFlag[(6)][(2)][MAX_GROUPED_SFB], 1108 const INT desiredPe, 1109 INT* redPeGlobal, 1110 const INT processElements, 1111 const INT elementOffset) 1112 1113{ 1114 INT elementId; 1115 INT nElements = elementOffset+processElements; 1116 1117 INT newGlobalPe = *redPeGlobal; 1118 1119 for(elementId=elementOffset;elementId<nElements;elementId++) { 1120 if (cm->elInfo[elementId].elType != ID_DSE) { 1121 INT ch; 1122 INT maxSfbPerGroup[2]; 1123 INT sfbCnt[2]; 1124 INT sfbPerGroup[2]; 1125 1126 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 1127 maxSfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->maxSfbPerGroup-1; 1128 sfbCnt[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbCnt; 1129 sfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbPerGroup; 1130 } 1131 1132 PE_DATA *peData = &qcElement[elementId]->peData; 1133 1134 do 1135 { 1136 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 1137 1138 INT sfb, sfbGrp; 1139 QC_OUT_CHANNEL *qcOutChan = qcElement[elementId]->qcOutChannel[ch]; 1140 INT noReduction = 1; 1141 1142 if (maxSfbPerGroup[ch]>=0) { /* sfb in next channel */ 1143 INT deltaPe = 0; 1144 sfb = maxSfbPerGroup[ch]--; 1145 noReduction = 0; 1146 1147 for (sfbGrp = 0; sfbGrp < sfbCnt[ch]; sfbGrp += sfbPerGroup[ch]) { 1148 1149 if (ahFlag[elementId][ch][sfbGrp+sfb] != NO_AH && 1150 qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] < SnrLdFac) 1151 { 1152 /* increase threshold to new minSnr of 1dB */ 1153 qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] = SnrLdFac; 1154 1155 /* sfbThrReduced = max(psyOutChan[ch]->sfbMinSnr[i] * sfbEn, sfbThr); */ 1156 if ( qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb] >= qcOutChan->sfbThresholdLdData[sfbGrp+sfb] - qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] ) { 1157 1158 qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb] + qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]; 1159 1160 /* calc new pe */ 1161 /* C2 + C3*ld(1/0.8) = 1.5 */ 1162 deltaPe -= (peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT); 1163 1164 /* sfbPe = 1.5 * sfbNLines */ 1165 peData->peChannelData[ch].sfbPe[sfbGrp+sfb] = (3*peData->peChannelData[ch].sfbNLines[sfbGrp+sfb]) << (PE_CONSTPART_SHIFT-1); 1166 deltaPe += (peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT); 1167 } 1168 } 1169 1170 } /* sfbGrp loop */ 1171 1172 peData->pe += deltaPe; 1173 peData->peChannelData[ch].pe += deltaPe; 1174 newGlobalPe += deltaPe; 1175 1176 /* stop if enough has been saved */ 1177 if (peData->pe <= desiredPe) { 1178 goto bail; 1179 } 1180 1181 } /* sfb > 0 */ 1182 1183 if ( (ch==(cm->elInfo[elementId].nChannelsInEl-1)) && noReduction ) { 1184 goto bail; 1185 } 1186 1187 } /* ch loop */ 1188 1189 } while ( peData->pe > desiredPe); 1190 1191 } /* != ID_DSE */ 1192 } /* element loop */ 1193 1194 1195bail: 1196 /* update global PE */ 1197 *redPeGlobal = newGlobalPe; 1198} 1199 1200 1201/***************************************************************************** 1202 functionname: FDKaacEnc_allowMoreHoles 1203 description: if the desired pe can not be reached, some more scalefactor 1204 bands have to be quantized to zero 1205*****************************************************************************/ 1206static void FDKaacEnc_allowMoreHoles(CHANNEL_MAPPING* cm, 1207 QC_OUT_ELEMENT* qcElement[(6)], 1208 PSY_OUT_ELEMENT* psyOutElement[(6)], 1209 ATS_ELEMENT* AdjThrStateElement[(6)], 1210 UCHAR ahFlag[(6)][(2)][MAX_GROUPED_SFB], 1211 const INT desiredPe, 1212 const INT currentPe, 1213 const int processElements, 1214 const int elementOffset) 1215{ 1216 INT elementId; 1217 INT nElements = elementOffset+processElements; 1218 INT actPe = currentPe; 1219 1220 if (actPe <= desiredPe) { 1221 return; /* nothing to do */ 1222 } 1223 1224 for (elementId = elementOffset;elementId<nElements;elementId++) { 1225 if (cm->elInfo[elementId].elType != ID_DSE) { 1226 1227 INT ch, sfb, sfbGrp; 1228 1229 PE_DATA *peData = &qcElement[elementId]->peData; 1230 const INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1231 1232 QC_OUT_CHANNEL* qcOutChannel[(2)] = {NULL}; 1233 PSY_OUT_CHANNEL* psyOutChannel[(2)] = {NULL}; 1234 1235 for (ch=0; ch<nChannels; ch++) { 1236 1237 /* init pointers */ 1238 qcOutChannel[ch] = qcElement[elementId]->qcOutChannel[ch]; 1239 psyOutChannel[ch] = psyOutElement[elementId]->psyOutChannel[ch]; 1240 1241 for(sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+= psyOutChannel[ch]->sfbPerGroup) { 1242 for (sfb=psyOutChannel[ch]->maxSfbPerGroup; sfb<psyOutChannel[ch]->sfbPerGroup; sfb++) { 1243 peData->peChannelData[ch].sfbPe[sfbGrp+sfb] = 0; 1244 } 1245 } 1246 } 1247 1248 /* for MS allow hole in the channel with less energy */ 1249 if ( nChannels==2 && psyOutChannel[0]->lastWindowSequence==psyOutChannel[1]->lastWindowSequence ) { 1250 1251 for (sfb=0; sfb<psyOutChannel[0]->maxSfbPerGroup; sfb++) { 1252 for(sfbGrp=0; sfbGrp < psyOutChannel[0]->sfbCnt; sfbGrp+=psyOutChannel[0]->sfbPerGroup) { 1253 if (psyOutElement[elementId]->toolsInfo.msMask[sfbGrp+sfb]) { 1254 FIXP_DBL EnergyLd_L = qcOutChannel[0]->sfbWeightedEnergyLdData[sfbGrp+sfb]; 1255 FIXP_DBL EnergyLd_R = qcOutChannel[1]->sfbWeightedEnergyLdData[sfbGrp+sfb]; 1256 1257 /* allow hole in side channel ? */ 1258 if ( (ahFlag[elementId][1][sfbGrp+sfb] != NO_AH) && 1259 (((FL2FXCONST_DBL(-0.02065512648f)>>1) + (qcOutChannel[0]->sfbMinSnrLdData[sfbGrp+sfb]>>1)) 1260 > ((EnergyLd_R>>1) - (EnergyLd_L>>1))) ) 1261 { 1262 ahFlag[elementId][1][sfbGrp+sfb] = NO_AH; 1263 qcOutChannel[1]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + EnergyLd_R; 1264 actPe -= peData->peChannelData[1].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT; 1265 } 1266 /* allow hole in mid channel ? */ 1267 else if ( (ahFlag[elementId][0][sfbGrp+sfb] != NO_AH) && 1268 (((FL2FXCONST_DBL(-0.02065512648f)>>1) + (qcOutChannel[1]->sfbMinSnrLdData[sfbGrp+sfb]>>1)) 1269 > ((EnergyLd_L>>1) - (EnergyLd_R>>1))) ) 1270 { 1271 ahFlag[elementId][0][sfbGrp+sfb] = NO_AH; 1272 qcOutChannel[0]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + EnergyLd_L; 1273 actPe -= peData->peChannelData[0].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT; 1274 } /* if (ahFlag) */ 1275 } /* if MS */ 1276 } /* sfbGrp */ 1277 if (actPe <= desiredPe) { 1278 return; /* stop if enough has been saved */ 1279 } 1280 } /* sfb */ 1281 } /* MS possible ? */ 1282 1283 /* more holes necessary? subsequently erase bands 1284 starting with low energies */ 1285 INT startSfb[2]; 1286 FIXP_DBL avgEnLD64,minEnLD64; 1287 INT ahCnt; 1288 FIXP_DBL ahCntLD64; 1289 INT enIdx; 1290 FIXP_DBL enLD64[4]; 1291 FIXP_DBL avgEn; 1292 1293 /* do not go below startSfb */ 1294 for (ch=0; ch<nChannels; ch++) { 1295 if (psyOutChannel[ch]->lastWindowSequence != SHORT_WINDOW) 1296 startSfb[ch] = AdjThrStateElement[elementId]->ahParam.startSfbL; 1297 else 1298 startSfb[ch] = AdjThrStateElement[elementId]->ahParam.startSfbS; 1299 } 1300 1301 /* calc avg and min energies of bands that avoid holes */ 1302 avgEn = FL2FXCONST_DBL(0.0f); 1303 minEnLD64 = FL2FXCONST_DBL(0.0f); 1304 ahCnt = 0; 1305 1306 for (ch=0; ch<nChannels; ch++) { 1307 1308 sfbGrp=0; 1309 sfb=startSfb[ch]; 1310 1311 do { 1312 for (; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 1313 if ((ahFlag[elementId][ch][sfbGrp+sfb]!=NO_AH) && 1314 (qcOutChannel[ch]->sfbWeightedEnergyLdData[sfbGrp+sfb] > qcOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb])){ 1315 minEnLD64 = fixMin(minEnLD64,qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]); 1316 avgEn += qcOutChannel[ch]->sfbEnergy[sfbGrp+sfb] >> 6; 1317 ahCnt++; 1318 } 1319 } 1320 1321 sfbGrp += psyOutChannel[ch]->sfbPerGroup; 1322 sfb=0; 1323 1324 } while (sfbGrp < psyOutChannel[ch]->sfbCnt); 1325 } 1326 1327 if ( (avgEn == FL2FXCONST_DBL(0.0f)) || (ahCnt == 0) ) { 1328 avgEnLD64 = FL2FXCONST_DBL(0.0f); 1329 } 1330 else { 1331 avgEnLD64 = CalcLdData(avgEn); 1332 ahCntLD64 = CalcLdInt(ahCnt); 1333 avgEnLD64 = avgEnLD64 + FL2FXCONST_DBL(0.09375f) - ahCntLD64; /* compensate shift with 6 */ 1334 } 1335 1336 /* calc some energy borders between minEn and avgEn */ 1337 /* for (enIdx=0; enIdx<4; enIdx++) */ 1338 /* en[enIdx] = minEn * (float)FDKpow(avgEn/(minEn+FLT_MIN), (2*enIdx+1)/7.0f); */ 1339 enLD64[0] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.14285714285f)); 1340 enLD64[1] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.42857142857f)); 1341 enLD64[2] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.71428571428f)); 1342 enLD64[3] = minEnLD64 + (avgEnLD64-minEnLD64); 1343 1344 for (enIdx=0; enIdx<4; enIdx++) { 1345 INT noReduction = 1; 1346 1347 INT maxSfbPerGroup[2]; 1348 INT sfbCnt[2]; 1349 INT sfbPerGroup[2]; 1350 1351 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 1352 maxSfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->maxSfbPerGroup-1; 1353 sfbCnt[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbCnt; 1354 sfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbPerGroup; 1355 } 1356 1357 do { 1358 1359 noReduction = 1; 1360 1361 for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) { 1362 1363 INT sfb, sfbGrp; 1364 1365 /* start with lowest energy border at highest sfb */ 1366 if (maxSfbPerGroup[ch]>=startSfb[ch]) { /* sfb in next channel */ 1367 sfb = maxSfbPerGroup[ch]--; 1368 noReduction = 0; 1369 1370 for (sfbGrp = 0; sfbGrp < sfbCnt[ch]; sfbGrp += sfbPerGroup[ch]) { 1371 /* sfb energy below border ? */ 1372 if (ahFlag[elementId][ch][sfbGrp+sfb] != NO_AH && qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb] < enLD64[enIdx]) { 1373 /* allow hole */ 1374 ahFlag[elementId][ch][sfbGrp+sfb] = NO_AH; 1375 qcOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + qcOutChannel[ch]->sfbWeightedEnergyLdData[sfbGrp+sfb]; 1376 actPe -= peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT; 1377 } 1378 } /* sfbGrp */ 1379 1380 if (actPe <= desiredPe) { 1381 return; /* stop if enough has been saved */ 1382 } 1383 } /* sfb > 0 */ 1384 } /* ch loop */ 1385 1386 } while( (noReduction == 0) && (actPe > desiredPe) ); 1387 1388 if (actPe <= desiredPe) { 1389 return; /* stop if enough has been saved */ 1390 } 1391 1392 } /* enIdx loop */ 1393 1394 } /* EOF DSE-suppression */ 1395 } /* EOF for all elements... */ 1396 1397} 1398 1399/* reset avoid hole flags from AH_ACTIVE to AH_INACTIVE */ 1400static void FDKaacEnc_resetAHFlags( UCHAR ahFlag[(2)][MAX_GROUPED_SFB], 1401 const int nChannels, 1402 PSY_OUT_CHANNEL *psyOutChannel[(2)]) 1403{ 1404 int ch, sfb, sfbGrp; 1405 1406 for(ch=0; ch<nChannels; ch++) { 1407 for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) { 1408 for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 1409 if ( ahFlag[ch][sfbGrp+sfb] == AH_ACTIVE) { 1410 ahFlag[ch][sfbGrp+sfb] = AH_INACTIVE; 1411 } 1412 } 1413 } 1414 } 1415} 1416 1417 1418static FIXP_DBL CalcRedValPower(FIXP_DBL num, 1419 FIXP_DBL denum, 1420 INT* scaling ) 1421{ 1422 FIXP_DBL value = FL2FXCONST_DBL(0.f); 1423 1424 if (num>=FL2FXCONST_DBL(0.f)) { 1425 value = fDivNorm( num, denum, scaling); 1426 } 1427 else { 1428 value = -fDivNorm( -num, denum, scaling); 1429 } 1430 value = f2Pow(value, *scaling, scaling); 1431 *scaling = DFRACT_BITS-1-*scaling; 1432 1433 return value; 1434} 1435 1436 1437/***************************************************************************** 1438functionname: FDKaacEnc_adaptThresholdsToPe 1439description: two guesses for the reduction value and one final correction of the thresholds 1440*****************************************************************************/ 1441static void FDKaacEnc_adaptThresholdsToPe(CHANNEL_MAPPING* cm, 1442 ATS_ELEMENT* AdjThrStateElement[(6)], 1443 QC_OUT_ELEMENT* qcElement[(6)], 1444 PSY_OUT_ELEMENT* psyOutElement[(6)], 1445 const INT desiredPe, 1446 const INT processElements, 1447 const INT elementOffset) 1448{ 1449 FIXP_DBL redValue[(6)]; 1450 SCHAR redValScaling[(6)]; 1451 UCHAR pAhFlag[(6)][(2)][MAX_GROUPED_SFB]; 1452 FIXP_DBL pThrExp[(6)][(2)][MAX_GROUPED_SFB]; 1453 int iter; 1454 1455 INT constPartGlobal, noRedPeGlobal, nActiveLinesGlobal, redPeGlobal; 1456 constPartGlobal = noRedPeGlobal = nActiveLinesGlobal = redPeGlobal = 0; 1457 1458 int elementId; 1459 1460 int nElements = elementOffset+processElements; 1461 if(nElements > cm->nElements) { 1462 nElements = cm->nElements; 1463 } 1464 1465 /* ------------------------------------------------------- */ 1466 /* Part I: Initialize data structures and variables... */ 1467 /* ------------------------------------------------------- */ 1468 for (elementId = elementOffset;elementId<nElements;elementId++) { 1469 if (cm->elInfo[elementId].elType != ID_DSE) { 1470 1471 INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1472 PE_DATA *peData = &qcElement[elementId]->peData; 1473 1474 /* thresholds to the power of redExp */ 1475 FDKaacEnc_calcThreshExp(pThrExp[elementId], qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, nChannels); 1476 1477 /* lower the minSnr requirements for low energies compared to the average 1478 energy in this frame */ 1479 FDKaacEnc_adaptMinSnr(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, &AdjThrStateElement[elementId]->minSnrAdaptParam, nChannels); 1480 1481 /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */ 1482 FDKaacEnc_initAvoidHoleFlag(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], &psyOutElement[elementId]->toolsInfo, nChannels, peData, &AdjThrStateElement[elementId]->ahParam); 1483 1484 /* sum up */ 1485 constPartGlobal += peData->constPart; 1486 noRedPeGlobal += peData->pe; 1487 nActiveLinesGlobal += fixMax((INT)peData->nActiveLines, 1); 1488 1489 } /* EOF DSE-suppression */ 1490 } /* EOF for all elements... */ 1491 1492 /* ----------------------------------------------------------------------- */ 1493 /* Part II: Calculate bit consumption of initial bit constraints setup */ 1494 /* ----------------------------------------------------------------------- */ 1495 for (elementId = elementOffset;elementId<nElements;elementId++) { 1496 if (cm->elInfo[elementId].elType != ID_DSE) { 1497 /* 1498 redVal = ( 2 ^ ( (constPartGlobal-desiredPe) / (invRedExp*nActiveLinesGlobal) ) 1499 - 2 ^ ( (constPartGlobal-noRedPeGlobal) / (invRedExp*nActiveLinesGlobal) ) ) 1500 */ 1501 1502 1503 INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1504 PE_DATA *peData = &qcElement[elementId]->peData; 1505 1506 /* first guess of reduction value */ 1507 int scale0=0, scale1=0; 1508 FIXP_DBL tmp0 = CalcRedValPower( constPartGlobal-desiredPe, 4*nActiveLinesGlobal, &scale0 ); 1509 FIXP_DBL tmp1 = CalcRedValPower( constPartGlobal-noRedPeGlobal, 4*nActiveLinesGlobal, &scale1 ); 1510 1511 int scalMin = FDKmin(scale0, scale1)-1; 1512 1513 redValue[elementId] = scaleValue(tmp0,(scalMin-scale0)) - scaleValue(tmp1,(scalMin-scale1)); 1514 redValScaling[elementId] = scalMin; 1515 1516 /* reduce thresholds */ 1517 FDKaacEnc_reduceThresholdsCBR(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], pThrExp[elementId], nChannels, redValue[elementId], redValScaling[elementId]); 1518 1519 /* pe after first guess */ 1520 FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels); 1521 1522 redPeGlobal += peData->pe; 1523 } /* EOF DSE-suppression */ 1524 } /* EOF for all elements... */ 1525 1526 /* -------------------------------------------------- */ 1527 /* Part III: Iterate until bit constraints are met */ 1528 /* -------------------------------------------------- */ 1529 iter = 0; 1530 while ((fixp_abs(redPeGlobal - desiredPe) > fMultI(FL2FXCONST_DBL(0.05f),desiredPe)) && (iter < 1)) { 1531 1532 INT desiredPeNoAHGlobal; 1533 INT redPeNoAHGlobal = 0; 1534 INT constPartNoAHGlobal = 0; 1535 INT nActiveLinesNoAHGlobal = 0; 1536 1537 for (elementId = elementOffset;elementId<nElements;elementId++) { 1538 if (cm->elInfo[elementId].elType != ID_DSE) { 1539 1540 INT redPeNoAH, constPartNoAH, nActiveLinesNoAH; 1541 INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1542 PE_DATA *peData = &qcElement[elementId]->peData; 1543 1544 /* pe for bands where avoid hole is inactive */ 1545 FDKaacEnc_FDKaacEnc_calcPeNoAH(&redPeNoAH, &constPartNoAH, &nActiveLinesNoAH, 1546 peData, pAhFlag[elementId], psyOutElement[elementId]->psyOutChannel, nChannels); 1547 1548 redPeNoAHGlobal += redPeNoAH; 1549 constPartNoAHGlobal += constPartNoAH; 1550 nActiveLinesNoAHGlobal += nActiveLinesNoAH; 1551 } /* EOF DSE-suppression */ 1552 } /* EOF for all elements... */ 1553 1554 /* Calculate new redVal ... */ 1555 if(desiredPe < redPeGlobal) { 1556 1557 /* new desired pe without bands where avoid hole is active */ 1558 desiredPeNoAHGlobal = desiredPe - (redPeGlobal - redPeNoAHGlobal); 1559 1560 /* limit desiredPeNoAH to positive values, as the PE can not become negative */ 1561 desiredPeNoAHGlobal = FDKmax(0,desiredPeNoAHGlobal); 1562 1563 /* second guess (only if there are bands left where avoid hole is inactive)*/ 1564 if (nActiveLinesNoAHGlobal > 0) { 1565 for (elementId = elementOffset;elementId<nElements;elementId++) { 1566 if (cm->elInfo[elementId].elType != ID_DSE) { 1567 /* 1568 redVal += ( 2 ^ ( (constPartNoAHGlobal-desiredPeNoAHGlobal) / (invRedExp*nActiveLinesNoAHGlobal) ) 1569 - 2 ^ ( (constPartNoAHGlobal-redPeNoAHGlobal) / (invRedExp*nActiveLinesNoAHGlobal) ) ) 1570 */ 1571 int scale0 = 0; 1572 int scale1 = 0; 1573 1574 FIXP_DBL tmp0 = CalcRedValPower( constPartNoAHGlobal-desiredPeNoAHGlobal, 4*nActiveLinesNoAHGlobal, &scale0 ); 1575 FIXP_DBL tmp1 = CalcRedValPower( constPartNoAHGlobal-redPeNoAHGlobal, 4*nActiveLinesNoAHGlobal, &scale1 ); 1576 1577 int scalMin = FDKmin(scale0, scale1)-1; 1578 1579 tmp0 = scaleValue(tmp0,(scalMin-scale0)) - scaleValue(tmp1,(scalMin-scale1)); 1580 scale0 = scalMin; 1581 1582 /* old reduction value */ 1583 tmp1 = redValue[elementId]; 1584 scale1 = redValScaling[elementId]; 1585 1586 scalMin = fixMin(scale0,scale1)-1; 1587 1588 /* sum up old and new reduction value */ 1589 redValue[elementId] = scaleValue(tmp0,(scalMin-scale0)) + scaleValue(tmp1,(scalMin-scale1)); 1590 redValScaling[elementId] = scalMin; 1591 1592 } /* EOF DSE-suppression */ 1593 } /* EOF for all elements... */ 1594 } /* nActiveLinesNoAHGlobal > 0 */ 1595 } 1596 else { 1597 /* desiredPe >= redPeGlobal */ 1598 for (elementId = elementOffset;elementId<nElements;elementId++) { 1599 if (cm->elInfo[elementId].elType != ID_DSE) { 1600 1601 INT redVal_scale = 0; 1602 FIXP_DBL tmp = fDivNorm((FIXP_DBL)redPeGlobal, (FIXP_DBL)desiredPe, &redVal_scale); 1603 1604 /* redVal *= redPeGlobal/desiredPe; */ 1605 redValue[elementId] = fMult(redValue[elementId], tmp); 1606 redValScaling[elementId] -= redVal_scale; 1607 1608 FDKaacEnc_resetAHFlags(pAhFlag[elementId], cm->elInfo[elementId].nChannelsInEl, psyOutElement[elementId]->psyOutChannel); 1609 } /* EOF DSE-suppression */ 1610 } /* EOF for all elements... */ 1611 } 1612 1613 redPeGlobal = 0; 1614 /* Calculate new redVal's PE... */ 1615 for (elementId = elementOffset;elementId<nElements;elementId++) { 1616 if (cm->elInfo[elementId].elType != ID_DSE) { 1617 1618 INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1619 PE_DATA *peData = &qcElement[elementId]->peData; 1620 1621 /* reduce thresholds */ 1622 FDKaacEnc_reduceThresholdsCBR(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], pThrExp[elementId], nChannels, redValue[elementId], redValScaling[elementId]); 1623 1624 /* pe after second guess */ 1625 FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels); 1626 redPeGlobal += peData->pe; 1627 1628 } /* EOF DSE-suppression */ 1629 } /* EOF for all elements... */ 1630 1631 iter++; 1632 } /* EOF while */ 1633 1634 1635 /* ------------------------------------------------------- */ 1636 /* Part IV: if still required, further reduce constraints */ 1637 /* ------------------------------------------------------- */ 1638 /* 1.0* 1.15* 1.20* 1639 * desiredPe desiredPe desiredPe 1640 * | | | 1641 * ...XXXXXXXXXXXXXXXXXXXXXXXXXXX| | 1642 * | | |XXXXXXXXXXX... 1643 * | |XXXXXXXXXXX| 1644 * --- A --- | --- B --- | --- C --- 1645 * 1646 * (X): redPeGlobal 1647 * (A): FDKaacEnc_correctThresh() 1648 * (B): FDKaacEnc_allowMoreHoles() 1649 * (C): FDKaacEnc_reduceMinSnr() 1650 */ 1651 1652 /* correct thresholds to get closer to the desired pe */ 1653 if ( redPeGlobal > desiredPe ) { 1654 FDKaacEnc_correctThresh(cm, qcElement, psyOutElement, pAhFlag, pThrExp, redValue, redValScaling, 1655 desiredPe - redPeGlobal, processElements, elementOffset); 1656 1657 /* update PE */ 1658 redPeGlobal = 0; 1659 for(elementId=elementOffset;elementId<nElements;elementId++) { 1660 if (cm->elInfo[elementId].elType != ID_DSE) { 1661 1662 INT nChannels = cm->elInfo[elementId].nChannelsInEl; 1663 PE_DATA *peData = &qcElement[elementId]->peData; 1664 1665 /* pe after correctThresh */ 1666 FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels); 1667 redPeGlobal += peData->pe; 1668 1669 } /* EOF DSE-suppression */ 1670 } /* EOF for all elements... */ 1671 } 1672 1673 if ( redPeGlobal > desiredPe ) { 1674 /* reduce pe by reducing minSnr requirements */ 1675 FDKaacEnc_reduceMinSnr(cm, qcElement, psyOutElement, pAhFlag, 1676 (fMultI(FL2FXCONST_DBL(0.15f),desiredPe) + desiredPe), 1677 &redPeGlobal, processElements, elementOffset); 1678 1679 /* reduce pe by allowing additional spectral holes */ 1680 FDKaacEnc_allowMoreHoles(cm, qcElement, psyOutElement, AdjThrStateElement, pAhFlag, 1681 desiredPe, redPeGlobal, processElements, elementOffset); 1682 } 1683 1684} 1685 1686 1687/* similar to FDKaacEnc_adaptThresholdsToPe(), for VBR-mode */ 1688void FDKaacEnc_AdaptThresholdsVBR(QC_OUT_CHANNEL* qcOutChannel[(2)], 1689 PSY_OUT_CHANNEL* psyOutChannel[(2)], 1690 ATS_ELEMENT* AdjThrStateElement, 1691 struct TOOLSINFO *toolsInfo, 1692 PE_DATA *peData, 1693 const INT nChannels) 1694{ 1695 UCHAR pAhFlag[(2)][MAX_GROUPED_SFB]; 1696 FIXP_DBL pThrExp[(2)][MAX_GROUPED_SFB]; 1697 1698 /* thresholds to the power of redExp */ 1699 FDKaacEnc_calcThreshExp(pThrExp, qcOutChannel, psyOutChannel, nChannels); 1700 1701 /* lower the minSnr requirements for low energies compared to the average 1702 energy in this frame */ 1703 FDKaacEnc_adaptMinSnr(qcOutChannel, psyOutChannel, &AdjThrStateElement->minSnrAdaptParam, nChannels); 1704 1705 /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */ 1706 FDKaacEnc_initAvoidHoleFlag(qcOutChannel, psyOutChannel, pAhFlag, toolsInfo, 1707 nChannels, peData, &AdjThrStateElement->ahParam); 1708 1709 /* reduce thresholds */ 1710 FDKaacEnc_reduceThresholdsVBR(qcOutChannel, psyOutChannel, pAhFlag, pThrExp, nChannels, 1711 AdjThrStateElement->vbrQualFactor, 1712 &AdjThrStateElement->chaosMeasureOld); 1713 1714} 1715 1716 1717/***************************************************************************** 1718 1719 functionname: FDKaacEnc_calcBitSave 1720 description: Calculates percentage of bit save, see figure below 1721 returns: 1722 input: parameters and bitres-fullness 1723 output: percentage of bit save 1724 1725*****************************************************************************/ 1726/* 1727 bitsave 1728 maxBitSave(%)| clipLow 1729 |---\ 1730 | \ 1731 | \ 1732 | \ 1733 | \ 1734 |--------\--------------> bitres 1735 | \ 1736 minBitSave(%)| \------------ 1737 clipHigh maxBitres 1738*/ 1739static FIXP_DBL FDKaacEnc_calcBitSave(FIXP_DBL fillLevel, 1740 const FIXP_DBL clipLow, 1741 const FIXP_DBL clipHigh, 1742 const FIXP_DBL minBitSave, 1743 const FIXP_DBL maxBitSave, 1744 const FIXP_DBL bitsave_slope) 1745{ 1746 FIXP_DBL bitsave; 1747 1748 fillLevel = fixMax(fillLevel, clipLow); 1749 fillLevel = fixMin(fillLevel, clipHigh); 1750 1751 bitsave = maxBitSave - fMult((fillLevel-clipLow), bitsave_slope); 1752 1753 return (bitsave); 1754} 1755 1756/***************************************************************************** 1757 1758 functionname: FDKaacEnc_calcBitSpend 1759 description: Calculates percentage of bit spend, see figure below 1760 returns: 1761 input: parameters and bitres-fullness 1762 output: percentage of bit spend 1763 1764*****************************************************************************/ 1765/* 1766 bitspend clipHigh 1767 maxBitSpend(%)| /-----------maxBitres 1768 | / 1769 | / 1770 | / 1771 | / 1772 | / 1773 |----/-----------------> bitres 1774 | / 1775 minBitSpend(%)|--/ 1776 clipLow 1777*/ 1778static FIXP_DBL FDKaacEnc_calcBitSpend(FIXP_DBL fillLevel, 1779 const FIXP_DBL clipLow, 1780 const FIXP_DBL clipHigh, 1781 const FIXP_DBL minBitSpend, 1782 const FIXP_DBL maxBitSpend, 1783 const FIXP_DBL bitspend_slope) 1784{ 1785 FIXP_DBL bitspend; 1786 1787 fillLevel = fixMax(fillLevel, clipLow); 1788 fillLevel = fixMin(fillLevel, clipHigh); 1789 1790 bitspend = minBitSpend + fMult(fillLevel-clipLow, bitspend_slope); 1791 1792 return (bitspend); 1793} 1794 1795 1796/***************************************************************************** 1797 1798 functionname: FDKaacEnc_adjustPeMinMax() 1799 description: adjusts peMin and peMax parameters over time 1800 returns: 1801 input: current pe, peMin, peMax, bitres size 1802 output: adjusted peMin/peMax 1803 1804*****************************************************************************/ 1805static void FDKaacEnc_adjustPeMinMax(const INT currPe, 1806 INT *peMin, 1807 INT *peMax) 1808{ 1809 FIXP_DBL minFacHi = FL2FXCONST_DBL(0.3f), maxFacHi = (FIXP_DBL)MAXVAL_DBL, minFacLo = FL2FXCONST_DBL(0.14f), maxFacLo = FL2FXCONST_DBL(0.07f); 1810 INT diff; 1811 1812 INT minDiff_fix = fMultI(FL2FXCONST_DBL(0.1666666667f), currPe); 1813 1814 if (currPe > *peMax) 1815 { 1816 diff = (currPe-*peMax) ; 1817 *peMin += fMultI(minFacHi,diff); 1818 *peMax += fMultI(maxFacHi,diff); 1819 } 1820 else if (currPe < *peMin) 1821 { 1822 diff = (*peMin-currPe) ; 1823 *peMin -= fMultI(minFacLo,diff); 1824 *peMax -= fMultI(maxFacLo,diff); 1825 } 1826 else 1827 { 1828 *peMin += fMultI(minFacHi, (currPe - *peMin)); 1829 *peMax -= fMultI(maxFacLo, (*peMax - currPe)); 1830 } 1831 1832 if ((*peMax - *peMin) < minDiff_fix) 1833 { 1834 INT peMax_fix = *peMax, peMin_fix = *peMin; 1835 FIXP_DBL partLo_fix, partHi_fix; 1836 1837 partLo_fix = (FIXP_DBL)fixMax(0, currPe - peMin_fix); 1838 partHi_fix = (FIXP_DBL)fixMax(0, peMax_fix - currPe); 1839 1840 peMax_fix = (INT)(currPe + fMultI(fDivNorm(partHi_fix, (partLo_fix+partHi_fix)), minDiff_fix)); 1841 peMin_fix = (INT)(currPe - fMultI(fDivNorm(partLo_fix, (partLo_fix+partHi_fix)), minDiff_fix)); 1842 peMin_fix = fixMax(0, peMin_fix); 1843 1844 *peMax = peMax_fix; 1845 *peMin = peMin_fix; 1846 } 1847} 1848 1849 1850 1851/***************************************************************************** 1852 1853 functionname: BitresCalcBitFac 1854 description: calculates factor of spending bits for one frame 1855 1.0 : take all frame dynpart bits 1856 >1.0 : take all frame dynpart bits + bitres 1857 <1.0 : put bits in bitreservoir 1858 returns: BitFac 1859 input: bitres-fullness, pe, blockType, parameter-settings 1860 output: 1861 1862*****************************************************************************/ 1863/* 1864 bitfac(%) pemax 1865 bitspend(%) | /-----------maxBitres 1866 | / 1867 | / 1868 | / 1869 | / 1870 | / 1871 |----/-----------------> pe 1872 | / 1873 bitsave(%) |--/ 1874 pemin 1875*/ 1876 1877static FIXP_DBL FDKaacEnc_bitresCalcBitFac(const INT bitresBits, 1878 const INT maxBitresBits, 1879 const INT pe, 1880 const INT lastWindowSequence, 1881 const INT avgBits, 1882 const FIXP_DBL maxBitFac, 1883 ADJ_THR_STATE *AdjThr, 1884 ATS_ELEMENT *adjThrChan) 1885{ 1886 BRES_PARAM *bresParam; 1887 INT pex; 1888 1889 INT qmin, qbr, qbres, qmbr; 1890 FIXP_DBL bitSave, bitSpend; 1891 1892 FIXP_DBL bitresFac_fix, tmp_cst, tmp_fix; 1893 FIXP_DBL pe_pers, bits_ratio, maxBrVal; 1894 FIXP_DBL bitsave_slope, bitspend_slope, maxBitFac_tmp; 1895 FIXP_DBL fillLevel_fix = (FIXP_DBL)0x7fffffff; 1896 FIXP_DBL UNITY = (FIXP_DBL)0x7fffffff; 1897 FIXP_DBL POINT7 = (FIXP_DBL)0x5999999A; 1898 1899 if (maxBitresBits > bitresBits) { 1900 fillLevel_fix = fDivNorm(bitresBits, maxBitresBits); 1901 } 1902 1903 if (lastWindowSequence != SHORT_WINDOW) 1904 { 1905 bresParam = &(AdjThr->bresParamLong); 1906 bitsave_slope = (FIXP_DBL)0x3BBBBBBC; 1907 bitspend_slope = (FIXP_DBL)0x55555555; 1908 } 1909 else 1910 { 1911 bresParam = &(AdjThr->bresParamShort); 1912 bitsave_slope = (FIXP_DBL)0x2E8BA2E9; 1913 bitspend_slope = (FIXP_DBL)0x7fffffff; 1914 } 1915 1916 pex = fixMax(pe, adjThrChan->peMin); 1917 pex = fixMin(pex, adjThrChan->peMax); 1918 1919 bitSave = FDKaacEnc_calcBitSave(fillLevel_fix, 1920 bresParam->clipSaveLow, bresParam->clipSaveHigh, 1921 bresParam->minBitSave, bresParam->maxBitSave, bitsave_slope); 1922 1923 bitSpend = FDKaacEnc_calcBitSpend(fillLevel_fix, 1924 bresParam->clipSpendLow, bresParam->clipSpendHigh, 1925 bresParam->minBitSpend, bresParam->maxBitSpend, bitspend_slope); 1926 1927 pe_pers = fDivNorm(pex - adjThrChan->peMin, adjThrChan->peMax - adjThrChan->peMin); 1928 tmp_fix = fMult(((FIXP_DBL)bitSpend + (FIXP_DBL)bitSave), pe_pers); 1929 bitresFac_fix = (UNITY>>1) - ((FIXP_DBL)bitSave>>1) + (tmp_fix>>1); qbres = (DFRACT_BITS-2); 1930 1931 /* (float)bitresBits/(float)avgBits */ 1932 bits_ratio = fDivNorm(bitresBits, avgBits, &qbr); 1933 qbr = DFRACT_BITS-1-qbr; 1934 1935 /* Add 0.7 in q31 to bits_ratio in qbr */ 1936 /* 0.7f + (float)bitresBits/(float)avgBits */ 1937 qmin = fixMin(qbr, (DFRACT_BITS-1)); 1938 bits_ratio = bits_ratio >> (qbr - qmin); 1939 tmp_cst = POINT7 >> ((DFRACT_BITS-1) - qmin); 1940 maxBrVal = (bits_ratio>>1) + (tmp_cst>>1); qmbr = qmin - 1; 1941 1942 /* bitresFac_fix = fixMin(bitresFac_fix, 0.7 + bitresBits/avgBits); */ 1943 bitresFac_fix = bitresFac_fix >> (qbres - qmbr); qbres = qmbr; 1944 bitresFac_fix = fixMin(bitresFac_fix, maxBrVal); 1945 1946 /* Compare with maxBitFac */ 1947 qmin = fixMin(Q_BITFAC, qbres); 1948 bitresFac_fix = bitresFac_fix >> (qbres - qmin); 1949 maxBitFac_tmp = maxBitFac >> (Q_BITFAC - qmin); 1950 if(maxBitFac_tmp < bitresFac_fix) 1951 { 1952 bitresFac_fix = maxBitFac; 1953 } 1954 else 1955 { 1956 if(qmin < Q_BITFAC) 1957 { 1958 bitresFac_fix = bitresFac_fix << (Q_BITFAC-qmin); 1959 } 1960 else 1961 { 1962 bitresFac_fix = bitresFac_fix >> (qmin-Q_BITFAC); 1963 } 1964 } 1965 1966 FDKaacEnc_adjustPeMinMax(pe, &adjThrChan->peMin, &adjThrChan->peMax); 1967 1968 return bitresFac_fix; 1969} 1970 1971 1972/***************************************************************************** 1973functionname: FDKaacEnc_AdjThrNew 1974description: allocate ADJ_THR_STATE 1975*****************************************************************************/ 1976INT FDKaacEnc_AdjThrNew(ADJ_THR_STATE** phAdjThr, 1977 INT nElements) 1978{ 1979 INT err = 0; 1980 INT i; 1981 ADJ_THR_STATE* hAdjThr = GetRam_aacEnc_AdjustThreshold(); 1982 if (hAdjThr==NULL) { 1983 err = 1; 1984 goto bail; 1985 } 1986 1987 for (i=0; i<nElements; i++) { 1988 hAdjThr->adjThrStateElem[i] = GetRam_aacEnc_AdjThrStateElement(i); 1989 if (hAdjThr->adjThrStateElem[i]==NULL) { 1990 err = 1; 1991 goto bail; 1992 } 1993 } 1994 1995bail: 1996 *phAdjThr = hAdjThr; 1997 return err; 1998} 1999 2000 2001/***************************************************************************** 2002functionname: FDKaacEnc_AdjThrInit 2003description: initialize ADJ_THR_STATE 2004*****************************************************************************/ 2005void FDKaacEnc_AdjThrInit(ADJ_THR_STATE *hAdjThr, 2006 const INT meanPe, 2007 ELEMENT_BITS *elBits[(6)], 2008 INT nElements, 2009 FIXP_DBL vbrQualFactor) 2010{ 2011 INT i; 2012 2013 FIXP_DBL POINT8 = FL2FXCONST_DBL(0.8f); 2014 FIXP_DBL POINT6 = FL2FXCONST_DBL(0.6f); 2015 2016 /* common for all elements: */ 2017 /* parameters for bitres control */ 2018 hAdjThr->bresParamLong.clipSaveLow = (FIXP_DBL)0x1999999a; /* FL2FXCONST_DBL(0.2f); */ 2019 hAdjThr->bresParamLong.clipSaveHigh = (FIXP_DBL)0x7999999a; /* FL2FXCONST_DBL(0.95f); */ 2020 hAdjThr->bresParamLong.minBitSave = (FIXP_DBL)0xf999999a; /* FL2FXCONST_DBL(-0.05f); */ 2021 hAdjThr->bresParamLong.maxBitSave = (FIXP_DBL)0x26666666; /* FL2FXCONST_DBL(0.3f); */ 2022 hAdjThr->bresParamLong.clipSpendLow = (FIXP_DBL)0x1999999a; /* FL2FXCONST_DBL(0.2f); */ 2023 hAdjThr->bresParamLong.clipSpendHigh = (FIXP_DBL)0x7999999a; /* FL2FXCONST_DBL(0.95f); */ 2024 hAdjThr->bresParamLong.minBitSpend = (FIXP_DBL)0xf3333333; /* FL2FXCONST_DBL(-0.10f); */ 2025 hAdjThr->bresParamLong.maxBitSpend = (FIXP_DBL)0x33333333; /* FL2FXCONST_DBL(0.4f); */ 2026 2027 hAdjThr->bresParamShort.clipSaveLow = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */ 2028 hAdjThr->bresParamShort.clipSaveHigh = (FIXP_DBL)0x5fffffff; /* FL2FXCONST_DBL(0.75f); */ 2029 hAdjThr->bresParamShort.minBitSave = (FIXP_DBL)0x00000000; /* FL2FXCONST_DBL(0.0f); */ 2030 hAdjThr->bresParamShort.maxBitSave = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */ 2031 hAdjThr->bresParamShort.clipSpendLow = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */ 2032 hAdjThr->bresParamShort.clipSpendHigh = (FIXP_DBL)0x5fffffff; /* FL2FXCONST_DBL(0.75f); */ 2033 hAdjThr->bresParamShort.minBitSpend = (FIXP_DBL)0xf9999998; /* FL2FXCONST_DBL(-0.05f); */ 2034 hAdjThr->bresParamShort.maxBitSpend = (FIXP_DBL)0x40000000; /* FL2FXCONST_DBL(0.5f); */ 2035 2036 /* specific for each element: */ 2037 for (i=0; i<nElements; i++) { 2038 ATS_ELEMENT* atsElem = hAdjThr->adjThrStateElem[i]; 2039 MINSNR_ADAPT_PARAM *msaParam = &atsElem->minSnrAdaptParam; 2040 INT chBitrate = elBits[i]->chBitrateEl; 2041 2042 /* parameters for bitres control */ 2043 atsElem->peMin = fMultI(POINT8, meanPe) >> 1; 2044 atsElem->peMax = fMultI(POINT6, meanPe); 2045 2046 /* for use in FDKaacEnc_reduceThresholdsVBR */ 2047 atsElem->chaosMeasureOld = FL2FXCONST_DBL(0.3f); 2048 2049 /* additional pe offset to correct pe2bits for low bitrates */ 2050 atsElem->peOffset = 0; 2051 2052 /* vbr initialisation */ 2053 atsElem->vbrQualFactor = vbrQualFactor; 2054 if (chBitrate < 32000) 2055 { 2056 atsElem->peOffset = fixMax(50, 100-fMultI((FIXP_DBL)0x666667, chBitrate)); 2057 } 2058 2059 /* avoid hole parameters */ 2060 if (chBitrate > 20000) { 2061 atsElem->ahParam.modifyMinSnr = TRUE; 2062 atsElem->ahParam.startSfbL = 15; 2063 atsElem->ahParam.startSfbS = 3; 2064 } 2065 else { 2066 atsElem->ahParam.modifyMinSnr = FALSE; 2067 atsElem->ahParam.startSfbL = 0; 2068 atsElem->ahParam.startSfbS = 0; 2069 } 2070 2071 /* minSnr adaptation */ 2072 msaParam->maxRed = FL2FXCONST_DBL(0.00390625f); /* 0.25f/64.0f */ 2073 /* start adaptation of minSnr for avgEn/sfbEn > startRatio */ 2074 msaParam->startRatio = FL2FXCONST_DBL(0.05190512648f); /* ld64(10.0f) */ 2075 /* maximum minSnr reduction to minSnr^maxRed is reached for 2076 avgEn/sfbEn >= maxRatio */ 2077 /* msaParam->maxRatio = 1000.0f; */ 2078 /*msaParam->redRatioFac = ((float)1.0f - msaParam->maxRed) / ((float)10.0f*log10(msaParam->startRatio/msaParam->maxRatio)/log10(2.0f)*(float)0.3010299956f);*/ 2079 msaParam->redRatioFac = FL2FXCONST_DBL(-0.375f); /* -0.0375f * 10.0f */ 2080 /*msaParam->redOffs = (float)1.0f - msaParam->redRatioFac * (float)10.0f * log10(msaParam->startRatio)/log10(2.0f) * (float)0.3010299956f;*/ 2081 msaParam->redOffs = FL2FXCONST_DBL(0.021484375); /* 1.375f/64.0f */ 2082 2083 /* init pe correction */ 2084 atsElem->peCorrectionFactor_m = FL2FXCONST_DBL(0.5f); /* 1.0 */ 2085 atsElem->peCorrectionFactor_e = 1; 2086 2087 atsElem->dynBitsLast = -1; 2088 atsElem->peLast = 0; 2089 2090 /* init bits to pe factor */ 2091 atsElem->bits2PeFactor_m = FL2FXCONST_DBL(1.18f/(1<<(1))); 2092 atsElem->bits2PeFactor_e = 1; 2093 } 2094} 2095 2096 2097/***************************************************************************** 2098 functionname: FDKaacEnc_FDKaacEnc_calcPeCorrection 2099 description: calc desired pe 2100*****************************************************************************/ 2101static void FDKaacEnc_FDKaacEnc_calcPeCorrection( 2102 FIXP_DBL *const correctionFac_m, 2103 INT *const correctionFac_e, 2104 const INT peAct, 2105 const INT peLast, 2106 const INT bitsLast, 2107 const FIXP_DBL bits2PeFactor_m, 2108 const INT bits2PeFactor_e 2109 ) 2110{ 2111 if ( (bitsLast > 0) && (peAct < 1.5f*peLast) && (peAct > 0.7f*peLast) && 2112 (FDKaacEnc_bits2pe2(bitsLast, fMult(FL2FXCONST_DBL(1.2f/2.f), bits2PeFactor_m), bits2PeFactor_e+1) > peLast) && 2113 (FDKaacEnc_bits2pe2(bitsLast, fMult(FL2FXCONST_DBL(0.65f), bits2PeFactor_m), bits2PeFactor_e ) < peLast) ) 2114 { 2115 FIXP_DBL corrFac = *correctionFac_m; 2116 2117 int scaling = 0; 2118 FIXP_DBL denum = (FIXP_DBL)FDKaacEnc_bits2pe2(bitsLast, bits2PeFactor_m, bits2PeFactor_e); 2119 FIXP_DBL newFac = fDivNorm((FIXP_DBL)peLast, denum, &scaling); 2120 2121 /* dead zone, newFac and corrFac are scaled by 0.5 */ 2122 if ((FIXP_DBL)peLast <= denum) { /* ratio <= 1.f */ 2123 newFac = fixMax(scaleValue(fixMin( fMult(FL2FXCONST_DBL(1.1f/2.f), newFac), scaleValue(FL2FXCONST_DBL( 1.f/2.f), -scaling)), scaling), FL2FXCONST_DBL(0.85f/2.f) ); 2124 } 2125 else { /* ratio < 1.f */ 2126 newFac = fixMax( fixMin( scaleValue(fMult(FL2FXCONST_DBL(0.9f/2.f), newFac), scaling), FL2FXCONST_DBL(1.15f/2.f) ), FL2FXCONST_DBL( 1.f/2.f) ); 2127 } 2128 2129 if ( ((newFac > FL2FXCONST_DBL(1.f/2.f)) && (corrFac < FL2FXCONST_DBL(1.f/2.f))) 2130 || ((newFac < FL2FXCONST_DBL(1.f/2.f)) && (corrFac > FL2FXCONST_DBL(1.f/2.f)))) 2131 { 2132 corrFac = FL2FXCONST_DBL(1.f/2.f); 2133 } 2134 2135 /* faster adaptation towards 1.0, slower in the other direction */ 2136 if ( (corrFac < FL2FXCONST_DBL(1.f/2.f) && newFac < corrFac) 2137 || (corrFac > FL2FXCONST_DBL(1.f/2.f) && newFac > corrFac) ) 2138 { 2139 corrFac = fMult(FL2FXCONST_DBL(0.85f), corrFac) + fMult(FL2FXCONST_DBL(0.15f), newFac); 2140 } 2141 else { 2142 corrFac = fMult(FL2FXCONST_DBL(0.7f), corrFac) + fMult(FL2FXCONST_DBL(0.3f), newFac); 2143 } 2144 2145 corrFac = fixMax( fixMin( corrFac, FL2FXCONST_DBL(1.15f/2.f) ), FL2FXCONST_DBL(0.85/2.f) ); 2146 2147 *correctionFac_m = corrFac; 2148 *correctionFac_e = 1; 2149 } 2150 else { 2151 *correctionFac_m = FL2FXCONST_DBL(1.f/2.f); 2152 *correctionFac_e = 1; 2153 } 2154} 2155 2156 2157void FDKaacEnc_DistributeBits(ADJ_THR_STATE *adjThrState, 2158 ATS_ELEMENT *AdjThrStateElement, 2159 PSY_OUT_CHANNEL *psyOutChannel[(2)], 2160 PE_DATA *peData, 2161 INT *grantedPe, 2162 INT *grantedPeCorr, 2163 const INT nChannels, 2164 const INT commonWindow, 2165 const INT grantedDynBits, 2166 const INT bitresBits, 2167 const INT maxBitresBits, 2168 const FIXP_DBL maxBitFac, 2169 const INT bitDistributenMode) 2170{ 2171 FIXP_DBL bitFactor; 2172 INT noRedPe = peData->pe; 2173 2174 /* prefer short windows for calculation of bitFactor */ 2175 INT curWindowSequence = LONG_WINDOW; 2176 if (nChannels==2) { 2177 if ((psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW) || 2178 (psyOutChannel[1]->lastWindowSequence == SHORT_WINDOW)) { 2179 curWindowSequence = SHORT_WINDOW; 2180 } 2181 } 2182 else { 2183 curWindowSequence = psyOutChannel[0]->lastWindowSequence; 2184 } 2185 2186 if (grantedDynBits >= 1) { 2187 if (bitDistributenMode!=0) { 2188 *grantedPe = FDKaacEnc_bits2pe2(grantedDynBits, AdjThrStateElement->bits2PeFactor_m, AdjThrStateElement->bits2PeFactor_e); 2189 } 2190 else 2191 { 2192 /* factor dependend on current fill level and pe */ 2193 bitFactor = FDKaacEnc_bitresCalcBitFac(bitresBits, maxBitresBits, noRedPe, 2194 curWindowSequence, grantedDynBits, maxBitFac, 2195 adjThrState, 2196 AdjThrStateElement 2197 ); 2198 2199 /* desired pe for actual frame */ 2200 /* Worst case max of grantedDynBits is = 1024 * 5.27 * 2 */ 2201 *grantedPe = FDKaacEnc_bits2pe2(grantedDynBits, 2202 fMult(bitFactor, AdjThrStateElement->bits2PeFactor_m), AdjThrStateElement->bits2PeFactor_e+(DFRACT_BITS-1-Q_BITFAC) 2203 ); 2204 } 2205 } 2206 else { 2207 *grantedPe = 0; /* prevent divsion by 0 */ 2208 } 2209 2210 /* correction of pe value */ 2211 { 2212 FDKaacEnc_FDKaacEnc_calcPeCorrection( 2213 &AdjThrStateElement->peCorrectionFactor_m, 2214 &AdjThrStateElement->peCorrectionFactor_e, 2215 fixMin(*grantedPe, noRedPe), 2216 AdjThrStateElement->peLast, 2217 AdjThrStateElement->dynBitsLast, 2218 AdjThrStateElement->bits2PeFactor_m, 2219 AdjThrStateElement->bits2PeFactor_e 2220 ); 2221 } 2222 2223 *grantedPeCorr = (INT)(fMult((FIXP_DBL)(*grantedPe<<Q_AVGBITS), AdjThrStateElement->peCorrectionFactor_m) >> (Q_AVGBITS-AdjThrStateElement->peCorrectionFactor_e)); 2224 2225 /* update last pe */ 2226 AdjThrStateElement->peLast = *grantedPe; 2227 AdjThrStateElement->dynBitsLast = -1; 2228 2229} 2230 2231/***************************************************************************** 2232functionname: FDKaacEnc_AdjustThresholds 2233description: adjust thresholds 2234*****************************************************************************/ 2235void FDKaacEnc_AdjustThresholds(ATS_ELEMENT* AdjThrStateElement[(6)], 2236 QC_OUT_ELEMENT* qcElement[(6)], 2237 QC_OUT* qcOut, 2238 PSY_OUT_ELEMENT* psyOutElement[(6)], 2239 INT CBRbitrateMode, 2240 CHANNEL_MAPPING* cm) 2241{ 2242 int i; 2243 if (CBRbitrateMode) 2244 { 2245 /* In case, no bits must be shifted between different elements, */ 2246 /* an element-wise execution of the pe-dependent threshold- */ 2247 /* adaption becomes necessary... */ 2248 for (i=0; i<cm->nElements; i++) 2249 { 2250 ELEMENT_INFO elInfo = cm->elInfo[i]; 2251 2252 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) || 2253 (elInfo.elType == ID_LFE)) 2254 { 2255 /* qcElement[i]->grantedPe = 2000; */ /* Use this only for debugging */ 2256 //if (totalGrantedPeCorr < totalNoRedPe) { 2257 if (qcElement[i]->grantedPe < qcElement[i]->peData.pe) 2258 { 2259 /* calc threshold necessary for desired pe */ 2260 FDKaacEnc_adaptThresholdsToPe(cm, 2261 AdjThrStateElement, 2262 qcElement, 2263 psyOutElement, 2264 qcElement[i]->grantedPeCorr, 2265 1, /* Process only 1 element */ 2266 i); /* Process exactly THIS element */ 2267 2268 } 2269 2270 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */ 2271 2272 } /* -end- element loop */ 2273 } 2274 else { 2275 for (i=0; i<cm->nElements; i++) 2276 { 2277 ELEMENT_INFO elInfo = cm->elInfo[i]; 2278 2279 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) || 2280 (elInfo.elType == ID_LFE)) 2281 { 2282 /* for VBR-mode */ 2283 FDKaacEnc_AdaptThresholdsVBR(qcElement[i]->qcOutChannel, 2284 psyOutElement[i]->psyOutChannel, 2285 AdjThrStateElement[i], 2286 &psyOutElement[i]->toolsInfo, 2287 &qcElement[i]->peData, 2288 cm->elInfo[i].nChannelsInEl); 2289 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */ 2290 2291 } /* -end- element loop */ 2292 2293 } 2294 for (i=0; i<cm->nElements; i++) { 2295 int ch,sfb,sfbGrp; 2296 /* no weighting of threholds and energies for mlout */ 2297 /* weight energies and thresholds */ 2298 for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) { 2299 QC_OUT_CHANNEL* pQcOutCh = qcElement[i]->qcOutChannel[ch]; 2300 for (sfbGrp = 0;sfbGrp < psyOutElement[i]->psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutElement[i]->psyOutChannel[ch]->sfbPerGroup) { 2301 for (sfb=0; sfb<psyOutElement[i]->psyOutChannel[ch]->maxSfbPerGroup; sfb++) { 2302 pQcOutCh->sfbThresholdLdData[sfb+sfbGrp] += pQcOutCh->sfbEnFacLd[sfb+sfbGrp]; 2303 } 2304 } 2305 } 2306 } 2307 2308} 2309 2310void FDKaacEnc_AdjThrClose(ADJ_THR_STATE** phAdjThr) 2311{ 2312 INT i; 2313 ADJ_THR_STATE* hAdjThr = *phAdjThr; 2314 2315 if (hAdjThr!=NULL) { 2316 for (i=0; i<(6); i++) { 2317 if (hAdjThr->adjThrStateElem[i]!=NULL) { 2318 FreeRam_aacEnc_AdjThrStateElement(&hAdjThr->adjThrStateElem[i]); 2319 } 2320 } 2321 FreeRam_aacEnc_AdjustThreshold(phAdjThr); 2322 } 2323} 2324 2325