diff options
Diffstat (limited to 'fdk-aac/libPCMutils/src/limiter.cpp')
| -rw-r--r-- | fdk-aac/libPCMutils/src/limiter.cpp | 570 |
1 files changed, 570 insertions, 0 deletions
diff --git a/fdk-aac/libPCMutils/src/limiter.cpp b/fdk-aac/libPCMutils/src/limiter.cpp new file mode 100644 index 0000000..a799a51 --- /dev/null +++ b/fdk-aac/libPCMutils/src/limiter.cpp @@ -0,0 +1,570 @@ +/* ----------------------------------------------------------------------------- +Software License for The Fraunhofer FDK AAC Codec Library for Android + +© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten +Forschung e.V. All rights reserved. + + 1. INTRODUCTION +The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software +that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding +scheme for digital audio. This FDK AAC Codec software is intended to be used on +a wide variety of Android devices. + +AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient +general perceptual audio codecs. AAC-ELD is considered the best-performing +full-bandwidth communications codec by independent studies and is widely +deployed. AAC has been standardized by ISO and IEC as part of the MPEG +specifications. + +Patent licenses for necessary patent claims for the FDK AAC Codec (including +those of Fraunhofer) may be obtained through Via Licensing +(www.vialicensing.com) or through the respective patent owners individually for +the purpose of encoding or decoding bit streams in products that are compliant +with the ISO/IEC MPEG audio standards. Please note that most manufacturers of +Android devices already license these patent claims through Via Licensing or +directly from the patent owners, and therefore FDK AAC Codec software may +already be covered under those patent licenses when it is used for those +licensed purposes only. + +Commercially-licensed AAC software libraries, including floating-point versions +with enhanced sound quality, are also available from Fraunhofer. Users are +encouraged to check the Fraunhofer website for additional applications +information and documentation. + +2. COPYRIGHT LICENSE + +Redistribution and use in source and binary forms, with or without modification, +are permitted without payment of copyright license fees provided that you +satisfy the following conditions: + +You must retain the complete text of this software license in redistributions of +the FDK AAC Codec or your modifications thereto in source code form. + +You must retain the complete text of this software license in the documentation +and/or other materials provided with redistributions of the FDK AAC Codec or +your modifications thereto in binary form. You must make available free of +charge copies of the complete source code of the FDK AAC Codec and your +modifications thereto to recipients of copies in binary form. + +The name of Fraunhofer may not be used to endorse or promote products derived +from this library without prior written permission. + +You may not charge copyright license fees for anyone to use, copy or distribute +the FDK AAC Codec software or your modifications thereto. + +Your modified versions of the FDK AAC Codec must carry prominent notices stating +that you changed the software and the date of any change. For modified versions +of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" +must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK +AAC Codec Library for Android." + +3. NO PATENT LICENSE + +NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without +limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. +Fraunhofer provides no warranty of patent non-infringement with respect to this +software. + +You may use this FDK AAC Codec software or modifications thereto only for +purposes that are authorized by appropriate patent licenses. + +4. DISCLAIMER + +This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright +holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, +including but not limited to the implied warranties of merchantability and +fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, +or consequential damages, including but not limited to procurement of substitute +goods or services; loss of use, data, or profits, or business interruption, +however caused and on any theory of liability, whether in contract, strict +liability, or tort (including negligence), arising in any way out of the use of +this software, even if advised of the possibility of such damage. + +5. CONTACT INFORMATION + +Fraunhofer Institute for Integrated Circuits IIS +Attention: Audio and Multimedia Departments - FDK AAC LL +Am Wolfsmantel 33 +91058 Erlangen, Germany + +www.iis.fraunhofer.de/amm +amm-info@iis.fraunhofer.de +----------------------------------------------------------------------------- */ + +/**************************** PCM utility library ****************************** + + Author(s): Matthias Neusinger + + Description: Hard limiter for clipping prevention + +*******************************************************************************/ + +#include "limiter.h" +#include "FDK_core.h" + +/* library version */ +#include "version.h" +/* library title */ +#define TDLIMIT_LIB_TITLE "TD Limiter Lib" + +/* create limiter */ +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; + INT e_ans; + + /* calc attack and release time in samples */ + attack = (unsigned int)(maxAttackMs * maxSampleRate / 1000); + release = (unsigned int)(releaseMs * maxSampleRate / 1000); + + /* alloc limiter struct */ + limiter = (TDLimiterPtr)FDKcalloc(1, sizeof(struct TDLimiter)); + 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)); + + if (!limiter->maxBuf || !limiter->delayBuf) { + pcmLimiter_Destroy(limiter); + return NULL; + } + + /* attackConst = pow(0.1, 1.0 / (attack + 1)) */ + exponent = invFixp(attack + 1); + attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans); + attackConst = scaleValue(attackConst, e_ans); + + /* releaseConst = (float)pow(0.1, 1.0 / (release + 1)) */ + exponent = invFixp(release + 1); + releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans); + 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 = threshold >> TDL_GAIN_SCALING; + limiter->channels = maxChannels; + limiter->maxChannels = maxChannels; + limiter->sampleRate = maxSampleRate; + limiter->maxSampleRate = maxSampleRate; + + pcmLimiter_Reset(limiter); + + return limiter; +} + +/* apply limiter */ +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_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; + + { + 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]; + } + } + + for (i = 0; i < nSamples; i++) { + if (gain_delay) { + 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[] = {(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 = PCM_LIM2FIXP_DBL(samplesIn[j]); + tmp2 = fAbs(tmp2); + tmp2 = FIXP_DBL(INT(tmp2) ^ INT((tmp2 >> (SAMPLE_BITS_LIM - 1)))); + tmp1 = fMax(tmp1, tmp2); + } + tmp = fMult(tmp1, additionalGain); + + /* set threshold as lower border to save calculations in running maximum + * algorithm */ + tmp = fMax(tmp, threshold); + + /* running maximum */ + old = maxBuf[maxBufIdx]; + maxBuf[maxBufIdx] = tmp; + + if (tmp >= max) { + /* new sample is greater than old maximum, so it is the new maximum */ + max = tmp; + } else if (old < max) { + /* maximum does not change, as the sample, which has left the window was + not the maximum */ + } 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++) { + max = fMax(max, maxBuf[j]); + } + } + maxBufIdx++; + 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 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 */ + 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 = gain; + } + + /* smoothing filter */ + if (cor < smoothState0) { + smoothState0 = + fMult(attackConst, (smoothState0 - cor)) + cor; /* attack */ + smoothState0 = fMax(smoothState0, gain); /* avoid overshooting target */ + } 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 */ + } + + gain = smoothState0; + + 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 */ + tmp = fMultDiv2(tmp, gain); + + 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; + } + + /* save minimum gain factor */ + if (gain < minGain) { + minGain = gain; + } + + /* advance sample pointer by <channel> samples */ + samplesIn += channels; + samplesOut += channels; + } + + limiter->max = max; + limiter->maxBufIdx = maxBufIdx; + limiter->cor = cor; + limiter->delayBufIdx = delayBufIdx; + + limiter->smoothState0 = smoothState0; + limiter->additionalGainFilterState = additionalGainSmoothState; + limiter->additionalGainFilterState1 = additionalGainSmoothState1; + + limiter->minGain = minGain; + + limiter->additionalGainPrev = pGain[0]; + + return TDLIMIT_OK; + } +} + +/* 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 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 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; + // pcmLimiter_Reset(limiter); + + return TDLIMIT_OK; +} + +/* set sampling rate */ +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 (sampleRate > limiter->maxSampleRate) return TDLIMIT_INVALID_PARAMETER; + + /* update attack and release time in samples */ + attack = (unsigned int)(limiter->attackMs * sampleRate / 1000); + release = (unsigned int)(limiter->releaseMs * sampleRate / 1000); + + /* attackConst = pow(0.1, 1.0 / (attack + 1)) */ + exponent = invFixp(attack + 1); + attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans); + attackConst = scaleValue(attackConst, e_ans); + + /* releaseConst = (float)pow(0.1, 1.0 / (release + 1)) */ + exponent = invFixp(release + 1); + 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; + + /* reset */ + // pcmLimiter_Reset(limiter); + + return TDLIMIT_OK; +} + +/* set attack time */ +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 (attackMs > limiter->maxAttackMs) return TDLIMIT_INVALID_PARAMETER; + + /* calculate attack time in samples */ + attack = (unsigned int)(attackMs * limiter->sampleRate / 1000); + + /* attackConst = pow(0.1, 1.0 / (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; + + return TDLIMIT_OK; +} + +/* set release time */ +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; + + /* calculate release time in samples */ + release = (unsigned int)(releaseMs * limiter->sampleRate / 1000); + + /* releaseConst = (float)pow(0.1, 1.0 / (release + 1)) */ + exponent = invFixp(release + 1); + releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans); + releaseConst = scaleValue(releaseConst, e_ans); + + limiter->releaseConst = releaseConst; + limiter->releaseMs = releaseMs; + + return TDLIMIT_OK; +} + +/* 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; + + /* Add lib info for FDK tools (if not yet done). */ + FDK_toolsGetLibInfo(info); + + return TDLIMIT_OK; +} |