Upgrade to FDKv2

Bug: 71430241
Test: CTS DecoderTest and DecoderTestAacDrc

original-Change-Id: Iaa20f749b8a04d553b20247cfe1a8930ebbabe30

Apply clang-format also on header files.

original-Change-Id: I14de1ef16bbc79ec0283e745f98356a10efeb2e4

Fixes for MPEG-D DRC

original-Change-Id: If1de2d74bbbac84b3f67de3b88b83f6a23b8a15c

Catch unsupported tw_mdct at an early stage

original-Change-Id: Ied9dd00d754162a0e3ca1ae3e6b854315d818afe

Fixing PVC transition frames

original-Change-Id: Ib75725abe39252806c32d71176308f2c03547a4e

Move qmf bands sanity check

original-Change-Id: Iab540c3013c174d9490d2ae100a4576f51d8dbc4

Initialize scaling variable

original-Change-Id: I3c4087101b70e998c71c1689b122b0d7762e0f9e

Add 16 qmf band configuration to getSlotNrgHQ()

original-Change-Id: I49a5d30f703a1b126ff163df9656db2540df21f1

Always apply byte alignment at the end of the AudioMuxElement

original-Change-Id: I42d560287506d65d4c3de8bfe3eb9a4ebeb4efc7

Setup SBR element only if no parse error exists

original-Change-Id: I1915b73704bc80ab882b9173d6bec59cbd073676

Additional array index check in HCR

original-Change-Id: I18cc6e501ea683b5009f1bbee26de8ddd04d8267

Fix fade-in index selection in concealment module

original-Change-Id: Ibf802ed6ed8c05e9257e1f3b6d0ac1162e9b81c1

Enable explicit backward compatible parser for AAC_LD

original-Change-Id: I27e9c678dcb5d40ed760a6d1e06609563d02482d

Skip spatial specific config in explicit backward compatible ASC

original-Change-Id: Iff7cc365561319e886090cedf30533f562ea4d6e

Update flags description in decoder API

original-Change-Id: I9a5b4f8da76bb652f5580cbd3ba9760425c43830

Add QMF domain reset function

original-Change-Id: I4f89a8a2c0277d18103380134e4ed86996e9d8d6

DRC upgrade v2.1.0

original-Change-Id: I5731c0540139dab220094cd978ef42099fc45b74

Fix integer overflow in sqrtFixp_lookup()

original-Change-Id: I429a6f0d19aa2cc957e0f181066f0ca73968c914

Fix integer overflow in invSqrtNorm2()

original-Change-Id: I84de5cbf9fb3adeb611db203fe492fabf4eb6155

Fix integer overflow in GenerateRandomVector()

original-Change-Id: I3118a641008bd9484d479e5b0b1ee2b5d7d44d74

Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I29d503c247c5c8282349b79df940416a512fb9d5

Fix integer overflow in FDKsbrEnc_codeEnvelope()

original-Change-Id: I6b34b61ebb9d525b0c651ed08de2befc1f801449

Follow-up on: Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I6f8f578cc7089e5eb7c7b93e580b72ca35ad689a

Fix integer overflow in get_pk_v2()

original-Change-Id: I63375bed40d45867f6eeaa72b20b1f33e815938c

Fix integer overflow in Syn_filt_zero()

original-Change-Id: Ie0c02fdfbe03988f9d3b20d10cd9fe4c002d1279

Fix integer overflow in CFac_CalcFacSignal()

original-Change-Id: Id2d767c40066c591b51768e978eb8af3b803f0c5

Fix integer overflow in FDKaacEnc_FDKaacEnc_calcPeNoAH()

original-Change-Id: Idcbd0f4a51ae2550ed106aa6f3d678d1f9724841

Fix integer overflow in sbrDecoder_calculateGainVec()

original-Change-Id: I7081bcbe29c5cede9821b38d93de07c7add2d507

Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4a95ddc18de150102352d4a1845f06094764c881

Fix integer overflow in Pred_Lt4()

original-Change-Id: I4dbd012b2de7d07c3e70a47b92e3bfae8dbc750a

Fix integer overflow in FDKsbrEnc_InitSbrFastTransientDetector()

original-Change-Id: I788cbec1a4a00f44c2f3a72ad7a4afa219807d04

Fix unsigned integer overflow in FDKaacEnc_WriteBitstream()

original-Change-Id: I68fc75166e7d2cd5cd45b18dbe3d8c2a92f1822a

Fix unsigned integer overflow in FDK_MetadataEnc_Init()

original-Change-Id: Ie8d025f9bcdb2442c704bd196e61065c03c10af4

Fix overflow in pseudo random number generators

original-Change-Id: I3e2551ee01356297ca14e3788436ede80bd5513c

Fix unsigned integer overflow in sbrDecoder_Parse()

original-Change-Id: I3f231b2f437e9c37db4d5b964164686710eee971

Fix unsigned integer overflow in longsub()

original-Change-Id: I73c2bc50415cac26f1f5a29e125bbe75f9180a6e

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: Ifce2db4b1454b46fa5f887e9d383f1cc43b291e4

Fix overflow at CLpdChannelStream_Read()

original-Change-Id: Idb9d822ce3a4272e4794b643644f5434e2d4bf3f

Fix unsigned integer overflow in Hcr_State_BODY_SIGN_ESC__ESC_WORD()

original-Change-Id: I1ccf77c0015684b85534c5eb97162740a870b71c

Fix unsigned integer overflow in UsacConfig_Parse()

