reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/DynamicsCompressorKernel.cpp

 /*
  * 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
@@ skipping 76 matching lines @@
     m_lastPreDelayFrames = preDelayFrames;
     for (unsigned i = 0; i < m_preDelayBuffers.size(); ++i)
       m_preDelayBuffers[i]->zero();
 
     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.
+// 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) {
@@ skipping 35 matching lines @@
 float DynamicsCompressorKernel::kAtSlope(float desiredSlope) {
   float xDb = m_dbThreshold + m_dbKnee;
   float x = decibelsToLinear(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.
+    // 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;
     }
 
@@ skipping 80 matching lines @@
   // 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)
+  // 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 a = 0.9999999999999998f * y1 + 1.8432219684323923e-16f * y2 -
             1.9373394351676423e-16f * y3 + 8.824516011816245e-18f * y4;
   float b = -1.5788320352845888f * y1 + 2.3305837032074286f * y2 -
             0.9141194204840429f * y3 + 0.1623677525612032f * y4;
   float c = 0.5334142869106424f * y1 - 1.272736789213631f * y2 +
             0.9258856042207512f * y3 - 0.18656310191776226f * y4;
   float d = 0.08783463138207234f * y1 - 0.1694162967925622f * y2 +
             0.08588057951595272f * y3 - 0.00429891410546283f * y4;
   float e = -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.
+  // 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 = asinf(desiredGain) / (piOverTwoFloat);
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // 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.
+    // 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.
+    // compressionDiffDb is the difference between current compression level and
+    // the desired level.
     float compressionDiffDb =
         linearToDecibels(m_compressorGain / scaledDesiredGain);
 
     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.
+      // Adaptive release - higher compression (lower compressionDiffDb)
+      // releases faster.
 
       // Contain within range: -12 -> 0 then scale to go from 0 -> 3
       float x = compressionDiffDb;
       x = clampTo(x, -12.0f, 0.0f);
       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.
+      // 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 = a + b * x + c * x2 + d * x3 + e * x4;
 
 #define kSpacingDb 5
       float dbPerFrame = kSpacingDb / releaseFrames;
 
       envelopeRate = decibelsToLinear(dbPerFrame);
     } else {
@@ skipping 24 matching lines @@
     {
       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.
+        // Predelay signal, computing compression amount from un-delayed
+        // version.
         for (unsigned i = 0; i < numberOfChannels; ++i) {
           float* delayBuffer = m_preDelayBuffers[i]->data();
           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).
+        // 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 = -linearToDecibels(attenuation);
         attenuationDb = std::max(2.0f, attenuationDb);
 
         float dbPerFrame = attenuationDb / satReleaseFrames;
 
         float satReleaseRate = decibelsToLinear(dbPerFrame) - 1;
@@ skipping 13 matching lines @@
         // 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.
+        // Warp pre-compression gain to smooth out sharp exponential transition
+        // points.
         float postWarpCompressorGain = sinf(piOverTwoFloat * compressorGain);
 
         // Calculate total gain using master gain and effect blend.
         float totalGain =
             dryMix + wetMix * masterLinearGain * postWarpCompressorGain;
 
         // Calculate metering.
         float dbRealGain = 20 * std::log10(postWarpCompressorGain);
         if (dbRealGain < m_meteringGain)
           m_meteringGain = dbRealGain;
@@ skipping 32 matching lines @@
   for (unsigned i = 0; i < m_preDelayBuffers.size(); ++i)
     m_preDelayBuffers[i]->zero();
 
   m_preDelayReadIndex = 0;
   m_preDelayWriteIndex = DefaultPreDelayFrames;
 
   m_maxAttackCompressionDiffDb = -1;  // uninitialized state
 }
 
 }  // namespace blink