Removing "using" declarations that import names in the C++ Standard library.(Source/platform/audio)

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 19 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 
 #include "platform/audio/DynamicsCompressorKernel.h"
 
 #include <algorithm>
 #include "platform/audio/AudioUtilities.h"
 #include "platform/audio/DenormalDisabler.h"
 #include "wtf/MathExtras.h"
 
-using namespace std;
-
 namespace blink {
 
 using namespace AudioUtilities;
 
 // 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)
@@ skipping 181 matching lines @@
     // Makeup gain.
     float fullRangeGain = saturate(1, k);
     float fullRangeMakeupGain = 1 / fullRangeGain;
 
     // Empirical/perceptual tuning.
     fullRangeMakeupGain = powf(fullRangeMakeupGain, 0.6f);
 
     float masterLinearGain = decibelsToLinear(dbPostGain) * fullRangeMakeupGain;
 
     // Attack parameters.
-    attackTime = max(0.001f, attackTime);
+    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.
@@ skipping 62 matching lines @@
             // 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 = max(-12.0f, x);
-            x = min(0.0f, x);
+            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 = decibelsToLinear(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 = max(0.5f, m_maxAttackCompressionDiffDb);
+            float effAttenDiffDb = std::max(0.5f, m_maxAttackCompressionDiffDb);
 
             float x = 0.25f / effAttenDiffDb;
             envelopeRate = 1 - powf(x, 1 / attackFrames);
         }
 
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         // Inner loop - calculate shaped power average - apply compression.
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
         {
@@ skipping 24 matching lines @@
 
                 // 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 = -linearToDecibels(attenuation);
-                attenuationDb = max(2.0f, attenuationDb);
+                attenuationDb = std::max(2.0f, attenuationDb);
 
                 float dbPerFrame = attenuationDb / satReleaseFrames;
 
                 float satReleaseRate = decibelsToLinear(dbPerFrame) - 1;
 
                 bool isRelease = (attenuation > detectorAverage);
                 float rate = isRelease ? satReleaseRate : 1;
 
                 detectorAverage += (attenuation - detectorAverage) * rate;
-                detectorAverage = min(1.0f, detectorAverage);
+                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 = min(1.0f, compressorGain);
+                    compressorGain = std::min(1.0f, compressorGain);
                 }
 
                 // 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 * log10(postWarpCompressorGain);
+                float dbRealGain = 20 * std::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]->data();
                     destinationChannels[i][frameIndex] = delayBuffer[preDelayReadIndex] * totalGain;
                 }
@@ skipping 24 matching lines @@
 
     m_preDelayReadIndex = 0;
     m_preDelayWriteIndex = DefaultPreDelayFrames;
 
     m_maxAttackCompressionDiffDb = -1; // uninitialized state
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)