original-Change-Id: Ie6d27f84b6ae7eef092ecbff4447941c77864d9f

Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I713f28e883eea3d70b6fa56a7b8f8c22bcf66ca0

Fix unsigned integer overflow in aacDecoder_drcReadCompression()

original-Change-Id: Ia34dfeb88c4705c558bce34314f584965cafcf7a

Fix unsigned integer overflow in CDataStreamElement_Read()

original-Change-Id: Iae896cc1d11f0a893d21be6aa90bd3e60a2c25f0

Fix unsigned integer overflow in transportDec_AdjustEndOfAccessUnit()

original-Change-Id: I64cf29a153ee784bb4a16fdc088baabebc0007dc

Fix unsigned integer overflow in transportDec_GetAuBitsRemaining()

original-Change-Id: I975b3420faa9c16a041874ba0db82e92035962e4

Fix unsigned integer overflow in extractExtendedData()

original-Change-Id: I2a59eb09e2053cfb58dfb75fcecfad6b85a80a8f

Fix signed integer overflow in CAacDecoder_ExtPayloadParse()

original-Change-Id: I4ad5ca4e3b83b5d964f1c2f8c5e7b17c477c7929

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: I29a39df77d45c52a0c9c5c83c1ba81f8d0f25090

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I8fb194ffc073a3432a380845be71036a272d388f

Fix signed integer overflow in _interpolateDrcGain()

original-Change-Id: I879ec9ab14005069a7c47faf80e8bc6e03d22e60

Fix unsigned integer overflow in FDKreadBits()

original-Change-Id: I1f47a6a8037ff70375aa8844947d5681bb4287ad

Fix unsigned integer overflow in FDKbyteAlign()

original-Change-Id: Id5f3a11a0c9e50fc6f76ed6c572dbd4e9f2af766

Fix unsigned integer overflow in FDK_get32()

original-Change-Id: I9d33b8e97e3d38cbb80629cb859266ca0acdce96

Fix unsigned integer overflow in FDK_pushBack()

original-Change-Id: Ic87f899bc8c6acf7a377a8ca7f3ba74c3a1e1c19

Fix unsigned integer overflow in FDK_pushForward()

original-Change-Id: I3b754382f6776a34be1602e66694ede8e0b8effc

Fix unsigned integer overflow in ReadPsData()

original-Change-Id: I25361664ba8139e32bbbef2ca8c106a606ce9c37

Fix signed integer overflow in E_UTIL_residu()

original-Change-Id: I8c3abd1f437ee869caa8fb5903ce7d3d641b6aad

REVERT: Follow-up on: Integer overflow in CLpc_SynthesisLattice().

original-Change-Id: I3d340099acb0414795c8dfbe6362bc0a8f045f9b

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4aedb8b3a187064e9f4d985175aa55bb99cc7590

Follow-up on: Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I2aa2e13916213bf52a67e8b0518e7bf7e57fb37d

Fix integer overflow in acelp

original-Change-Id: Ie6390c136d84055f8b728aefbe4ebef6e029dc77

Fix unsigned integer overflow in aacDecoder_UpdateBitStreamCounters()

original-Change-Id: I391ffd97ddb0b2c184cba76139bfb356a3b4d2e2

Adjust concealment default settings

original-Change-Id: I6a95db935a327c47df348030bcceafcb29f54b21

Saturate estimatedStartPos

original-Change-Id: I27be2085e0ae83ec9501409f65e003f6bcba1ab6

Negative shift exponent in _interpolateDrcGain()

original-Change-Id: I18edb26b26d002aafd5e633d4914960f7a359c29

Negative shift exponent in calculateICC()

original-Change-Id: I3dcd2ae98d2eb70ee0d59750863cbb2a6f4f8aba

Too large shift exponent in FDK_put()

original-Change-Id: Ib7d9aaa434d2d8de4a13b720ca0464b31ca9b671

Too large shift exponent in CalcInvLdData()

original-Change-Id: I43e6e78d4cd12daeb1dcd5d82d1798bdc2550262

Member access within null pointer of type SBR_CHANNEL

original-Change-Id: Idc5e4ea8997810376d2f36bbdf628923b135b097

Member access within null pointer of type CpePersistentData

original-Change-Id: Ib6c91cb0d37882768e5baf63324e429589de0d9d

Member access within null pointer FDKaacEnc_psyMain()

original-Change-Id: I7729b7f4479970531d9dc823abff63ca52e01997

Member access within null pointer FDKaacEnc_GetPnsParam()

original-Change-Id: I9aa3b9f3456ae2e0f7483dbd5b3dde95fc62da39

Member access within null pointer FDKsbrEnc_EnvEncodeFrame()

original-Change-Id: I67936f90ea714e90b3e81bc0dd1472cc713eb23a

Add HCR sanity check

original-Change-Id: I6c1d9732ebcf6af12f50b7641400752f74be39f7

Fix memory issue for HBE edge case with 8:3 SBR

original-Change-Id: I11ea58a61e69fbe8bf75034b640baee3011e63e9

Additional SBR parametrization sanity check for ELD

original-Change-Id: Ie26026fbfe174c2c7b3691f6218b5ce63e322140

Add MPEG-D DRC channel layout check

original-Change-Id: Iea70a74f171b227cce636a9eac4ba662777a2f72

Additional out-of-bounds checks in MPEG-D DRC

original-Change-Id: Ife4a8c3452c6fde8a0a09e941154a39a769777d4

Change-Id: Ic63cb2f628720f54fe9b572b0cb528e2599c624e

