reflow comments in modules/{webaudio,vr}

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 13 matching lines @@
  */
 
 #include "modules/webaudio/BiquadDSPKernel.h"
 #include "platform/audio/AudioUtilities.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Vector.h"
 #include <limits.h>
 
 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
+// 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 (getBiquadProcessor()->filterCoefficientsDirty()) {
     float cutoffFrequency[AudioUtilities::kRenderQuantumFrames];
     float Q[AudioUtilities::kRenderQuantumFrames];
     float gain[AudioUtilities::kRenderQuantumFrames];
     float detune[AudioUtilities::kRenderQuantumFrames];  // in Cents
 
@@ skipping 30 matching lines @@
 
   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.
+    // Configure the biquad with the new filter parameters for the appropriate
+    // type of filter.
     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:
@@ skipping 24 matching lines @@
 }
 
 void BiquadDSPKernel::process(const float* source,
                               float* destination,
                               size_t framesToProcess) {
   DCHECK(source);
   DCHECK(destination);
   DCHECK(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.
+  // 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.
+  // 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);
     if (tryLocker.locked())
       updateCoefficientsIfNecessary(framesToProcess);
   }
 
   m_biquad.process(source, destination, framesToProcess);
 }
 
 void BiquadDSPKernel::getFrequencyResponse(int nFrequencies,
@@ skipping 13 matching lines @@
   // with 1 equal to the Nyquist frequency.
   for (int k = 0; k < nFrequencies; ++k)
     frequency[k] = clampTo<float>(frequencyHz[k] / nyquist);
 
   float cutoffFrequency;
   float Q;
   float gain;
   float detune;  // in Cents
 
   {
-    // Get a copy of the current biquad filter coefficients so we can update the biquad with
-    // these values. We need to synchronize with process() to prevent process() from updating
-    // the filter coefficients while we're trying to access them. The process will update it
-    // next time around.
+    // Get a copy of the current biquad filter coefficients so we can update the
+    // biquad with these values. We need to synchronize with process() to
+    // prevent process() from updating the filter coefficients while we're
+    // trying to access them. The process will update it next time around.
     //
-    // 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.
+    // 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 = 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