1 /* ----------------------------------------------------------------------------- 2 Software License for The Fraunhofer FDK AAC Codec Library for Android 3 4 Copyright 1995 - 2019 Fraunhofer-Gesellschaft zur Frderung der angewandten 5 Forschung e.V. All rights reserved. 6 7 1. INTRODUCTION 8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software 9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding 10 scheme for digital audio. This FDK AAC Codec software is intended to be used on 11 a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient 14 general perceptual audio codecs. AAC-ELD is considered the best-performing 15 full-bandwidth communications codec by independent studies and is widely 16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG 17 specifications. 18 19 Patent licenses for necessary patent claims for the FDK AAC Codec (including 20 those of Fraunhofer) may be obtained through Via Licensing 21 (www.vialicensing.com) or through the respective patent owners individually for 22 the purpose of encoding or decoding bit streams in products that are compliant 23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of 24 Android devices already license these patent claims through Via Licensing or 25 directly from the patent owners, and therefore FDK AAC Codec software may 26 already be covered under those patent licenses when it is used for those 27 licensed purposes only. 28 29 Commercially-licensed AAC software libraries, including floating-point versions 30 with enhanced sound quality, are also available from Fraunhofer. Users are 31 encouraged to check the Fraunhofer website for additional applications 32 information and documentation. 33 34 2. COPYRIGHT LICENSE 35 36 Redistribution and use in source and binary forms, with or without modification, 37 are permitted without payment of copyright license fees provided that you 38 satisfy the following conditions: 39 40 You must retain the complete text of this software license in redistributions of 41 the FDK AAC Codec or your modifications thereto in source code form. 42 43 You must retain the complete text of this software license in the documentation 44 and/or other materials provided with redistributions of the FDK AAC Codec or 45 your modifications thereto in binary form. You must make available free of 46 charge copies of the complete source code of the FDK AAC Codec and your 47 modifications thereto to recipients of copies in binary form. 48 49 The name of Fraunhofer may not be used to endorse or promote products derived 50 from this library without prior written permission. 51 52 You may not charge copyright license fees for anyone to use, copy or distribute 53 the FDK AAC Codec software or your modifications thereto. 54 55 Your modified versions of the FDK AAC Codec must carry prominent notices stating 56 that you changed the software and the date of any change. For modified versions 57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" 58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK 59 AAC Codec Library for Android." 60 61 3. NO PATENT LICENSE 62 63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without 64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. 65 Fraunhofer provides no warranty of patent non-infringement with respect to this 66 software. 67 68 You may use this FDK AAC Codec software or modifications thereto only for 69 purposes that are authorized by appropriate patent licenses. 70 71 4. DISCLAIMER 72 73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright 74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, 75 including but not limited to the implied warranties of merchantability and 76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, 78 or consequential damages, including but not limited to procurement of substitute 79 goods or services; loss of use, data, or profits, or business interruption, 80 however caused and on any theory of liability, whether in contract, strict 81 liability, or tort (including negligence), arising in any way out of the use of 82 this software, even if advised of the possibility of such damage. 83 84 5. CONTACT INFORMATION 85 86 Fraunhofer Institute for Integrated Circuits IIS 87 Attention: Audio and Multimedia Departments - FDK AAC LL 88 Am Wolfsmantel 33 89 91058 Erlangen, Germany 90 91 www.iis.fraunhofer.de/amm 92 amm-info (at) iis.fraunhofer.de 93 ----------------------------------------------------------------------------- */ 94 95 /**************************** AAC encoder library ****************************** 96 97 Author(s): A. Horndasch (code originally from lwr) / Josef Hoepfl (FDK) 98 99 Description: intensity stereo processing 100 101 *******************************************************************************/ 102 103 #include "intensity.h" 104 105 #include "interface.h" 106 #include "psy_configuration.h" 107 #include "psy_const.h" 108 #include "qc_main.h" 109 #include "bit_cnt.h" 110 111 /* only set an IS seed it left/right channel correlation is above IS_CORR_THRESH 112 */ 113 #define IS_CORR_THRESH FL2FXCONST_DBL(0.95f) 114 115 /* when expanding the IS region to more SFBs only accept an error that is 116 * not more than IS_TOTAL_ERROR_THRESH overall and 117 * not more than IS_LOCAL_ERROR_THRESH for the current SFB */ 118 #define IS_TOTAL_ERROR_THRESH FL2FXCONST_DBL(0.04f) 119 #define IS_LOCAL_ERROR_THRESH FL2FXCONST_DBL(0.01f) 120 121 /* the maximum allowed change of the intensity direction (unit: IS scale) - 122 * scaled with factor 0.25 - */ 123 #define IS_DIRECTION_DEVIATION_THRESH_SF 2 124 #define IS_DIRECTION_DEVIATION_THRESH \ 125 FL2FXCONST_DBL(2.0f / (1 << IS_DIRECTION_DEVIATION_THRESH_SF)) 126 127 /* IS regions need to have a minimal percentage of the overall loudness, e.g. 128 * 0.06 == 6% */ 129 #define IS_REGION_MIN_LOUDNESS FL2FXCONST_DBL(0.1f) 130 131 /* only perform IS if IS_MIN_SFBS neighboring SFBs can be processed */ 132 #define IS_MIN_SFBS 6 133 134 /* only do IS if 135 * if IS_LEFT_RIGHT_RATIO_THRESH < sfbEnergyLeft[sfb]/sfbEnergyRight[sfb] < 1 / 136 * IS_LEFT_RIGHT_RATIO_THRESH 137 * -> no IS if the panning angle is not far from the middle, MS will do */ 138 /* this is equivalent to a scale of +/-1.02914634566 */ 139 #define IS_LEFT_RIGHT_RATIO_THRESH FL2FXCONST_DBL(0.7f) 140 141 /* scalefactor of realScale */ 142 #define REAL_SCALE_SF 1 143 144 /* scalefactor overallLoudness */ 145 #define OVERALL_LOUDNESS_SF 6 146 147 /* scalefactor for sum over max samples per goup */ 148 #define MAX_SFB_PER_GROUP_SF 6 149 150 /* scalefactor for sum of mdct spectrum */ 151 #define MDCT_SPEC_SF 6 152 153 typedef struct { 154 FIXP_DBL corr_thresh; /*!< Only set an IS seed it left/right channel 155 correlation is above corr_thresh */ 156 157 FIXP_DBL total_error_thresh; /*!< When expanding the IS region to more SFBs 158 only accept an error that is not more than 159 'total_error_thresh' overall. */ 160 161 FIXP_DBL local_error_thresh; /*!< When expanding the IS region to more SFBs 162 only accept an error that is not more than 163 'local_error_thresh' for the current SFB. */ 164 165 FIXP_DBL direction_deviation_thresh; /*!< The maximum allowed change of the 166 intensity direction (unit: IS scale) 167 */ 168 169 FIXP_DBL is_region_min_loudness; /*!< IS regions need to have a minimal 170 percentage of the overall loudness, e.g. 171 0.06 == 6% */ 172 173 INT min_is_sfbs; /*!< Only perform IS if 'min_is_sfbs' neighboring SFBs can be 174 processed */ 175 176 FIXP_DBL left_right_ratio_threshold; /*!< No IS if the panning angle is not 177 far from the middle, MS will do */ 178 179 } INTENSITY_PARAMETERS; 180 181 /***************************************************************************** 182 183 functionname: calcSfbMaxScale 184 185 description: Calc max value in scalefactor band 186 187 input: *mdctSpectrum 188 l1 189 l2 190 191 output: none 192 193 returns: scalefactor 194 195 *****************************************************************************/ 196 static INT calcSfbMaxScale(const FIXP_DBL *mdctSpectrum, const INT l1, 197 const INT l2) { 198 INT i; 199 INT sfbMaxScale; 200 FIXP_DBL maxSpc; 201 202 maxSpc = FL2FXCONST_DBL(0.0); 203 for (i = l1; i < l2; i++) { 204 FIXP_DBL tmp = fixp_abs((FIXP_DBL)mdctSpectrum[i]); 205 maxSpc = fixMax(maxSpc, tmp); 206 } 207 sfbMaxScale = (maxSpc == FL2FXCONST_DBL(0.0)) ? (DFRACT_BITS - 2) 208 : CntLeadingZeros(maxSpc) - 1; 209 210 return sfbMaxScale; 211 } 212 213 /***************************************************************************** 214 215 functionname: FDKaacEnc_initIsParams 216 217 description: Initialization of intensity parameters 218 219 input: isParams 220 221 output: isParams 222 223 returns: none 224 225 *****************************************************************************/ 226 static void FDKaacEnc_initIsParams(INTENSITY_PARAMETERS *isParams) { 227 isParams->corr_thresh = IS_CORR_THRESH; 228 isParams->total_error_thresh = IS_TOTAL_ERROR_THRESH; 229 isParams->local_error_thresh = IS_LOCAL_ERROR_THRESH; 230 isParams->direction_deviation_thresh = IS_DIRECTION_DEVIATION_THRESH; 231 isParams->is_region_min_loudness = IS_REGION_MIN_LOUDNESS; 232 isParams->min_is_sfbs = IS_MIN_SFBS; 233 isParams->left_right_ratio_threshold = IS_LEFT_RIGHT_RATIO_THRESH; 234 } 235 236 /***************************************************************************** 237 238 functionname: FDKaacEnc_prepareIntensityDecision 239 240 description: Prepares intensity decision 241 242 input: sfbEnergyLeft 243 sfbEnergyRight 244 sfbEnergyLdDataLeft 245 sfbEnergyLdDataRight 246 mdctSpectrumLeft 247 sfbEnergyLdDataRight 248 isParams 249 250 output: hrrErr scale: none 251 isMask scale: none 252 realScale scale: LD_DATA_SHIFT + REAL_SCALE_SF 253 normSfbLoudness scale: none 254 255 returns: none 256 257 *****************************************************************************/ 258 static void FDKaacEnc_prepareIntensityDecision( 259 const FIXP_DBL *sfbEnergyLeft, const FIXP_DBL *sfbEnergyRight, 260 const FIXP_DBL *sfbEnergyLdDataLeft, const FIXP_DBL *sfbEnergyLdDataRight, 261 const FIXP_DBL *mdctSpectrumLeft, const FIXP_DBL *mdctSpectrumRight, 262 const INTENSITY_PARAMETERS *isParams, FIXP_DBL *hrrErr, INT *isMask, 263 FIXP_DBL *realScale, FIXP_DBL *normSfbLoudness, const INT sfbCnt, 264 const INT sfbPerGroup, const INT maxSfbPerGroup, const INT *sfbOffset) { 265 INT j, sfb, sfboffs; 266 INT grpCounter; 267 268 /* temporary variables to compute loudness */ 269 FIXP_DBL overallLoudness[MAX_NO_OF_GROUPS]; 270 271 /* temporary variables to compute correlation */ 272 FIXP_DBL channelCorr[MAX_GROUPED_SFB]; 273 FIXP_DBL ml, mr; 274 FIXP_DBL prod_lr; 275 FIXP_DBL square_l, square_r; 276 FIXP_DBL tmp_l, tmp_r; 277 FIXP_DBL inv_n; 278 279 FDKmemclear(channelCorr, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); 280 FDKmemclear(normSfbLoudness, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); 281 FDKmemclear(overallLoudness, MAX_NO_OF_GROUPS * sizeof(FIXP_DBL)); 282 FDKmemclear(realScale, MAX_GROUPED_SFB * sizeof(FIXP_DBL)); 283 284 for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; 285 sfboffs += sfbPerGroup, grpCounter++) { 286 overallLoudness[grpCounter] = FL2FXCONST_DBL(0.0f); 287 for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { 288 INT sL, sR, s; 289 FIXP_DBL isValue = sfbEnergyLdDataLeft[sfb + sfboffs] - 290 sfbEnergyLdDataRight[sfb + sfboffs]; 291 292 /* delimitate intensity scale value to representable range */ 293 realScale[sfb + sfboffs] = fixMin( 294 FL2FXCONST_DBL(60.f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT))), 295 fixMax(FL2FXCONST_DBL(-60.f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT))), 296 isValue)); 297 298 sL = fixMax(0, (CntLeadingZeros(sfbEnergyLeft[sfb + sfboffs]) - 1)); 299 sR = fixMax(0, (CntLeadingZeros(sfbEnergyRight[sfb + sfboffs]) - 1)); 300 s = (fixMin(sL, sR) >> 2) << 2; 301 normSfbLoudness[sfb + sfboffs] = 302 sqrtFixp(sqrtFixp(((sfbEnergyLeft[sfb + sfboffs] << s) >> 1) + 303 ((sfbEnergyRight[sfb + sfboffs] << s) >> 1))) >> 304 (s >> 2); 305 306 overallLoudness[grpCounter] += 307 normSfbLoudness[sfb + sfboffs] >> OVERALL_LOUDNESS_SF; 308 /* don't do intensity if 309 * - panning angle is too close to the middle or 310 * - one channel is non-existent or 311 * - if it is dual mono */ 312 if ((sfbEnergyLeft[sfb + sfboffs] >= 313 fMult(isParams->left_right_ratio_threshold, 314 sfbEnergyRight[sfb + sfboffs])) && 315 (fMult(isParams->left_right_ratio_threshold, 316 sfbEnergyLeft[sfb + sfboffs]) <= 317 sfbEnergyRight[sfb + sfboffs])) { 318 /* this will prevent post processing from considering this SFB for 319 * merging */ 320 hrrErr[sfb + sfboffs] = FL2FXCONST_DBL(1.0 / 8.0); 321 } 322 } 323 } 324 325 for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; 326 sfboffs += sfbPerGroup, grpCounter++) { 327 INT invOverallLoudnessSF; 328 FIXP_DBL invOverallLoudness; 329 330 if (overallLoudness[grpCounter] == FL2FXCONST_DBL(0.0)) { 331 invOverallLoudness = FL2FXCONST_DBL(0.0); 332 invOverallLoudnessSF = 0; 333 } else { 334 invOverallLoudness = 335 fDivNorm((FIXP_DBL)MAXVAL_DBL, overallLoudness[grpCounter], 336 &invOverallLoudnessSF); 337 invOverallLoudnessSF = 338 invOverallLoudnessSF - OVERALL_LOUDNESS_SF + 339 1; /* +1: compensate fMultDiv2() in subsequent loop */ 340 } 341 invOverallLoudnessSF = fixMin( 342 fixMax(invOverallLoudnessSF, -(DFRACT_BITS - 1)), DFRACT_BITS - 1); 343 344 for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { 345 FIXP_DBL tmp; 346 347 tmp = fMultDiv2((normSfbLoudness[sfb + sfboffs] >> OVERALL_LOUDNESS_SF) 348 << OVERALL_LOUDNESS_SF, 349 invOverallLoudness); 350 351 normSfbLoudness[sfb + sfboffs] = scaleValue(tmp, invOverallLoudnessSF); 352 353 channelCorr[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); 354 355 /* max width of scalefactorband is 96; width's are always even */ 356 /* inv_n is scaled with factor 2 to compensate fMultDiv2() in subsequent 357 * loops */ 358 inv_n = GetInvInt( 359 (sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs]) >> 1); 360 361 if (inv_n > FL2FXCONST_DBL(0.0f)) { 362 INT s, sL, sR; 363 364 /* correlation := Pearson's product-moment coefficient */ 365 /* compute correlation between channels and check if it is over 366 * threshold */ 367 ml = FL2FXCONST_DBL(0.0f); 368 mr = FL2FXCONST_DBL(0.0f); 369 prod_lr = FL2FXCONST_DBL(0.0f); 370 square_l = FL2FXCONST_DBL(0.0f); 371 square_r = FL2FXCONST_DBL(0.0f); 372 373 sL = calcSfbMaxScale(mdctSpectrumLeft, sfbOffset[sfb + sfboffs], 374 sfbOffset[sfb + sfboffs + 1]); 375 sR = calcSfbMaxScale(mdctSpectrumRight, sfbOffset[sfb + sfboffs], 376 sfbOffset[sfb + sfboffs + 1]); 377 s = fixMin(sL, sR); 378 379 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 380 j++) { 381 ml += fMultDiv2((mdctSpectrumLeft[j] << s), 382 inv_n); // scaled with mdctScale - s + inv_n 383 mr += fMultDiv2((mdctSpectrumRight[j] << s), 384 inv_n); // scaled with mdctScale - s + inv_n 385 } 386 ml = fMultDiv2(ml, inv_n); // scaled with mdctScale - s + inv_n 387 mr = fMultDiv2(mr, inv_n); // scaled with mdctScale - s + inv_n 388 389 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 390 j++) { 391 tmp_l = fMultDiv2((mdctSpectrumLeft[j] << s), inv_n) - 392 ml; // scaled with mdctScale - s + inv_n 393 tmp_r = fMultDiv2((mdctSpectrumRight[j] << s), inv_n) - 394 mr; // scaled with mdctScale - s + inv_n 395 396 prod_lr += fMultDiv2( 397 tmp_l, tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1 398 square_l += 399 fPow2Div2(tmp_l); // scaled with 2*(mdctScale - s + inv_n) + 1 400 square_r += 401 fPow2Div2(tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1 402 } 403 prod_lr = prod_lr << 1; // scaled with 2*(mdctScale - s + inv_n) 404 square_l = square_l << 1; // scaled with 2*(mdctScale - s + inv_n) 405 square_r = square_r << 1; // scaled with 2*(mdctScale - s + inv_n) 406 407 if (square_l > FL2FXCONST_DBL(0.0f) && 408 square_r > FL2FXCONST_DBL(0.0f)) { 409 INT channelCorrSF = 0; 410 411 /* local scaling of square_l and square_r is compensated after sqrt 412 * calculation */ 413 sL = fixMax(0, (CntLeadingZeros(square_l) - 1)); 414 sR = fixMax(0, (CntLeadingZeros(square_r) - 1)); 415 s = ((sL + sR) >> 1) << 1; 416 sL = fixMin(sL, s); 417 sR = s - sL; 418 tmp = fMult(square_l << sL, square_r << sR); 419 tmp = sqrtFixp(tmp); 420 421 FDK_ASSERT(tmp > FL2FXCONST_DBL(0.0f)); 422 423 /* numerator and denominator have the same scaling */ 424 if (prod_lr < FL2FXCONST_DBL(0.0f)) { 425 channelCorr[sfb + sfboffs] = 426 -(fDivNorm(-prod_lr, tmp, &channelCorrSF)); 427 428 } else { 429 channelCorr[sfb + sfboffs] = 430 (fDivNorm(prod_lr, tmp, &channelCorrSF)); 431 } 432 channelCorrSF = fixMin( 433 fixMax((channelCorrSF + ((sL + sR) >> 1)), -(DFRACT_BITS - 1)), 434 DFRACT_BITS - 1); 435 436 if (channelCorrSF < 0) { 437 channelCorr[sfb + sfboffs] = 438 channelCorr[sfb + sfboffs] >> (-channelCorrSF); 439 } else { 440 /* avoid overflows due to limited computational accuracy */ 441 if (fAbs(channelCorr[sfb + sfboffs]) > 442 (((FIXP_DBL)MAXVAL_DBL) >> channelCorrSF)) { 443 if (channelCorr[sfb + sfboffs] < FL2FXCONST_DBL(0.0f)) 444 channelCorr[sfb + sfboffs] = -(FIXP_DBL)MAXVAL_DBL; 445 else 446 channelCorr[sfb + sfboffs] = (FIXP_DBL)MAXVAL_DBL; 447 } else { 448 channelCorr[sfb + sfboffs] = channelCorr[sfb + sfboffs] 449 << channelCorrSF; 450 } 451 } 452 } 453 } 454 455 /* for post processing: hrrErr is the error in terms of (too little) 456 * correlation weighted with the loudness of the SFB; SFBs with small 457 * hrrErr can be merged */ 458 if (hrrErr[sfb + sfboffs] == FL2FXCONST_DBL(1.0 / 8.0)) { 459 continue; 460 } 461 462 hrrErr[sfb + sfboffs] = 463 fMultDiv2((FL2FXCONST_DBL(0.25f) - (channelCorr[sfb + sfboffs] >> 2)), 464 normSfbLoudness[sfb + sfboffs]); 465 466 /* set IS mask/vector to 1, if correlation is high enough */ 467 if (fAbs(channelCorr[sfb + sfboffs]) >= isParams->corr_thresh) { 468 isMask[sfb + sfboffs] = 1; 469 } 470 } 471 } 472 } 473 474 /***************************************************************************** 475 476 functionname: FDKaacEnc_finalizeIntensityDecision 477 478 description: Finalizes intensity decision 479 480 input: isParams scale: none 481 hrrErr scale: none 482 realIsScale scale: LD_DATA_SHIFT + REAL_SCALE_SF 483 normSfbLoudness scale: none 484 485 output: isMask scale: none 486 487 returns: none 488 489 *****************************************************************************/ 490 static void FDKaacEnc_finalizeIntensityDecision( 491 const FIXP_DBL *hrrErr, INT *isMask, const FIXP_DBL *realIsScale, 492 const FIXP_DBL *normSfbLoudness, const INTENSITY_PARAMETERS *isParams, 493 const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup) { 494 INT sfb, sfboffs, j; 495 FIXP_DBL isScaleLast = FL2FXCONST_DBL(0.0f); 496 INT isStartValueFound = 0; 497 498 for (sfboffs = 0; sfboffs < sfbCnt; sfboffs += sfbPerGroup) { 499 INT startIsSfb = 0; 500 INT inIsBlock = 0; 501 INT currentIsSfbCount = 0; 502 FIXP_DBL overallHrrError = FL2FXCONST_DBL(0.0f); 503 FIXP_DBL isRegionLoudness = FL2FXCONST_DBL(0.0f); 504 505 for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { 506 if (isMask[sfboffs + sfb] == 1) { 507 if (currentIsSfbCount == 0) { 508 startIsSfb = sfboffs + sfb; 509 } 510 if (isStartValueFound == 0) { 511 isScaleLast = realIsScale[sfboffs + sfb]; 512 isStartValueFound = 1; 513 } 514 inIsBlock = 1; 515 currentIsSfbCount++; 516 overallHrrError += hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF - 3); 517 isRegionLoudness += 518 normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF; 519 } else { 520 /* based on correlation, IS should not be used 521 * -> use it anyway, if overall error is below threshold 522 * and if local error does not exceed threshold 523 * otherwise: check if there are enough IS SFBs 524 */ 525 if (inIsBlock) { 526 overallHrrError += 527 hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF - 3); 528 isRegionLoudness += 529 normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF; 530 531 if ((hrrErr[sfboffs + sfb] < (isParams->local_error_thresh >> 3)) && 532 (overallHrrError < 533 (isParams->total_error_thresh >> MAX_SFB_PER_GROUP_SF))) { 534 currentIsSfbCount++; 535 /* overwrite correlation based decision */ 536 isMask[sfboffs + sfb] = 1; 537 } else { 538 inIsBlock = 0; 539 } 540 } 541 } 542 /* check for large direction deviation */ 543 if (inIsBlock) { 544 if (fAbs(isScaleLast - realIsScale[sfboffs + sfb]) < 545 (isParams->direction_deviation_thresh >> 546 (REAL_SCALE_SF + LD_DATA_SHIFT - 547 IS_DIRECTION_DEVIATION_THRESH_SF))) { 548 isScaleLast = realIsScale[sfboffs + sfb]; 549 } else { 550 isMask[sfboffs + sfb] = 0; 551 inIsBlock = 0; 552 currentIsSfbCount--; 553 } 554 } 555 556 if (currentIsSfbCount > 0 && (!inIsBlock || sfb == maxSfbPerGroup - 1)) { 557 /* not enough SFBs -> do not use IS */ 558 if (currentIsSfbCount < isParams->min_is_sfbs || 559 (isRegionLoudness<isParams->is_region_min_loudness>> 560 MAX_SFB_PER_GROUP_SF)) { 561 for (j = startIsSfb; j <= sfboffs + sfb; j++) { 562 isMask[j] = 0; 563 } 564 isScaleLast = FL2FXCONST_DBL(0.0f); 565 isStartValueFound = 0; 566 for (j = 0; j < startIsSfb; j++) { 567 if (isMask[j] != 0) { 568 isScaleLast = realIsScale[j]; 569 isStartValueFound = 1; 570 } 571 } 572 } 573 currentIsSfbCount = 0; 574 overallHrrError = FL2FXCONST_DBL(0.0f); 575 isRegionLoudness = FL2FXCONST_DBL(0.0f); 576 } 577 } 578 } 579 } 580 581 /***************************************************************************** 582 583 functionname: FDKaacEnc_IntensityStereoProcessing 584 585 description: Intensity stereo processing tool 586 587 input: sfbEnergyLeft 588 sfbEnergyRight 589 mdctSpectrumLeft 590 mdctSpectrumRight 591 sfbThresholdLeft 592 sfbThresholdRight 593 sfbSpreadEnLeft 594 sfbSpreadEnRight 595 sfbEnergyLdDataLeft 596 sfbEnergyLdDataRight 597 598 output: isBook 599 isScale 600 pnsData->pnsFlag 601 msDigest zeroed from start to sfbCnt 602 msMask zeroed from start to sfbCnt 603 mdctSpectrumRight zeroed where isBook!=0 604 sfbEnergyRight zeroed where isBook!=0 605 sfbSpreadEnRight zeroed where isBook!=0 606 sfbThresholdRight zeroed where isBook!=0 607 sfbEnergyLdDataRight FL2FXCONST_DBL(-1.0) where isBook!=0 608 sfbThresholdLdDataRight FL2FXCONST_DBL(-0.515625f) where 609 isBook!=0 610 611 returns: none 612 613 *****************************************************************************/ 614 void FDKaacEnc_IntensityStereoProcessing( 615 FIXP_DBL *sfbEnergyLeft, FIXP_DBL *sfbEnergyRight, 616 FIXP_DBL *mdctSpectrumLeft, FIXP_DBL *mdctSpectrumRight, 617 FIXP_DBL *sfbThresholdLeft, FIXP_DBL *sfbThresholdRight, 618 FIXP_DBL *sfbThresholdLdDataRight, FIXP_DBL *sfbSpreadEnLeft, 619 FIXP_DBL *sfbSpreadEnRight, FIXP_DBL *sfbEnergyLdDataLeft, 620 FIXP_DBL *sfbEnergyLdDataRight, INT *msDigest, INT *msMask, 621 const INT sfbCnt, const INT sfbPerGroup, const INT maxSfbPerGroup, 622 const INT *sfbOffset, const INT allowIS, INT *isBook, INT *isScale, 623 PNS_DATA *RESTRICT pnsData[2]) { 624 INT sfb, sfboffs, j; 625 FIXP_DBL scale; 626 FIXP_DBL lr; 627 FIXP_DBL hrrErr[MAX_GROUPED_SFB]; 628 FIXP_DBL normSfbLoudness[MAX_GROUPED_SFB]; 629 FIXP_DBL realIsScale[MAX_GROUPED_SFB]; 630 INTENSITY_PARAMETERS isParams; 631 INT isMask[MAX_GROUPED_SFB]; 632 633 FDKmemclear((void *)isBook, sfbCnt * sizeof(INT)); 634 FDKmemclear((void *)isMask, sfbCnt * sizeof(INT)); 635 FDKmemclear((void *)realIsScale, sfbCnt * sizeof(FIXP_DBL)); 636 FDKmemclear((void *)isScale, sfbCnt * sizeof(INT)); 637 FDKmemclear((void *)hrrErr, sfbCnt * sizeof(FIXP_DBL)); 638 639 if (!allowIS) return; 640 641 FDKaacEnc_initIsParams(&isParams); 642 643 /* compute / set the following values per SFB: 644 * - left/right ratio between channels 645 * - normalized loudness 646 * + loudness == average of energy in channels to 0.25 647 * + normalization: division by sum of all SFB loudnesses 648 * - isMask (is set to 0 if channels are the same or one is 0) 649 */ 650 FDKaacEnc_prepareIntensityDecision( 651 sfbEnergyLeft, sfbEnergyRight, sfbEnergyLdDataLeft, sfbEnergyLdDataRight, 652 mdctSpectrumLeft, mdctSpectrumRight, &isParams, hrrErr, isMask, 653 realIsScale, normSfbLoudness, sfbCnt, sfbPerGroup, maxSfbPerGroup, 654 sfbOffset); 655 656 FDKaacEnc_finalizeIntensityDecision(hrrErr, isMask, realIsScale, 657 normSfbLoudness, &isParams, sfbCnt, 658 sfbPerGroup, maxSfbPerGroup); 659 660 for (sfb = 0; sfb < sfbCnt; sfb += sfbPerGroup) { 661 for (sfboffs = 0; sfboffs < maxSfbPerGroup; sfboffs++) { 662 INT sL, sR; 663 FIXP_DBL inv_n; 664 INT mdct_spec_sf = MDCT_SPEC_SF; 665 666 msMask[sfb + sfboffs] = 0; 667 if (isMask[sfb + sfboffs] == 0) { 668 continue; 669 } 670 671 if ((sfbEnergyLeft[sfb + sfboffs] < sfbThresholdLeft[sfb + sfboffs]) && 672 (fMult(FL2FXCONST_DBL(1.0f / 1.5f), sfbEnergyRight[sfb + sfboffs]) > 673 sfbThresholdRight[sfb + sfboffs])) { 674 continue; 675 } 676 /* NEW: if there is a big-enough IS region, switch off PNS */ 677 if (pnsData[0]) { 678 if (pnsData[0]->pnsFlag[sfb + sfboffs]) { 679 pnsData[0]->pnsFlag[sfb + sfboffs] = 0; 680 } 681 if (pnsData[1]->pnsFlag[sfb + sfboffs]) { 682 pnsData[1]->pnsFlag[sfb + sfboffs] = 0; 683 } 684 } 685 686 if (sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs] > 687 1 << mdct_spec_sf) { 688 mdct_spec_sf++; /* This is for rare cases where the number of bins in a 689 scale factor band is > 64 */ 690 } 691 692 inv_n = GetInvInt( 693 (sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs]) >> 694 1); // scaled with 2 to compensate fMultDiv2() in subsequent loop 695 sL = calcSfbMaxScale(mdctSpectrumLeft, sfbOffset[sfb + sfboffs], 696 sfbOffset[sfb + sfboffs + 1]); 697 sR = calcSfbMaxScale(mdctSpectrumRight, sfbOffset[sfb + sfboffs], 698 sfbOffset[sfb + sfboffs + 1]); 699 700 lr = FL2FXCONST_DBL(0.0f); 701 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; j++) 702 lr += fMultDiv2( 703 fMultDiv2(mdctSpectrumLeft[j] << sL, mdctSpectrumRight[j] << sR), 704 inv_n); 705 lr = lr << 1; 706 707 if (lr < FL2FXCONST_DBL(0.0f)) { 708 /* This means OUT OF phase intensity stereo, cf. standard */ 709 INT s0, s1, s2; 710 FIXP_DBL tmp, d, ed = FL2FXCONST_DBL(0.0f); 711 712 s0 = fixMin(sL, sR); 713 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 714 j++) { 715 d = ((mdctSpectrumLeft[j] << s0) >> 1) - 716 ((mdctSpectrumRight[j] << s0) >> 1); 717 ed += fMultDiv2(d, d) >> (mdct_spec_sf - 1); 718 } 719 msMask[sfb + sfboffs] = 1; 720 tmp = fDivNorm(sfbEnergyLeft[sfb + sfboffs], ed, &s1); 721 s2 = (s1) + (2 * s0) - 2 - mdct_spec_sf; 722 if (s2 & 1) { 723 tmp = tmp >> 1; 724 s2 = s2 + 1; 725 } 726 s2 = (s2 >> 1) + 1; // +1 compensate fMultDiv2() in subsequent loop 727 s2 = fixMin(fixMax(s2, -(DFRACT_BITS - 1)), (DFRACT_BITS - 1)); 728 scale = sqrtFixp(tmp); 729 if (s2 < 0) { 730 s2 = -s2; 731 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 732 j++) { 733 mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) - 734 fMultDiv2(mdctSpectrumRight[j], scale)) >> 735 s2; 736 mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); 737 } 738 } else { 739 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 740 j++) { 741 mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) - 742 fMultDiv2(mdctSpectrumRight[j], scale)) 743 << s2; 744 mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); 745 } 746 } 747 } else { 748 /* This means IN phase intensity stereo, cf. standard */ 749 INT s0, s1, s2; 750 FIXP_DBL tmp, s, es = FL2FXCONST_DBL(0.0f); 751 752 s0 = fixMin(sL, sR); 753 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 754 j++) { 755 s = ((mdctSpectrumLeft[j] << s0) >> 1) + 756 ((mdctSpectrumRight[j] << s0) >> 1); 757 es += fMultDiv2(s, s) >> 758 (mdct_spec_sf - 759 1); // scaled 2*(mdctScale - s0 + 1) + mdct_spec_sf 760 } 761 msMask[sfb + sfboffs] = 0; 762 tmp = fDivNorm(sfbEnergyLeft[sfb + sfboffs], es, &s1); 763 s2 = (s1) + (2 * s0) - 2 - mdct_spec_sf; 764 if (s2 & 1) { 765 tmp = tmp >> 1; 766 s2 = s2 + 1; 767 } 768 s2 = (s2 >> 1) + 1; // +1 compensate fMultDiv2() in subsequent loop 769 s2 = fixMin(fixMax(s2, -(DFRACT_BITS - 1)), (DFRACT_BITS - 1)); 770 scale = sqrtFixp(tmp); 771 if (s2 < 0) { 772 s2 = -s2; 773 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 774 j++) { 775 mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) + 776 fMultDiv2(mdctSpectrumRight[j], scale)) >> 777 s2; 778 mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); 779 } 780 } else { 781 for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; 782 j++) { 783 mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j], scale) + 784 fMultDiv2(mdctSpectrumRight[j], scale)) 785 << s2; 786 mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f); 787 } 788 } 789 } 790 791 isBook[sfb + sfboffs] = CODE_BOOK_IS_IN_PHASE_NO; 792 793 if (realIsScale[sfb + sfboffs] < FL2FXCONST_DBL(0.0f)) { 794 isScale[sfb + sfboffs] = 795 (INT)(((realIsScale[sfb + sfboffs] >> 1) - 796 FL2FXCONST_DBL( 797 0.5f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT + 1)))) >> 798 (DFRACT_BITS - 1 - REAL_SCALE_SF - LD_DATA_SHIFT - 1)) + 799 1; 800 } else { 801 isScale[sfb + sfboffs] = 802 (INT)(((realIsScale[sfb + sfboffs] >> 1) + 803 FL2FXCONST_DBL( 804 0.5f / (1 << (REAL_SCALE_SF + LD_DATA_SHIFT + 1)))) >> 805 (DFRACT_BITS - 1 - REAL_SCALE_SF - LD_DATA_SHIFT - 1)); 806 } 807 808 sfbEnergyRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); 809 sfbEnergyLdDataRight[sfb + sfboffs] = FL2FXCONST_DBL(-1.0f); 810 sfbThresholdRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); 811 sfbThresholdLdDataRight[sfb + sfboffs] = FL2FXCONST_DBL(-0.515625f); 812 sfbSpreadEnRight[sfb + sfboffs] = FL2FXCONST_DBL(0.0f); 813 814 *msDigest = MS_SOME; 815 } 816 } 817 } 818