1 files changed, 330 insertions, 258 deletions

diff --git a/libPCMutils/src/limiter.cpp b/libPCMutils/src/limiter.cpp
index af724f0..a799a51 100644
--- a/libPCMutils/src/limiter.cpp
+++ b/libPCMutils/src/limiter.cpp
@@ -1,74 +1,85 @@
-
-/* -----------------------------------------------------------------------------------------------------------
+/* -----------------------------------------------------------------------------
 Software License for The Fraunhofer FDK AAC Codec Library for Android
 
-© Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
-  All rights reserved.
+© Copyright  1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
+Forschung e.V. All rights reserved.
 
  1.    INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
+The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
+that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
+scheme for digital audio. This FDK AAC Codec software is intended to be used on
+a wide variety of Android devices.
+
+AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
+general perceptual audio codecs. AAC-ELD is considered the best-performing
+full-bandwidth communications codec by independent studies and is widely
+deployed. AAC has been standardized by ISO and IEC as part of the MPEG
+specifications.
+
+Patent licenses for necessary patent claims for the FDK AAC Codec (including
+those of Fraunhofer) may be obtained through Via Licensing
+(www.vialicensing.com) or through the respective patent owners individually for
+the purpose of encoding or decoding bit streams in products that are compliant
+with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
+Android devices already license these patent claims through Via Licensing or
+directly from the patent owners, and therefore FDK AAC Codec software may
+already be covered under those patent licenses when it is used for those
+licensed purposes only.
+
+Commercially-licensed AAC software libraries, including floating-point versions
+with enhanced sound quality, are also available from Fraunhofer. Users are
+encouraged to check the Fraunhofer website for additional applications
+information and documentation.
 
 2.    COPYRIGHT LICENSE
 
-Redistribution and use in source and binary forms, with or without modification, are permitted without
-payment of copyright license fees provided that you satisfy the following conditions:
+Redistribution and use in source and binary forms, with or without modification,
+are permitted without payment of copyright license fees provided that you
+satisfy the following conditions:
 
-You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
-your modifications thereto in source code form.
+You must retain the complete text of this software license in redistributions of
+the FDK AAC Codec or your modifications thereto in source code form.
 
-You must retain the complete text of this software license in the documentation and/or other materials
-provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
-You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
+You must retain the complete text of this software license in the documentation
+and/or other materials provided with redistributions of the FDK AAC Codec or
+your modifications thereto in binary form. You must make available free of
+charge copies of the complete source code of the FDK AAC Codec and your
 modifications thereto to recipients of copies in binary form.
 
-The name of Fraunhofer may not be used to endorse or promote products derived from this library without
-prior written permission.
+The name of Fraunhofer may not be used to endorse or promote products derived
+from this library without prior written permission.
 
-You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
-software or your modifications thereto.
+You may not charge copyright license fees for anyone to use, copy or distribute
+the FDK AAC Codec software or your modifications thereto.
 
-Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
-and the date of any change. For modified versions of the FDK AAC Codec, the term
-"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
-"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
+Your modified versions of the FDK AAC Codec must carry prominent notices stating
+that you changed the software and the date of any change. For modified versions
+of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
+must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
+AAC Codec Library for Android."
 
 3.    NO PATENT LICENSE
 
-NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
-ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
-respect to this software.
+NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
+limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
+Fraunhofer provides no warranty of patent non-infringement with respect to this
+software.
 
-You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
-by appropriate patent licenses.
+You may use this FDK AAC Codec software or modifications thereto only for
+purposes that are authorized by appropriate patent licenses.
 
 4.    DISCLAIMER
 
-This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
-"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
-of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
-including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
-or business interruption, however caused and on any theory of liability, whether in contract, strict
-liability, or tort (including negligence), arising in any way out of the use of this software, even if
-advised of the possibility of such damage.
+This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
+holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+including but not limited to the implied warranties of merchantability and
+fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
+or consequential damages, including but not limited to procurement of substitute
+goods or services; loss of use, data, or profits, or business interruption,
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence), arising in any way out of the use of
+this software, even if advised of the possibility of such damage.
 
 5.    CONTACT INFORMATION
 
@@ -79,46 +90,28 @@ Am Wolfsmantel 33
 
 www.iis.fraunhofer.de/amm
 amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
+----------------------------------------------------------------------------- */
 
-/************************  FDK PCM postprocessor module  *********************
+/**************************** PCM utility library ******************************
 
    Author(s):   Matthias Neusinger
+
    Description: Hard limiter for clipping prevention
 
 *******************************************************************************/
 
 #include "limiter.h"
+#include "FDK_core.h"
 
-
-struct TDLimiter {
-  unsigned int  attack;
-  FIXP_DBL      attackConst, releaseConst;
-  unsigned int  attackMs, releaseMs, maxAttackMs;
-  FIXP_PCM      threshold;
-  unsigned int  channels, maxChannels;
-  unsigned int  sampleRate, maxSampleRate;
-  FIXP_DBL      cor, max;
-  FIXP_DBL*     maxBuf;
-  FIXP_DBL*     delayBuf;
-  unsigned int  maxBufIdx, delayBufIdx;
-  FIXP_DBL      smoothState0;
-  FIXP_DBL      minGain;
-
-  FIXP_DBL      additionalGainPrev;
-  FIXP_DBL      additionalGainFilterState;
-  FIXP_DBL      additionalGainFilterState1;
-};
+/* library version */
+#include "version.h"
+/* library title */
+#define TDLIMIT_LIB_TITLE "TD Limiter Lib"
 
 /* create limiter */
