libSBRdec/src/sbrdec_drc.cpp

   1
   2 /* -----------------------------------------------------------------------------------------------------------
   3 Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5 © Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
   6   All rights reserved.
   7
   8  1.    INTRODUCTION
   9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
  10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
  11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
  12
  13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
  14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
  15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
  16 of the MPEG specifications.
  17
  18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
  19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
  20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
  21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
  22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
  23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
  24
  25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
  26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
  27 applications information and documentation.
  28
  29 2.    COPYRIGHT LICENSE
  30
  31 Redistribution and use in source and binary forms, with or without modification, are permitted without
  32 payment of copyright license fees provided that you satisfy the following conditions:
  33
  34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
  35 your modifications thereto in source code form.
  36
  37 You must retain the complete text of this software license in the documentation and/or other materials
  38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
  39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
  40 modifications thereto to recipients of copies in binary form.
  41
  42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
  43 prior written permission.
  44
  45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
  46 software or your modifications thereto.
  47
  48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
  49 and 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
  53 3.    NO PATENT LICENSE
  54
  55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
  56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
  57 respect to this software.
  58
  59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
  60 by appropriate patent licenses.
  61
  62 4.    DISCLAIMER
  63
  64 This 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
  66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
  68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
  69 or business interruption, however caused and on any theory of liability, whether in contract, strict
  70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
  71 advised of the possibility of such damage.
  72
  73 5.    CONTACT INFORMATION
  74
  75 Fraunhofer Institute for Integrated Circuits IIS
  76 Attention: Audio and Multimedia Departments - FDK AAC LL
  77 Am Wolfsmantel 33
  78 91058 Erlangen, Germany
  79
  80 www.iis.fraunhofer.de/amm
  81 amm-info@iis.fraunhofer.de
  82 ----------------------------------------------------------------------------------------------------------- */
  83
  84 /*****************************  MPEG-4 AAC Decoder  **************************
  85
  86    Author(s):   Christian Griebel
  87    Description: Dynamic range control (DRC) decoder tool for SBR
  88
  89 ******************************************************************************/
  90
  91 #include "sbrdec_drc.h"
  92
  93
  94 /* DRC - Offset table for QMF interpolation. */
  95 static const int offsetTab[2][16] =
  96 {
  97   { 0, 4, 8, 12, 16, 20, 24, 28, 0, 0, 0, 0, 0, 0, 0, 0 },  /* 1024 framing */
  98   { 0, 4, 8, 12, 16, 19, 22, 26, 0, 0, 0, 0, 0, 0, 0, 0 }   /*  960 framing */
  99 };
 100
 101 /*!
 102   \brief Initialize DRC QMF factors
 103
 104   \hDrcData Handle to DRC channel data.
 105
 106   \return none
 107 */
 108 void sbrDecoder_drcInitChannel (
 109     HANDLE_SBR_DRC_CHANNEL  hDrcData )
 110 {
 111   int band;
 112
 113   if (hDrcData == NULL) {
 114     return;
 115   }
 116
 117   for (band = 0; band < (64); band++) {
 118     hDrcData->prevFact_mag[band] = FL2FXCONST_DBL(0.5f);
 119   }
 120
 121   for (band = 0; band < SBRDEC_MAX_DRC_BANDS; band++) {
 122     hDrcData->currFact_mag[band] = FL2FXCONST_DBL(0.5f);
 123     hDrcData->nextFact_mag[band] = FL2FXCONST_DBL(0.5f);
 124   }
 125
 126   hDrcData->prevFact_exp = 1;
 127   hDrcData->currFact_exp = 1;
 128   hDrcData->nextFact_exp = 1;
 129
 130   hDrcData->numBandsCurr = 1;
 131   hDrcData->numBandsNext = 1;
 132
 133   hDrcData->winSequenceCurr = 0;
 134   hDrcData->winSequenceNext = 0;
 135
 136   hDrcData->drcInterpolationSchemeCurr = 0;
 137   hDrcData->drcInterpolationSchemeNext = 0;
 138
 139   hDrcData->enable = 0;
 140 }
 141
 142
 143 /*!
 144   \brief Swap DRC QMF scaling factors after they have been applied.
 145
 146   \hDrcData Handle to DRC channel data.
 147
 148   \return none
 149 */
 150 void sbrDecoder_drcUpdateChannel (
 151     HANDLE_SBR_DRC_CHANNEL  hDrcData )
 152 {
 153   if (hDrcData == NULL) {
 154     return;
 155   }
 156   if (hDrcData->enable != 1) {
 157     return;
 158   }
 159
 160   /* swap previous data */
 161   FDKmemcpy( hDrcData->currFact_mag,
 162              hDrcData->nextFact_mag,
 163              SBRDEC_MAX_DRC_BANDS * sizeof(FIXP_DBL) );
 164
 165   hDrcData->currFact_exp = hDrcData->nextFact_exp;
 166
 167   hDrcData->numBandsCurr = hDrcData->numBandsNext;
 168
 169   FDKmemcpy( hDrcData->bandTopCurr,
 170              hDrcData->bandTopNext,
 171              SBRDEC_MAX_DRC_BANDS * sizeof(USHORT) );
 172
 173   hDrcData->drcInterpolationSchemeCurr = hDrcData->drcInterpolationSchemeNext;
 174
 175   hDrcData->winSequenceCurr = hDrcData->winSequenceNext;
 176 }
 177
 178
 179 /*!
 180   \brief Apply DRC factors slot based.
 181
 182   \hDrcData Handle to DRC channel data.
 183   \qmfRealSlot Pointer to real valued QMF data of one time slot.
 184   \qmfImagSlot Pointer to the imaginary QMF data of one time slot.
 185   \col Number of the time slot.
 186   \numQmfSubSamples Total number of time slots for one frame.
 187   \scaleFactor Pointer to the out scale factor of the time slot.
 188
 189   \return None.
 190 */
 191 void sbrDecoder_drcApplySlot (
 192     HANDLE_SBR_DRC_CHANNEL  hDrcData,
 193     FIXP_DBL   *qmfRealSlot,
 194     FIXP_DBL   *qmfImagSlot,
 195     int  col,
 196     int  numQmfSubSamples,
 197     int  maxShift
 198   )
 199 {
 200   const int *offset;
 201
 202   int band, bottomMdct, topMdct, bin, useLP;
 203   int indx = numQmfSubSamples - (numQmfSubSamples >> 1) - 10;   /* l_border */
 204   int frameLenFlag = (numQmfSubSamples == 30) ? 1 : 0;
 205
 206   const FIXP_DBL *fact_mag = NULL;
 207   INT fact_exp = 0;
 208   UINT numBands = 0;
 209   USHORT *bandTop = NULL;
 210   int shortDrc = 0;
 211
 212   FIXP_DBL alphaValue = FL2FXCONST_DBL(0.0f);
 213
 214   if (hDrcData == NULL) {
 215     return;
 216   }
 217   if (hDrcData->enable != 1) {
 218     return;
 219   }
 220
 221   offset = offsetTab[frameLenFlag];
 222
 223   useLP = (qmfImagSlot == NULL) ? 1 : 0;
 224
 225   col += indx;
 226   bottomMdct = 0;
 227   bin = 0;
 228
 229   /* get respective data and calc interpolation factor */
 230   if (col < (numQmfSubSamples>>1)) {  /* first half of current frame */
 231     if (hDrcData->winSequenceCurr != 2) { /* long window */
 232       int j = col + (numQmfSubSamples>>1);
 233
 234       if (hDrcData->drcInterpolationSchemeCurr == 0) {
 235         INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
 236
 237         alphaValue = (FIXP_DBL)(j * k);
 238       }
 239       else {
 240         if (j >= offset[hDrcData->drcInterpolationSchemeCurr - 1]) {
 241           alphaValue = (FIXP_DBL)MAXVAL_DBL;
 242         }
 243       }
 244     }
 245     else {  /* short windows */
 246       shortDrc = 1;
 247     }
 248
 249     fact_mag = hDrcData->currFact_mag;
 250     fact_exp = hDrcData->currFact_exp;
 251     numBands = hDrcData->numBandsCurr;
 252     bandTop = hDrcData->bandTopCurr;
 253   }
 254   else if (col < numQmfSubSamples) {  /* second half of current frame */
 255     if (hDrcData->winSequenceNext != 2) { /* next: long window */
 256       int j = col - (numQmfSubSamples>>1);
 257
 258       if (hDrcData->drcInterpolationSchemeNext == 0) {
 259         INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
 260
 261         alphaValue = (FIXP_DBL)(j * k);
 262       }
 263       else {
 264         if (j >= offset[hDrcData->drcInterpolationSchemeNext - 1]) {
 265           alphaValue = (FIXP_DBL)MAXVAL_DBL;
 266         }
 267       }
 268
 269       fact_mag = hDrcData->nextFact_mag;
 270       fact_exp = hDrcData->nextFact_exp;
 271       numBands = hDrcData->numBandsNext;
 272       bandTop = hDrcData->bandTopNext;
 273     }
 274     else {  /* next: short windows */
 275       if (hDrcData->winSequenceCurr != 2) {  /* current: long window */
 276         alphaValue = (FIXP_DBL)0;
 277
 278         fact_mag = hDrcData->nextFact_mag;
 279         fact_exp = hDrcData->nextFact_exp;
 280         numBands = hDrcData->numBandsNext;
 281         bandTop = hDrcData->bandTopNext;
 282       }
 283       else {  /* current: short windows */
 284         shortDrc = 1;
 285
 286         fact_mag = hDrcData->currFact_mag;
 287         fact_exp = hDrcData->currFact_exp;
 288         numBands = hDrcData->numBandsCurr;
 289         bandTop = hDrcData->bandTopCurr;
 290       }
 291     }
 292   }
 293   else {  /* first half of next frame */
 294     if (hDrcData->winSequenceNext != 2) { /* long window */
 295       int j = col - (numQmfSubSamples>>1);
 296
 297       if (hDrcData->drcInterpolationSchemeNext == 0) {
 298         INT k = (frameLenFlag) ? 0x4444444 : 0x4000000;
 299
 300         alphaValue = (FIXP_DBL)(j * k);
 301       }
 302       else {
 303         if (j >= offset[hDrcData->drcInterpolationSchemeNext - 1]) {
 304           alphaValue = (FIXP_DBL)MAXVAL_DBL;
 305         }
 306       }
 307     }
 308     else {  /* short windows */
 309       shortDrc = 1;
 310     }
 311
 312     fact_mag = hDrcData->nextFact_mag;
 313     fact_exp = hDrcData->nextFact_exp;
 314     numBands = hDrcData->numBandsNext;
 315     bandTop = hDrcData->bandTopNext;
 316
 317     col -= numQmfSubSamples;
 318   }
 319
 320
 321   /* process bands */
 322   for (band = 0; band < (int)numBands; band++) {
 323     int bottomQmf, topQmf;
 324
 325     FIXP_DBL drcFact_mag = (FIXP_DBL)MAXVAL_DBL;
 326
 327     topMdct = (bandTop[band]+1) << 2;
 328
 329     if (!shortDrc) {  /* long window */
 330       if (frameLenFlag) {
 331         /* 960 framing */
 332         bottomMdct = 30 * (bottomMdct / 30);
 333         topMdct    = 30 * (topMdct / 30);
 334
 335         bottomQmf = fMultIfloor((FIXP_DBL)0x4444444, bottomMdct);
 336         topQmf    = fMultIfloor((FIXP_DBL)0x4444444, topMdct);
 337       }
 338       else {
 339         /* 1024 framing */
 340         bottomMdct &= ~0x1f;
 341         topMdct    &= ~0x1f;
 342
 343         bottomQmf = bottomMdct >> 5;
 344         topQmf    = topMdct >> 5;
 345       }
 346
 347       if (band == ((int)numBands-1)) {
 348         topQmf = (64);
 349       }
 350
 351       for (bin = bottomQmf; bin < topQmf; bin++) {
 352         FIXP_DBL drcFact1_mag = hDrcData->prevFact_mag[bin];
 353         FIXP_DBL drcFact2_mag = fact_mag[band];
 354
 355         /* normalize scale factors */
 356         if (hDrcData->prevFact_exp < maxShift) {
 357           drcFact1_mag >>= maxShift - hDrcData->prevFact_exp;
 358         }
 359         if (fact_exp < maxShift) {
 360           drcFact2_mag >>= maxShift - fact_exp;
 361         }
 362
 363         /* interpolate */
 364         if (alphaValue == (FIXP_DBL)0) {
 365           drcFact_mag = drcFact1_mag;
 366         } else if (alphaValue == (FIXP_DBL)MAXVAL_DBL) {
 367           drcFact_mag = drcFact2_mag;
 368         } else {
 369           drcFact_mag = fMult(alphaValue, drcFact2_mag) + fMult(((FIXP_DBL)MAXVAL_DBL - alphaValue), drcFact1_mag);
 370         }
 371
 372         /* apply scaling */
 373         qmfRealSlot[bin] = fMult(qmfRealSlot[bin], drcFact_mag);
 374         if (!useLP) {
 375           qmfImagSlot[bin] = fMult(qmfImagSlot[bin], drcFact_mag);
 376         }
 377
 378         /* save previous factors */
 379         if (col == (numQmfSubSamples>>1)-1) {
 380           hDrcData->prevFact_mag[bin] = fact_mag[band];
 381         }
 382       }
 383     }
 384     else {  /* short windows */
 385       int startSample, stopSample;
 386       FIXP_DBL invFrameSizeDiv8 = (frameLenFlag) ? (FIXP_DBL)0x1111111 : (FIXP_DBL)0x1000000;
 387
 388       if (frameLenFlag) {
 389         /*  960 framing */
 390         bottomMdct = 30/8 * (bottomMdct*8/30);
 391         topMdct    = 30/8 * (topMdct*8/30);
 392       }
 393       else {
 394         /* 1024 framing */
 395         bottomMdct &= ~0x03;
 396         topMdct    &= ~0x03;
 397       }
 398
 399       /* startSample is truncated to the nearest corresponding start subsample in
 400          the QMF of the short window bottom is present in:*/
 401       startSample  = ((fMultIfloor( invFrameSizeDiv8, bottomMdct ) & 0x7) * numQmfSubSamples) >> 3;
 402
 403       /* stopSample is rounded upwards to the nearest corresponding stop subsample
 404          in the QMF of the short window top is present in. */
 405       stopSample  = ((fMultIceil( invFrameSizeDiv8, topMdct ) & 0xf) * numQmfSubSamples) >> 3;
 406
 407       bottomQmf = fMultIfloor( invFrameSizeDiv8, ((bottomMdct%(numQmfSubSamples<<2)) << 5) );
 408       topQmf    = fMultIfloor( invFrameSizeDiv8, ((topMdct%(numQmfSubSamples<<2)) << 5) );
 409
 410       /* extend last band */
 411       if (band == ((int)numBands-1)) {
 412         topQmf = (64);
 413         stopSample = numQmfSubSamples;
 414       }
 415
 416       if (topQmf == 0) {
 417         topQmf = (64);
 418       }
 419
 420       /* save previous factors */
 421       if (stopSample == numQmfSubSamples) {
 422         int tmpBottom = bottomQmf;
 423
 424         if (((numQmfSubSamples-1) & ~0x03) > startSample) {
 425             tmpBottom = 0;    /* band starts in previous short window */
 426         }
 427
 428         for (bin = tmpBottom; bin < topQmf; bin++) {
 429           hDrcData->prevFact_mag[bin] = fact_mag[band];
 430         }
 431       }
 432
 433       /* apply */
 434       if ((col >= startSample) && (col < stopSample)) {
 435         if ((col & ~0x03) > startSample) {
 436             bottomQmf = 0;    /* band starts in previous short window */
 437         }
 438         if (col < ((stopSample-1) & ~0x03)) {
 439             topQmf = (64);   /* band ends in next short window */
 440         }
 441
 442         drcFact_mag = fact_mag[band];
 443
 444         /* normalize scale factor */
 445         if (fact_exp < maxShift) {
 446           drcFact_mag >>= maxShift - fact_exp;
 447         }
 448
 449         /* apply scaling */
 450         for (bin = bottomQmf; bin < topQmf; bin++) {
 451           qmfRealSlot[bin] = fMult(qmfRealSlot[bin], drcFact_mag);
 452           if (!useLP) {
 453             qmfImagSlot[bin] = fMult(qmfImagSlot[bin], drcFact_mag);
 454           }
 455         }
 456       }
 457     }
 458
 459     bottomMdct = topMdct;
 460   }   /* end of bands loop */
 461
 462   if (col == (numQmfSubSamples>>1)-1) {
 463     hDrcData->prevFact_exp = fact_exp;
 464   }
 465 }
 466
 467
 468 /*!
 469   \brief Apply DRC factors frame based.
 470
 471   \hDrcData Handle to DRC channel data.
 472   \qmfRealSlot Pointer to real valued QMF data of the whole frame.
 473   \qmfImagSlot Pointer to the imaginary QMF data of the whole frame.
 474   \numQmfSubSamples Total number of time slots for one frame.
 475   \scaleFactor Pointer to the out scale factor of the frame.
 476
 477   \return None.
 478 */
 479 void sbrDecoder_drcApply (
 480     HANDLE_SBR_DRC_CHANNEL  hDrcData,
 481     FIXP_DBL **QmfBufferReal,
 482     FIXP_DBL **QmfBufferImag,
 483     int  numQmfSubSamples,
 484     int *scaleFactor
 485   )
 486 {
 487   int col;
 488   int maxShift = 0;
 489
 490   if (hDrcData == NULL) {
 491     return;
 492   }
 493   if (hDrcData->enable == 0) {
 494     return;  /* Avoid changing the scaleFactor even though the processing is disabled. */
 495   }
 496
 497   /* get max scale factor */
 498   if (hDrcData->prevFact_exp > maxShift) {
 499     maxShift = hDrcData->prevFact_exp;
 500   }
 501   if (hDrcData->currFact_exp > maxShift) {
 502     maxShift = hDrcData->currFact_exp;
 503   }
 504   if (hDrcData->nextFact_exp > maxShift) {
 505     maxShift = hDrcData->nextFact_exp;
 506   }
 507
 508   for (col = 0; col < numQmfSubSamples; col++)
 509   {
 510     FIXP_DBL *qmfSlotReal = QmfBufferReal[col];
 511     FIXP_DBL *qmfSlotImag = (QmfBufferImag == NULL) ? NULL : QmfBufferImag[col];
 512
 513     sbrDecoder_drcApplySlot (
 514       hDrcData,
 515       qmfSlotReal,
 516       qmfSlotImag,
 517       col,
 518       numQmfSubSamples,
 519       maxShift
 520     );
 521   }
 522
 523   *scaleFactor += maxShift;
 524 }
 525