blink: Rename modules/ method to prefix with get when they collide.

third_party/WebKit/Source/modules/webaudio/BiquadDSPKernel.cpp

 /*
  * Copyright (C) 2010, 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
@@ skipping 20 matching lines @@
 namespace blink {
 
 // FIXME: As a recursive linear filter, depending on its parameters, a biquad filter can have
 // an infinite tailTime. In practice, Biquad filters do not usually (except for very high resonance values)
 // have a tailTime of longer than approx. 200ms. This value could possibly be calculated based on the
 // settings of the Biquad.
 static const double MaxBiquadDelayTime = 0.2;
 
 void BiquadDSPKernel::updateCoefficientsIfNecessary(int framesToProcess)
 {
-    if (biquadProcessor()->filterCoefficientsDirty()) {
+    if (getBiquadProcessor()->filterCoefficientsDirty()) {
         float cutoffFrequency[AudioUtilities::kRenderQuantumFrames];
         float Q[AudioUtilities::kRenderQuantumFrames];
         float gain[AudioUtilities::kRenderQuantumFrames];
         float detune[AudioUtilities::kRenderQuantumFrames]; // in Cents
 
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(
             static_cast<unsigned>(framesToProcess) <= AudioUtilities::kRenderQuantumFrames);
 
-        if (biquadProcessor()->hasSampleAccurateValues()) {
-            biquadProcessor()->parameter1().calculateSampleAccurateValues(cutoffFrequency, framesToProcess);
-            biquadProcessor()->parameter2().calculateSampleAccurateValues(Q, framesToProcess);
-            biquadProcessor()->parameter3().calculateSampleAccurateValues(gain, framesToProcess);
-            biquadProcessor()->parameter4().calculateSampleAccurateValues(detune, framesToProcess);
+        if (getBiquadProcessor()->hasSampleAccurateValues()) {
+            getBiquadProcessor()->parameter1().calculateSampleAccurateValues(cutoffFrequency, framesToProcess);
+            getBiquadProcessor()->parameter2().calculateSampleAccurateValues(Q, framesToProcess);
+            getBiquadProcessor()->parameter3().calculateSampleAccurateValues(gain, framesToProcess);
+            getBiquadProcessor()->parameter4().calculateSampleAccurateValues(detune, framesToProcess);
             updateCoefficients(framesToProcess, cutoffFrequency, Q, gain, detune);
         } else {
-            cutoffFrequency[0] = biquadProcessor()->parameter1().smoothedValue();
-            Q[0] = biquadProcessor()->parameter2().smoothedValue();
-            gain[0] = biquadProcessor()->parameter3().smoothedValue();
-            detune[0] = biquadProcessor()->parameter4().smoothedValue();
+            cutoffFrequency[0] = getBiquadProcessor()->parameter1().smoothedValue();
+            Q[0] = getBiquadProcessor()->parameter2().smoothedValue();
+            gain[0] = getBiquadProcessor()->parameter3().smoothedValue();
+            detune[0] = getBiquadProcessor()->parameter4().smoothedValue();
             updateCoefficients(1, cutoffFrequency, Q, gain, detune);
         }
     }
 }
 
 void BiquadDSPKernel::updateCoefficients(int numberOfFrames, const float* cutoffFrequency, const float* Q, const float* gain, const float* detune)
 {
     // Convert from Hertz to normalized frequency 0 -> 1.
     double nyquist = this->nyquist();
 
     m_biquad.setHasSampleAccurateValues(numberOfFrames > 1);
 
     for (int k = 0; k < numberOfFrames; ++k) {
         double normalizedFrequency = cutoffFrequency[k] / nyquist;
 
         // Offset frequency by detune.
         if (detune[k])
             normalizedFrequency *= pow(2, detune[k] / 1200);
 
         // Configure the biquad with the new filter parameters for the appropriate type of filter.
-        switch (biquadProcessor()->type()) {
+        switch (getBiquadProcessor()->type()) {
         case BiquadProcessor::LowPass:
             m_biquad.setLowpassParams(k, normalizedFrequency, Q[k]);
             break;
 
         case BiquadProcessor::HighPass:
             m_biquad.setHighpassParams(k, normalizedFrequency, Q[k]);
             break;
 
         case BiquadProcessor::BandPass:
             m_biquad.setBandpassParams(k, normalizedFrequency, Q[k]);
@@ skipping 19 matching lines @@
             m_biquad.setAllpassParams(k, normalizedFrequency, Q[k]);
             break;
         }
     }
 }
 
 void BiquadDSPKernel::process(const float* source, float* destination, size_t framesToProcess)
 {
     ASSERT(source);
     ASSERT(destination);
-    ASSERT(biquadProcessor());
+    ASSERT(getBiquadProcessor());
 
     // Recompute filter coefficients if any of the parameters have changed.
     // FIXME: as an optimization, implement a way that a Biquad object can simply copy its internal filter coefficients from another Biquad object.
     // Then re-factor this code to only run for the first BiquadDSPKernel of each BiquadProcessor.
 
 
     // The audio thread can't block on this lock; skip updating the coefficients for this block if
     // necessary. We'll get them the next time around.
     {
         MutexTryLocker tryLocker(m_processLock);
@@ skipping 33 matching lines @@
         //
         // The BiquadDSPKernel object here (along with it's Biquad object) is for querying the
         // frequency response and is NOT the same as the one in process() which is used for
         // performing the actual filtering. This one is is created in
         // BiquadProcessor::getFrequencyResponse for this purpose. Both, however, point to the same
         // BiquadProcessor object.
         //
         // FIXME: Simplify this: crbug.com/390266
         MutexLocker processLocker(m_processLock);
 
-        cutoffFrequency = biquadProcessor()->parameter1().value();
-        Q = biquadProcessor()->parameter2().value();
-        gain = biquadProcessor()->parameter3().value();
-        detune = biquadProcessor()->parameter4().value();
+        cutoffFrequency = getBiquadProcessor()->parameter1().value();
+        Q = getBiquadProcessor()->parameter2().value();
+        gain = getBiquadProcessor()->parameter3().value();
+        detune = getBiquadProcessor()->parameter4().value();
     }
 
     updateCoefficients(1, &cutoffFrequency, &Q, &gain, &detune);
 
     m_biquad.getFrequencyResponse(nFrequencies, frequency.data(), magResponse, phaseResponse);
 }
 
 double BiquadDSPKernel::tailTime() const
 {
     return MaxBiquadDelayTime;
 }
 
 double BiquadDSPKernel::latencyTime() const
 {
     return 0;
 }
 
 } // namespace blink