-TDLimiterPtr createLimiter(
-                           unsigned int  maxAttackMs,
-                           unsigned int  releaseMs,
-                           INT_PCM       threshold,
-                           unsigned int  maxChannels,
-                           unsigned int  maxSampleRate
-                           )
-{
+TDLimiterPtr pcmLimiter_Create(unsigned int maxAttackMs, unsigned int releaseMs,
+                               FIXP_DBL threshold, unsigned int maxChannels,
+                               UINT maxSampleRate) {
   TDLimiterPtr limiter = NULL;
   unsigned int attack, release;
   FIXP_DBL attackConst, releaseConst, exponent;
@@ -133,16 +126,17 @@ TDLimiterPtr createLimiter(
   if (!limiter) return NULL;
 
   /* alloc max and delay buffers */
-  limiter->maxBuf   = (FIXP_DBL*)FDKcalloc(attack + 1, sizeof(FIXP_DBL));
-  limiter->delayBuf = (FIXP_DBL*)FDKcalloc(attack * maxChannels, sizeof(FIXP_DBL));
+  limiter->maxBuf = (FIXP_DBL*)FDKcalloc(attack + 1, sizeof(FIXP_DBL));
+  limiter->delayBuf =
+      (FIXP_DBL*)FDKcalloc(attack * maxChannels, sizeof(FIXP_DBL));
 
   if (!limiter->maxBuf || !limiter->delayBuf) {
-    destroyLimiter(limiter);
+    pcmLimiter_Destroy(limiter);
     return NULL;
   }
 
   /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
-  exponent = invFixp(attack+1);
+  exponent = invFixp(attack + 1);
   attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
   attackConst = scaleValue(attackConst, e_ans);
 
@@ -152,140 +146,107 @@ TDLimiterPtr createLimiter(
   releaseConst = scaleValue(releaseConst, e_ans);
 
   /* init parameters */
-  limiter->attackMs      = maxAttackMs;
-  limiter->maxAttackMs   = maxAttackMs;
-  limiter->releaseMs     = releaseMs;
-  limiter->attack        = attack;
-  limiter->attackConst   = attackConst;
-  limiter->releaseConst  = releaseConst;
-  limiter->threshold     = (FIXP_PCM)threshold;
-  limiter->channels      = maxChannels;
-  limiter->maxChannels   = maxChannels;
-  limiter->sampleRate    = maxSampleRate;
+  limiter->attackMs = maxAttackMs;
+  limiter->maxAttackMs = maxAttackMs;
+  limiter->releaseMs = releaseMs;
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->releaseConst = releaseConst;
+  limiter->threshold = threshold >> TDL_GAIN_SCALING;
+  limiter->channels = maxChannels;
+  limiter->maxChannels = maxChannels;
+  limiter->sampleRate = maxSampleRate;
   limiter->maxSampleRate = maxSampleRate;
 
-  resetLimiter(limiter);
+  pcmLimiter_Reset(limiter);
 
   return limiter;
 }
 
-
-/* reset limiter */
-TDLIMITER_ERROR resetLimiter(TDLimiterPtr limiter)
-{
-  if (limiter != NULL) {
-
-    limiter->maxBufIdx = 0;
-    limiter->delayBufIdx = 0;
-    limiter->max = (FIXP_DBL)0;
-    limiter->cor = FL2FXCONST_DBL(1.0f/(1<<1));
-    limiter->smoothState0 = FL2FXCONST_DBL(1.0f/(1<<1));
-    limiter->minGain = FL2FXCONST_DBL(1.0f/(1<<1));
-
-    limiter->additionalGainPrev = FL2FXCONST_DBL(1.0f/(1<<TDL_GAIN_SCALING));
-    limiter->additionalGainFilterState = FL2FXCONST_DBL(1.0f/(1<<TDL_GAIN_SCALING));
-    limiter->additionalGainFilterState1 = FL2FXCONST_DBL(1.0f/(1<<TDL_GAIN_SCALING));
-
-    FDKmemset(limiter->maxBuf,   0, (limiter->attack + 1) * sizeof(FIXP_DBL) );
-    FDKmemset(limiter->delayBuf, 0, limiter->attack * limiter->channels * sizeof(FIXP_DBL) );
-  }
-  else {
-    return TDLIMIT_INVALID_HANDLE;
-  }
-
-  return TDLIMIT_OK;
-}
-
-
-/* destroy limiter */
-TDLIMITER_ERROR destroyLimiter(TDLimiterPtr limiter)
-{
-  if (limiter != NULL) {
-    FDKfree(limiter->maxBuf);
-    FDKfree(limiter->delayBuf);
-
-    FDKfree(limiter);
-  }
-  else {
-    return TDLIMIT_INVALID_HANDLE;
-  }
-  return TDLIMIT_OK;
-}
-
 /* apply limiter */
-TDLIMITER_ERROR applyLimiter(TDLimiterPtr limiter,
-                 INT_PCM*    samples,
-                 FIXP_DBL*    pGain,
-                 const INT*   gain_scale,
-                 const UINT   gain_size,
-                 const UINT   gain_delay,
-                 const UINT   nSamples)
-{
+TDLIMITER_ERROR pcmLimiter_Apply(TDLimiterPtr limiter, PCM_LIM* samplesIn,
+                                 INT_PCM* samplesOut, FIXP_DBL* RESTRICT pGain,
+                                 const INT* RESTRICT gain_scale,
+                                 const UINT gain_size, const UINT gain_delay,
+                                 const UINT nSamples) {
   unsigned int i, j;
-  FIXP_PCM tmp1, tmp2;
-  FIXP_DBL tmp, old, gain, additionalGain, additionalGainUnfiltered;
-  FIXP_DBL minGain = FL2FXCONST_DBL(1.0f/(1<<1));
+  FIXP_DBL tmp1;
+  FIXP_DBL tmp2;
+  FIXP_DBL tmp, old, gain, additionalGain = 0, additionalGainUnfiltered;
+  FIXP_DBL minGain = FL2FXCONST_DBL(1.0f / (1 << 1));
 
   FDK_ASSERT(gain_size == 1);
   FDK_ASSERT(gain_delay <= nSamples);
 
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
 
   {
-    unsigned int channels       = limiter->channels;
-    unsigned int attack         = limiter->attack;
-    FIXP_DBL     attackConst    = limiter->attackConst;
-    FIXP_DBL     releaseConst   = limiter->releaseConst;
-    FIXP_DBL     threshold      = FX_PCM2FX_DBL(limiter->threshold)>>TDL_GAIN_SCALING;
-
-    FIXP_DBL     max            = limiter->max;
-    FIXP_DBL*    maxBuf         = limiter->maxBuf;
-    unsigned int maxBufIdx      = limiter->maxBufIdx;
-    FIXP_DBL     cor            = limiter->cor;
-    FIXP_DBL*    delayBuf       = limiter->delayBuf;
-    unsigned int delayBufIdx    = limiter->delayBufIdx;
-
-    FIXP_DBL     smoothState0   = limiter->smoothState0;
-    FIXP_DBL     additionalGainSmoothState = limiter->additionalGainFilterState;
-    FIXP_DBL     additionalGainSmoothState1 = limiter->additionalGainFilterState1;
-
-    for (i = 0; i < nSamples; i++) {
-
-      if (i < gain_delay) {
-        additionalGainUnfiltered = limiter->additionalGainPrev;
-      } else {
-        additionalGainUnfiltered = pGain[0];
-      }
-
-      /* Smooth additionalGain */
-      /* [b,a] = butter(1, 0.01) */
-      static const FIXP_SGL b[] = { FL2FXCONST_SGL(0.015466*2.0), FL2FXCONST_SGL( 0.015466*2.0) };
-      static const FIXP_SGL a[] = { FL2FXCONST_SGL(1.000000), FL2FXCONST_SGL(-0.96907) };
-      /* [b,a] = butter(1, 0.001) */
-      //static const FIXP_SGL b[] = { FL2FXCONST_SGL(0.0015683*2.0), FL2FXCONST_SGL( 0.0015683*2.0) };
-      //static const FIXP_SGL a[] = { FL2FXCONST_SGL(1.0000000), FL2FXCONST_SGL(-0.99686) };
-      additionalGain = - fMult(additionalGainSmoothState, a[1]) + fMultDiv2( additionalGainUnfiltered, b[0]) + fMultDiv2(additionalGainSmoothState1, b[1]);
-      additionalGainSmoothState1 = additionalGainUnfiltered;
-      additionalGainSmoothState = additionalGain;
-
-      /* Apply the additional scaling that has no delay and no smoothing */
+    unsigned int channels = limiter->channels;
+    unsigned int attack = limiter->attack;
+    FIXP_DBL attackConst = limiter->attackConst;
+    FIXP_DBL releaseConst = limiter->releaseConst;
+    FIXP_DBL threshold = limiter->threshold;
+
+    FIXP_DBL max = limiter->max;
+    FIXP_DBL* maxBuf = limiter->maxBuf;
+    unsigned int maxBufIdx = limiter->maxBufIdx;
+    FIXP_DBL cor = limiter->cor;
+    FIXP_DBL* delayBuf = limiter->delayBuf;
+    unsigned int delayBufIdx = limiter->delayBufIdx;
+
+    FIXP_DBL smoothState0 = limiter->smoothState0;
+    FIXP_DBL additionalGainSmoothState = limiter->additionalGainFilterState;
+    FIXP_DBL additionalGainSmoothState1 = limiter->additionalGainFilterState1;
+
+    if (!gain_delay) {
+      additionalGain = pGain[0];
       if (gain_scale[0] > 0) {
         additionalGain <<= gain_scale[0];
       } else {
-        additionalGain >>= gain_scale[0];
+        additionalGain >>= -gain_scale[0];
       }
+    }
+
+    for (i = 0; i < nSamples; i++) {
+      if (gain_delay) {
+        if (i < gain_delay) {
+          additionalGainUnfiltered = limiter->additionalGainPrev;
+        } else {
+          additionalGainUnfiltered = pGain[0];
+        }
 
-      /* get maximum absolute sample value of all channels, including the additional gain. */
-      tmp1 = (FIXP_PCM)0;
+        /* Smooth additionalGain */
+        /* [b,a] = butter(1, 0.01) */
+        static const FIXP_SGL b[] = {FL2FXCONST_SGL(0.015466 * 2.0),
+                                     FL2FXCONST_SGL(0.015466 * 2.0)};
+        static const FIXP_SGL a[] = {(FIXP_SGL)MAXVAL_SGL,
+                                     FL2FXCONST_SGL(-0.96907)};
+        additionalGain = -fMult(additionalGainSmoothState, a[1]) +
+                         fMultDiv2(additionalGainUnfiltered, b[0]) +
+                         fMultDiv2(additionalGainSmoothState1, b[1]);
+        additionalGainSmoothState1 = additionalGainUnfiltered;
+        additionalGainSmoothState = additionalGain;
+
+        /* Apply the additional scaling that has no delay and no smoothing */
+        if (gain_scale[0] > 0) {
+          additionalGain <<= gain_scale[0];
+        } else {
+          additionalGain >>= -gain_scale[0];
+        }
+      }
+      /* get maximum absolute sample value of all channels, including the
+       * additional gain. */
+      tmp1 = (FIXP_DBL)0;
       for (j = 0; j < channels; j++) {
-          tmp2 = (FIXP_PCM)samples[i * channels + j];
-          if (tmp2 == (FIXP_PCM)SAMPLE_MIN) /* protect fAbs from -1.0 value */
-              tmp2 = (FIXP_PCM)(SAMPLE_MIN+1);
-        tmp1 = fMax(tmp1, fAbs(tmp2));
+        tmp2 = PCM_LIM2FIXP_DBL(samplesIn[j]);
+        tmp2 = fAbs(tmp2);
+        tmp2 = FIXP_DBL(INT(tmp2) ^ INT((tmp2 >> (SAMPLE_BITS_LIM - 1))));
+        tmp1 = fMax(tmp1, tmp2);
       }
-      tmp = SATURATE_LEFT_SHIFT(fMultDiv2(tmp1, additionalGain), 1, DFRACT_BITS);
+      tmp = fMult(tmp1, additionalGain);
 
-      /* set threshold as lower border to save calculations in running maximum algorithm */
+      /* set threshold as lower border to save calculations in running maximum
+       * algorithm */
       tmp = fMax(tmp, threshold);
 
       /* running maximum */
@@ -295,75 +256,97 @@ TDLIMITER_ERROR applyLimiter(TDLimiterPtr limiter,
       if (tmp >= max) {
         /* new sample is greater than old maximum, so it is the new maximum */
         max = tmp;
-      }
-      else if (old < max) {
+      } else if (old < max) {
         /* maximum does not change, as the sample, which has left the window was
            not the maximum */
-      }
-      else {
+      } else {
         /* the old maximum has left the window, we have to search the complete
            buffer for the new max */
         max = maxBuf[0];
         for (j = 1; j <= attack; j++) {
-          if (maxBuf[j] > max) max = maxBuf[j];
+          max = fMax(max, maxBuf[j]);
         }
       }
       maxBufIdx++;
-      if (maxBufIdx >= attack+1) maxBufIdx = 0;
+      if (maxBufIdx >= attack + 1) maxBufIdx = 0;
 
       /* calc gain */
       /* gain is downscaled by one, so that gain = 1.0 can be represented */
       if (max > threshold) {
-        gain = fDivNorm(threshold, max)>>1;
-      }
-      else {
-        gain = FL2FXCONST_DBL(1.0f/(1<<1));
+        gain = fDivNorm(threshold, max) >> 1;
+      } else {
+        gain = FL2FXCONST_DBL(1.0f / (1 << 1));
       }
 
       /* gain smoothing, method: TDL_EXPONENTIAL */
       /* first order IIR filter with attack correction to avoid overshoots */
 
-      /* correct the 'aiming' value of the exponential attack to avoid the remaining overshoot */
+      /* correct the 'aiming' value of the exponential attack to avoid the
+       * remaining overshoot */
       if (gain < smoothState0) {
-        cor = fMin(cor, fMultDiv2((gain - fMultDiv2(FL2FXCONST_SGL(0.1f*(1<<1)),smoothState0)), FL2FXCONST_SGL(1.11111111f/(1<<1)))<<2);
-      }
-      else {
+        cor = fMin(cor,
+                   fMultDiv2((gain - fMultDiv2(FL2FXCONST_SGL(0.1f * (1 << 1)),
+                                               smoothState0)),
+                             FL2FXCONST_SGL(1.11111111f / (1 << 1)))
+                       << 2);
+      } else {
         cor = gain;
       }
 
       /* smoothing filter */
       if (cor < smoothState0) {
-        smoothState0 = fMult(attackConst,(smoothState0 - cor)) + cor;  /* attack */
+        smoothState0 =
+            fMult(attackConst, (smoothState0 - cor)) + cor; /* attack */
         smoothState0 = fMax(smoothState0, gain); /* avoid overshooting target */
-      }
-      else {
+      } else {
         /* sign inversion twice to round towards +infinity,
            so that gain can converge to 1.0 again,
            for bit-identical output when limiter is not active */
-        smoothState0 = -fMult(releaseConst,-(smoothState0 - cor)) + cor; /* release */
+        smoothState0 =
+            -fMult(releaseConst, -(smoothState0 - cor)) + cor; /* release */
       }
 
       gain = smoothState0;
 
-      /* lookahead delay, apply gain */
-      for (j = 0; j < channels; j++) {
-
-        tmp = delayBuf[delayBufIdx * channels + j];
-        delayBuf[delayBufIdx * channels + j] = fMult((FIXP_PCM)samples[i * channels + j], additionalGain);
+      FIXP_DBL* p_delayBuf = &delayBuf[delayBufIdx * channels + 0];
+      if (gain < FL2FXCONST_DBL(1.0f / (1 << 1))) {
+        gain <<= 1;
+        /* lookahead delay, apply gain */
+        for (j = 0; j < channels; j++) {
+          tmp = p_delayBuf[j];
+          p_delayBuf[j] = fMult((FIXP_PCM_LIM)samplesIn[j], additionalGain);
 
-        /* Apply gain to delayed signal */
-        if (gain < FL2FXCONST_DBL(1.0f/(1<<1)))
-          tmp = fMult(tmp,gain<<1);
+          /* Apply gain to delayed signal */
+          tmp = fMultDiv2(tmp, gain);
 
-        samples[i * channels + j] = FX_DBL2FX_PCM((FIXP_DBL)SATURATE_LEFT_SHIFT(tmp,TDL_GAIN_SCALING,DFRACT_BITS));
+          samplesOut[j] = (INT_PCM)FX_DBL2FX_PCM((FIXP_DBL)SATURATE_LEFT_SHIFT(
+              tmp, TDL_GAIN_SCALING + 1, DFRACT_BITS));
+        }
+        gain >>= 1;
+      } else {
+        /* lookahead delay, apply gain=1.0f */
+        for (j = 0; j < channels; j++) {
+          tmp = p_delayBuf[j];
+          p_delayBuf[j] = fMult((FIXP_PCM_LIM)samplesIn[j], additionalGain);
+          samplesOut[j] = (INT_PCM)FX_DBL2FX_PCM((FIXP_DBL)SATURATE_LEFT_SHIFT(
+              tmp, TDL_GAIN_SCALING, DFRACT_BITS));
+        }
       }
+
       delayBufIdx++;
-      if (delayBufIdx >= attack) delayBufIdx = 0;
+      if (delayBufIdx >= attack) {
+        delayBufIdx = 0;
+      }
 
       /* save minimum gain factor */
-      if (gain < minGain) minGain = gain;
-    }
+      if (gain < minGain) {
+        minGain = gain;
+      }
 
+      /* advance sample pointer by <channel> samples */
+      samplesIn += channels;
+      samplesOut += channels;
+    }
 
     limiter->max = max;
     limiter->maxBufIdx = maxBufIdx;
@@ -382,34 +365,99 @@ TDLIMITER_ERROR applyLimiter(TDLimiterPtr limiter,
   }
 }
 
+/* set limiter threshold */
+TDLIMITER_ERROR pcmLimiter_SetThreshold(TDLimiterPtr limiter,
+                                        FIXP_DBL threshold) {
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  limiter->threshold = threshold >> TDL_GAIN_SCALING;
+
+  return TDLIMIT_OK;
+}
+
+/* reset limiter */
+TDLIMITER_ERROR pcmLimiter_Reset(TDLimiterPtr limiter) {
+  if (limiter != NULL) {
+    limiter->maxBufIdx = 0;
+    limiter->delayBufIdx = 0;
+    limiter->max = (FIXP_DBL)0;
+    limiter->cor = FL2FXCONST_DBL(1.0f / (1 << 1));
+    limiter->smoothState0 = FL2FXCONST_DBL(1.0f / (1 << 1));
+    limiter->minGain = FL2FXCONST_DBL(1.0f / (1 << 1));
+
+    limiter->additionalGainPrev =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+    limiter->additionalGainFilterState =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+    limiter->additionalGainFilterState1 =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+
+    FDKmemset(limiter->maxBuf, 0, (limiter->attack + 1) * sizeof(FIXP_DBL));
+    FDKmemset(limiter->delayBuf, 0,
+              limiter->attack * limiter->channels * sizeof(FIXP_DBL));
+  } else {
+    return TDLIMIT_INVALID_HANDLE;
+  }
+
+  return TDLIMIT_OK;
+}
+
+/* destroy limiter */
+TDLIMITER_ERROR pcmLimiter_Destroy(TDLimiterPtr limiter) {
+  if (limiter != NULL) {
+    FDKfree(limiter->maxBuf);
+    FDKfree(limiter->delayBuf);
+
+    FDKfree(limiter);
+  } else {
+    return TDLIMIT_INVALID_HANDLE;
+  }
+  return TDLIMIT_OK;
+}
+
 /* get delay in samples */
-unsigned int getLimiterDelay(TDLimiterPtr limiter)
-{
+unsigned int pcmLimiter_GetDelay(TDLimiterPtr limiter) {
   FDK_ASSERT(limiter != NULL);
   return limiter->attack;
 }
 
+/* get maximum gain reduction of last processed block */
+INT pcmLimiter_GetMaxGainReduction(TDLimiterPtr limiter) {
+  /* maximum gain reduction in dB = -20 * log10(limiter->minGain)
+     = -20 * log2(limiter->minGain)/log2(10) = -6.0206*log2(limiter->minGain) */
+  int e_ans;
+  FIXP_DBL loggain, maxGainReduction;
+
+  FDK_ASSERT(limiter != NULL);
+
+  loggain = fLog2(limiter->minGain, 1, &e_ans);
+
+  maxGainReduction = fMult(loggain, FL2FXCONST_DBL(-6.0206f / (1 << 3)));
+
+  return fixp_roundToInt(maxGainReduction, (e_ans + 3));
+}
+
 /* set number of channels */
-TDLIMITER_ERROR setLimiterNChannels(TDLimiterPtr limiter, unsigned int nChannels)
-{
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+TDLIMITER_ERROR pcmLimiter_SetNChannels(TDLimiterPtr limiter,
+                                        unsigned int nChannels) {
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
 
   if (nChannels > limiter->maxChannels) return TDLIMIT_INVALID_PARAMETER;
 
   limiter->channels = nChannels;
-  //resetLimiter(limiter);
+  // pcmLimiter_Reset(limiter);
 
   return TDLIMIT_OK;
 }
 
 /* set sampling rate */
-TDLIMITER_ERROR setLimiterSampleRate(TDLimiterPtr limiter, unsigned int sampleRate)
-{
+TDLIMITER_ERROR pcmLimiter_SetSampleRate(TDLimiterPtr limiter,
+                                         UINT sampleRate) {
   unsigned int attack, release;
   FIXP_DBL attackConst, releaseConst, exponent;
   INT e_ans;
 
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
 
   if (sampleRate > limiter->maxSampleRate) return TDLIMIT_INVALID_PARAMETER;
 
@@ -418,7 +466,7 @@ TDLIMITER_ERROR setLimiterSampleRate(TDLimiterPtr limiter, unsigned int sampleRa
   release = (unsigned int)(limiter->releaseMs * sampleRate / 1000);
 
   /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
-  exponent = invFixp(attack+1);
+  exponent = invFixp(attack + 1);
   attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
   attackConst = scaleValue(attackConst, e_ans);
 
@@ -427,25 +475,25 @@ TDLIMITER_ERROR setLimiterSampleRate(TDLimiterPtr limiter, unsigned int sampleRa
   releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
   releaseConst = scaleValue(releaseConst, e_ans);
 
-  limiter->attack        = attack;
-  limiter->attackConst   = attackConst;
-  limiter->releaseConst  = releaseConst;
-  limiter->sampleRate    = sampleRate;
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->releaseConst = releaseConst;
+  limiter->sampleRate = sampleRate;
 
   /* reset */
-  //resetLimiter(limiter);
+  // pcmLimiter_Reset(limiter);
 
   return TDLIMIT_OK;
 }
 
 /* set attack time */
-TDLIMITER_ERROR setLimiterAttack(TDLimiterPtr limiter, unsigned int attackMs)
-{
+TDLIMITER_ERROR pcmLimiter_SetAttack(TDLimiterPtr limiter,
+                                     unsigned int attackMs) {
   unsigned int attack;
   FIXP_DBL attackConst, exponent;
   INT e_ans;
 
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
 
   if (attackMs > limiter->maxAttackMs) return TDLIMIT_INVALID_PARAMETER;
 
@@ -453,25 +501,25 @@ TDLIMITER_ERROR setLimiterAttack(TDLimiterPtr limiter, unsigned int attackMs)
   attack = (unsigned int)(attackMs * limiter->sampleRate / 1000);
 
   /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
-  exponent = invFixp(attack+1);
+  exponent = invFixp(attack + 1);
   attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
   attackConst = scaleValue(attackConst, e_ans);
 
-  limiter->attack        = attack;
-  limiter->attackConst   = attackConst;
-  limiter->attackMs      = attackMs;
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->attackMs = attackMs;
 
   return TDLIMIT_OK;
 }
 
 /* set release time */
-TDLIMITER_ERROR setLimiterRelease(TDLimiterPtr limiter, unsigned int releaseMs)
-{
+TDLIMITER_ERROR pcmLimiter_SetRelease(TDLimiterPtr limiter,
+                                      unsigned int releaseMs) {
   unsigned int release;
   FIXP_DBL releaseConst, exponent;
   INT e_ans;
 
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
 
   /* calculate  release time in samples */
   release = (unsigned int)(releaseMs * limiter->sampleRate / 1000);
@@ -481,18 +529,42 @@ TDLIMITER_ERROR setLimiterRelease(TDLimiterPtr limiter, unsigned int releaseMs)
   releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
   releaseConst = scaleValue(releaseConst, e_ans);
 
-  limiter->releaseConst  = releaseConst;
-  limiter->releaseMs     = releaseMs;
+  limiter->releaseConst = releaseConst;
+  limiter->releaseMs = releaseMs;
 
   return TDLIMIT_OK;
 }
 
-/* set limiter threshold */
-TDLIMITER_ERROR setLimiterThreshold(TDLimiterPtr limiter, INT_PCM threshold)
-{
-  if ( limiter == NULL ) return TDLIMIT_INVALID_HANDLE;
+/* Get library info for this module. */
+TDLIMITER_ERROR pcmLimiter_GetLibInfo(LIB_INFO* info) {
+  int i;
+
+  if (info == NULL) {
+    return TDLIMIT_INVALID_PARAMETER;
+  }
+
+  /* Search for next free tab */
+  for (i = 0; i < FDK_MODULE_LAST; i++) {
+    if (info[i].module_id == FDK_NONE) break;
+  }
+  if (i == FDK_MODULE_LAST) {
+    return TDLIMIT_UNKNOWN;
+  }
+
+  /* Add the library info */
+  info[i].module_id = FDK_TDLIMIT;
+  info[i].version =
+      LIB_VERSION(PCMUTIL_LIB_VL0, PCMUTIL_LIB_VL1, PCMUTIL_LIB_VL2);
+  LIB_VERSION_STRING(info + i);
+  info[i].build_date = PCMUTIL_LIB_BUILD_DATE;
+  info[i].build_time = PCMUTIL_LIB_BUILD_TIME;
+  info[i].title = TDLIMIT_LIB_TITLE;
+
+  /* Set flags */
+  info[i].flags = CAPF_LIMITER;
 
-  limiter->threshold = (FIXP_PCM)threshold;
+  /* Add lib info for FDK tools (if not yet done). */
+  FDK_toolsGetLibInfo(info);
 
   return TDLIMIT_OK;
 }