/*
* Copyright (C) 2011 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS 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 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "DynamicsCompressorKernel.h"
#include <algorithm>
#include <cmath>
#include "DenormalDisabler.h"
#include "WebAudioUtils.h"
#include "mozilla/FloatingPoint.h"
using namespace mozilla::dom;
// for WebAudioUtils
using mozilla::MakeUnique;
using mozilla::PositiveInfinity;
namespace WebCore {
// Metering hits peaks instantly, but releases this fast (in seconds).
const float meteringReleaseTimeConstant =
0.
325f;
const float uninitializedValue = -
1;
DynamicsCompressorKernel::DynamicsCompressorKernel(
float sampleRate,
unsigned numberOfChannels)
: m_sampleRate(sampleRate),
m_lastPreDelayFrames(DefaultPreDelayFrames),
m_preDelayReadIndex(
0),
m_preDelayWriteIndex(DefaultPreDelayFrames),
m_ratio(uninitializedValue),
m_slope(uninitializedValue),
m_linearThreshold(uninitializedValue),
m_dbThreshold(uninitializedValue),
m_dbKnee(uninitializedValue),
m_kneeThreshold(uninitializedValue),
m_kneeThresholdDb(uninitializedValue),
m_ykneeThresholdDb(uninitializedValue),
m_K(uninitializedValue) {
setNumberOfChannels(numberOfChannels);
// Initializes most member variables
reset();
m_meteringReleaseK =
static_cast<
float>(WebAudioUtils::DiscreteTimeConstantForSampleRate(
meteringReleaseTimeConstant, sampleRate));
}
size_t DynamicsCompressorKernel::sizeOfExcludingThis(
mozilla::MallocSizeOf aMallocSizeOf)
const {
size_t amount =
0;
amount += m_preDelayBuffers.ShallowSizeOfExcludingThis(aMallocSizeOf);
for (size_t i =
0; i < m_preDelayBuffers.Length(); i++) {
amount += aMallocSizeOf(m_preDelayBuffers[i].get());
}
return amount;
}
void DynamicsCompressorKernel::setNumberOfChannels(
unsigned numberOfChannels) {
if (m_preDelayBuffers.Length() == numberOfChannels)
return;
m_preDelayBuffers.Clear();
for (
unsigned i =
0; i < numberOfChannels; ++i)
m_preDelayBuffers.AppendElement(MakeUnique<
float[]>(MaxPreDelayFrames));
}
void DynamicsCompressorKernel::setPreDelayTime(
float preDelayTime) {
// Re-configure look-ahead section pre-delay if delay time has changed.
unsigned preDelayFrames = preDelayTime * sampleRate();
if (preDelayFrames > MaxPreDelayFrames -
1)
preDelayFrames = MaxPreDelayFrames -
1;
if (m_lastPreDelayFrames != preDelayFrames) {
m_lastPreDelayFrames = preDelayFrames;
for (
unsigned i =
0; i < m_preDelayBuffers.Length(); ++i)
memset(m_preDelayBuffers[i].get(),
0,
sizeof(
float) * MaxPreDelayFrames);
m_preDelayReadIndex =
0;
m_preDelayWriteIndex = preDelayFrames;
}
}
// Exponential curve for the knee.
// It is 1st derivative matched at m_linearThreshold and asymptotically
// approaches the value m_linearThreshold + 1 / k.
float DynamicsCompressorKernel::kneeCurve(
float x,
float k) {
// Linear up to threshold.
if (x < m_linearThreshold)
return x;
return m_linearThreshold +
(
1 - fdlibm_expf(-k * (x - m_linearThreshold))) / k;
}
// Full compression curve with constant ratio after knee.
float DynamicsCompressorKernel::saturate(
float x,
float k) {
float y;
if (x < m_kneeThreshold)
y = kneeCurve(x, k);
else {
// Constant ratio after knee.
float xDb = WebAudioUtils::ConvertLinearToDecibels(x, -
1000.
0f);
float yDb = m_ykneeThresholdDb + m_slope * (xDb - m_kneeThresholdDb);
y = WebAudioUtils::ConvertDecibelsToLinear(yDb);
}
return y;
}
// Approximate 1st derivative with input and output expressed in dB.
// This slope is equal to the inverse of the compression "ratio".
// In other words, a compression ratio of 20 would be a slope of 1/20.
float DynamicsCompressorKernel::slopeAt(
float x,
float k) {
if (x < m_linearThreshold)
return 1;
float x2 = x *
1.
001;
float xDb = WebAudioUtils::ConvertLinearToDecibels(x, -
1000.
0f);
float x2Db = WebAudioUtils::ConvertLinearToDecibels(x2, -
1000.
0f);
float yDb = WebAudioUtils::ConvertLinearToDecibels(kneeCurve(x, k), -
1000.
0f);
float y2Db =
WebAudioUtils::ConvertLinearToDecibels(kneeCurve(x2, k), -
1000.
0f);
float m = (y2Db - yDb) / (x2Db - xDb);
return m;
}
float DynamicsCompressorKernel::kAtSlope(
float desiredSlope) {
float xDb = m_dbThreshold + m_dbKnee;
float x = WebAudioUtils::ConvertDecibelsToLinear(xDb);
// Approximate k given initial values.
float minK =
0.
1f;
float maxK =
10000;
float k =
5;
for (
int i =
0; i <
15; ++i) {
// A high value for k will more quickly asymptotically approach a slope of
// 0.
float slope = slopeAt(x, k);
if (slope < desiredSlope) {
// k is too high.
maxK = k;
}
else {
// k is too low.
minK = k;
}
// Re-calculate based on geometric mean.
k = sqrtf(minK * maxK);
}
return k;
}
float DynamicsCompressorKernel::updateStaticCurveParameters(
float dbThreshold,
float dbKnee,
float ratio) {
if (dbThreshold != m_dbThreshold || dbKnee != m_dbKnee || ratio != m_ratio) {
// Threshold and knee.
m_dbThreshold = dbThreshold;
m_linearThreshold = WebAudioUtils::ConvertDecibelsToLinear(dbThreshold);
m_dbKnee = dbKnee;
// Compute knee parameters.
m_ratio = ratio;
m_slope =
1 / m_ratio;
float k = kAtSlope(
1 / m_ratio);
m_kneeThresholdDb = dbThreshold + dbKnee;
m_kneeThreshold = WebAudioUtils::ConvertDecibelsToLinear(m_kneeThresholdDb);
m_ykneeThresholdDb = WebAudioUtils::ConvertLinearToDecibels(
kneeCurve(m_kneeThreshold, k), -
1000.
0f);
m_K = k;
}
return m_K;
}
void DynamicsCompressorKernel::process(
float* sourceChannels[],
float* destinationChannels[],
unsigned numberOfChannels,
unsigned framesToProcess,
float dbThreshold,
float dbKnee,
float ratio,
float attackTime,
float releaseTime,
float preDelayTime,
float dbPostGain,
float effectBlend,
/* equal power crossfade */
float releaseZone1,
float releaseZone2,
float releaseZone3,
float releaseZone4) {
MOZ_ASSERT(m_preDelayBuffers.Length() == numberOfChannels);
float sampleRate =
this->sampleRate();
float dryMix =
1 - effectBlend;
float wetMix = effectBlend;
float k = updateStaticCurveParameters(dbThreshold, dbKnee, ratio);
// Makeup gain.
float fullRangeGain = saturate(
1, k);
float fullRangeMakeupGain =
1 / fullRangeGain;
// Empirical/perceptual tuning.
fullRangeMakeupGain = fdlibm_powf(fullRangeMakeupGain,
0.
6f);
float masterLinearGain =
WebAudioUtils::ConvertDecibelsToLinear(dbPostGain) * fullRangeMakeupGain;
// Attack parameters.
attackTime = std::max(
0.
001f, attackTime);
float attackFrames = attackTime * sampleRate;
// Release parameters.
float releaseFrames = sampleRate * releaseTime;
// Detector release time.
float satReleaseTime =
0.
0025f;
float satReleaseFrames = satReleaseTime * sampleRate;
// Create a smooth function which passes through four points.
// Polynomial of the form
// y = a + b*x + c*x^2 + d*x^3 + e*x^4;
float y1 = releaseFrames * releaseZone1;
float y2 = releaseFrames * releaseZone2;
float y3 = releaseFrames * releaseZone3;
float y4 = releaseFrames * releaseZone4;
// All of these coefficients were derived for 4th order polynomial curve
// fitting where the y values match the evenly spaced x values as follows:
// (y1 : x == 0, y2 : x == 1, y3 : x == 2, y4 : x == 3)
float kA =
0.
9999999999999998f * y1 +
1.
8432219684323923e-
16f * y2 -
1.
9373394351676423e-
16f * y3 +
8.
824516011816245e-
18f * y4;
float kB = -
1.
5788320352845888f * y1 +
2.
3305837032074286f * y2 -
0.
9141194204840429f * y3 +
0.
1623677525612032f * y4;
float kC =
0.
5334142869106424f * y1 -
1.
272736789213631f * y2 +
0.
9258856042207512f * y3 -
0.
18656310191776226f * y4;
float kD =
0.
08783463138207234f * y1 -
0.
1694162967925622f * y2 +
0.
08588057951595272f * y3 -
0.
00429891410546283f * y4;
float kE = -
0.
042416883008123074f * y1 +
0.
1115693827987602f * y2 -
0.
09764676325265872f * y3 +
0.
028494263462021576f * y4;
// x ranges from 0 -> 3 0 1 2 3
// -15 -10 -5 0db
// y calculates adaptive release frames depending on the amount of
// compression.
setPreDelayTime(preDelayTime);
const int nDivisionFrames =
32;
const int nDivisions = framesToProcess / nDivisionFrames;
unsigned frameIndex =
0;
for (
int i =
0; i < nDivisions; ++i) {
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Calculate desired gain
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Fix gremlins.
if (std::isnan(m_detectorAverage)) m_detectorAverage =
1;
if (std::isinf(m_detectorAverage)) m_detectorAverage =
1;
float desiredGain = m_detectorAverage;
// Pre-warp so we get desiredGain after sin() warp below.
float scaledDesiredGain = fdlibm_asinf(desiredGain) / (
0.
5f * M_PI);
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Deal with envelopes
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// envelopeRate is the rate we slew from current compressor level to the
// desired level. The exact rate depends on if we're attacking or releasing
// and by how much.
float envelopeRate;
bool isReleasing = scaledDesiredGain > m_compressorGain;
// compressionDiffDb is the difference between current compression level and
// the desired level.
float compressionDiffDb;
if (scaledDesiredGain ==
0.
0) {
compressionDiffDb = PositiveInfinity<
float>();
}
else {
compressionDiffDb = WebAudioUtils::ConvertLinearToDecibels(
m_compressorGain / scaledDesiredGain, -
1000.
0f);
}
if (isReleasing) {
// Release mode - compressionDiffDb should be negative dB
m_maxAttackCompressionDiffDb = -
1;
// Fix gremlins.
if (std::isnan(compressionDiffDb)) compressionDiffDb = -
1;
if (std::isinf(compressionDiffDb)) compressionDiffDb = -
1;
// Adaptive release - higher compression (lower compressionDiffDb)
// releases faster.
// Contain within range: -12 -> 0 then scale to go from 0 -> 3
float x = compressionDiffDb;
x = std::max(-
12.
0f, x);
x = std::min(
0.
0f, x);
x =
0.
25f * (x +
12);
// Compute adaptive release curve using 4th order polynomial.
// Normal values for the polynomial coefficients would create a
// monotonically increasing function.
float x2 = x * x;
float x3 = x2 * x;
float x4 = x2 * x2;
float releaseFrames = kA + kB * x + kC * x2 + kD * x3 + kE * x4;
#define kSpacingDb
5
float dbPerFrame = kSpacingDb / releaseFrames;
envelopeRate = WebAudioUtils::ConvertDecibelsToLinear(dbPerFrame);
}
else {
// Attack mode - compressionDiffDb should be positive dB
// Fix gremlins.
if (std::isnan(compressionDiffDb)) compressionDiffDb =
1;
if (std::isinf(compressionDiffDb)) compressionDiffDb =
1;
// As long as we're still in attack mode, use a rate based off
// the largest compressionDiffDb we've encountered so far.
if (m_maxAttackCompressionDiffDb == -
1 ||
m_maxAttackCompressionDiffDb < compressionDiffDb)
m_maxAttackCompressionDiffDb = compressionDiffDb;
float effAttenDiffDb = std::max(
0.
5f, m_maxAttackCompressionDiffDb);
float x =
0.
25f / effAttenDiffDb;
envelopeRate =
1 - fdlibm_powf(x,
1 / attackFrames);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Inner loop - calculate shaped power average - apply compression.
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
int preDelayReadIndex = m_preDelayReadIndex;
int preDelayWriteIndex = m_preDelayWriteIndex;
float detectorAverage = m_detectorAverage;
float compressorGain = m_compressorGain;
int loopFrames = nDivisionFrames;
while (loopFrames--) {
float compressorInput =
0;
// Predelay signal, computing compression amount from un-delayed
// version.
for (
unsigned i =
0; i < numberOfChannels; ++i) {
float* delayBuffer = m_preDelayBuffers[i].get();
float undelayedSource = sourceChannels[i][frameIndex];
delayBuffer[preDelayWriteIndex] = undelayedSource;
float absUndelayedSource =
undelayedSource >
0 ? undelayedSource : -undelayedSource;
if (compressorInput < absUndelayedSource)
compressorInput = absUndelayedSource;
}
// Calculate shaped power on undelayed input.
float scaledInput = compressorInput;
float absInput = scaledInput >
0 ? scaledInput : -scaledInput;
// Put through shaping curve.
// This is linear up to the threshold, then enters a "knee" portion
// followed by the "ratio" portion. The transition from the threshold to
// the knee is smooth (1st derivative matched). The transition from the
// knee to the ratio portion is smooth (1st derivative matched).
float shapedInput = saturate(absInput, k);
float attenuation = absInput <=
0.
0001f ?
1 : shapedInput / absInput;
if (std::isnan(attenuation)) {
// When absInput is inf, shapedInput is also inf, so attenuation is
// NaN. Use maximum attenuation.
attenuation =
0;
}
float attenuationDb =
-WebAudioUtils::ConvertLinearToDecibels(attenuation, -
1000.
0f);
attenuationDb = std::max(
2.
0f, attenuationDb);
float dbPerFrame = attenuationDb / satReleaseFrames;
float satReleaseRate =
WebAudioUtils::ConvertDecibelsToLinear(dbPerFrame) -
1;
bool isRelease = (attenuation > detectorAverage);
float rate = isRelease ? satReleaseRate :
1;
detectorAverage += (attenuation - detectorAverage) * rate;
detectorAverage = std::min(
1.
0f, detectorAverage);
// Fix gremlins.
if (std::isnan(detectorAverage)) detectorAverage =
1;
if (std::isinf(detectorAverage)) detectorAverage =
1;
// Exponential approach to desired gain.
if (envelopeRate <
1) {
// Attack - reduce gain to desired.
compressorGain += (scaledDesiredGain - compressorGain) * envelopeRate;
}
else {
// Release - exponentially increase gain to 1.0
compressorGain *= envelopeRate;
compressorGain = std::min(
1.
0f, compressorGain);
}
// Warp pre-compression gain to smooth out sharp exponential transition
// points.
float postWarpCompressorGain =
fdlibm_sinf(
0.
5f * M_PI * compressorGain);
// Calculate total gain using master gain and effect blend.
float totalGain =
dryMix + wetMix * masterLinearGain * postWarpCompressorGain;
// Calculate metering.
float dbRealGain =
20 * fdlibm_log10f(postWarpCompressorGain);
if (dbRealGain < m_meteringGain)
m_meteringGain = dbRealGain;
else
m_meteringGain += (dbRealGain - m_meteringGain) * m_meteringReleaseK;
// Apply final gain.
for (
unsigned i =
0; i < numberOfChannels; ++i) {
float* delayBuffer = m_preDelayBuffers[i].get();
destinationChannels[i][frameIndex] =
delayBuffer[preDelayReadIndex] * totalGain;
}
frameIndex++;
preDelayReadIndex = (preDelayReadIndex +
1) & MaxPreDelayFramesMask;
preDelayWriteIndex = (preDelayWriteIndex +
1) & MaxPreDelayFramesMask;
}
// Locals back to member variables.
m_preDelayReadIndex = preDelayReadIndex;
m_preDelayWriteIndex = preDelayWriteIndex;
m_detectorAverage =
DenormalDisabler::flushDenormalFloatToZero(detectorAverage);
m_compressorGain =
DenormalDisabler::flushDenormalFloatToZero(compressorGain);
}
}
}
void DynamicsCompressorKernel::reset() {
m_detectorAverage =
0;
m_compressorGain =
1;
m_meteringGain =
1;
// Predelay section.
for (
unsigned i =
0; i < m_preDelayBuffers.Length(); ++i)
memset(m_preDelayBuffers[i].get(),
0,
sizeof(
float) * MaxPreDelayFrames);
m_preDelayReadIndex =
0;
m_preDelayWriteIndex = DefaultPreDelayFrames;
m_maxAttackCompressionDiffDb = -
1;
// uninitialized state
}
}
// namespace WebCore
