The Tor Browser / file revision

 /*

  * 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 "DenormalDisabler.h"

 #include <algorithm>

 #include "mozilla/FloatingPoint.h"

 #include "mozilla/Constants.h"

 #include "WebAudioUtils.h"

 using namespace std;

 using namespace mozilla::dom; // for WebAudioUtils

 using mozilla::IsInfinite;

 using mozilla::IsNaN;

 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.SizeOfExcludingThis(aMallocSizeOf);

     for (size_t i = 0; i < m_preDelayBuffers.Length(); i++) {

         amount += m_preDelayBuffers[i].SizeOfExcludingThis(aMallocSizeOf);

     }

     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(new 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], 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 - 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.1;

     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 = powf(fullRangeMakeupGain, 0.6f);

     float masterLinearGain = WebAudioUtils::ConvertDecibelsToLinear(dbPostGain) * fullRangeMakeupGain;

     // Attack parameters.

     attackTime = 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 (IsNaN(m_detectorAverage))

             m_detectorAverage = 1;

         if (IsInfinite(m_detectorAverage))

             m_detectorAverage = 1;

         float desiredGain = m_detectorAverage;

         // Pre-warp so we get desiredGain after sin() warp below.

         float scaledDesiredGain = 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 = WebAudioUtils::ConvertLinearToDecibels(m_compressorGain / scaledDesiredGain, -1000.0f);

         if (isReleasing) {

             // Release mode - compressionDiffDb should be negative dB

             m_maxAttackCompressionDiffDb = -1;

             // Fix gremlins.

             if (IsNaN(compressionDiffDb))

                 compressionDiffDb = -1;

             if (IsInfinite(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 = max(-12.0f, x);

             x = 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 (IsNaN(compressionDiffDb))

                 compressionDiffDb = 1;

             if (IsInfinite(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 = max(0.5f, m_maxAttackCompressionDiffDb);

             float x = 0.25f / effAttenDiffDb;

             envelopeRate = 1 - 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];

                     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;

                 float attenuationDb = -WebAudioUtils::ConvertLinearToDecibels(attenuation, -1000.0f);

                 attenuationDb = 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 = min(1.0f, detectorAverage);

                 // Fix gremlins.

                 if (IsNaN(detectorAverage))

                     detectorAverage = 1;

                 if (IsInfinite(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 = min(1.0f, compressorGain);

                 }

                 // Warp pre-compression gain to smooth out sharp exponential transition points.

                 float postWarpCompressorGain = 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 * log10(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];

                     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], 0, sizeof(float) * MaxPreDelayFrames);

     m_preDelayReadIndex = 0;

     m_preDelayWriteIndex = DefaultPreDelayFrames;

     m_maxAttackCompressionDiffDb = -1; // uninitialized state

 }

 } // namespace WebCore