reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/Reverb.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
@@ skipping 24 matching lines @@
 #include <memory>
 
 #if OS(MACOSX)
 using namespace std;
 #endif
 
 namespace blink {
 
 using namespace VectorMath;
 
-// Empirical gain calibration tested across many impulse responses to ensure perceived volume is same as dry (unprocessed) signal
+// Empirical gain calibration tested across many impulse responses to ensure
+// perceived volume is same as dry (unprocessed) signal
 const float GainCalibration = -58;
 const float GainCalibrationSampleRate = 44100;
 
-// A minimum power value to when normalizing a silent (or very quiet) impulse response
+// A minimum power value to when normalizing a silent (or very quiet) impulse
+// response
 const float MinPower = 0.000125f;
 
 static float calculateNormalizationScale(AudioBus* response) {
   // Normalize by RMS power
   size_t numberOfChannels = response->numberOfChannels();
   size_t length = response->length();
 
   float power = 0;
 
   for (size_t i = 0; i < numberOfChannels; ++i) {
@@ skipping 36 matching lines @@
   if (normalize) {
     scale = calculateNormalizationScale(impulseResponse);
 
     if (scale)
       impulseResponse->scale(scale);
   }
 
   initialize(impulseResponse, renderSliceSize, maxFFTSize, numberOfChannels,
              useBackgroundThreads);
 
-  // Undo scaling since this shouldn't be a destructive operation on impulseResponse.
+  // Undo scaling since this shouldn't be a destructive operation on
+  // impulseResponse.
   // FIXME: What about roundoff? Perhaps consider making a temporary scaled copy
   // instead of scaling and unscaling in place.
   if (normalize && scale)
     impulseResponse->scale(1 / scale);
 }
 
 void Reverb::initialize(AudioBus* impulseResponseBuffer,
                         size_t renderSliceSize,
                         size_t maxFFTSize,
                         size_t numberOfChannels,
                         bool useBackgroundThreads) {
   m_impulseResponseLength = impulseResponseBuffer->length();
 
-  // The reverb can handle a mono impulse response and still do stereo processing
+  // The reverb can handle a mono impulse response and still do stereo
+  // processing
   size_t numResponseChannels = impulseResponseBuffer->numberOfChannels();
   m_convolvers.reserveCapacity(numberOfChannels);
 
   int convolverRenderPhase = 0;
   for (size_t i = 0; i < numResponseChannels; ++i) {
     AudioChannel* channel = impulseResponseBuffer->channel(i);
 
     std::unique_ptr<ReverbConvolver> convolver = wrapUnique(
         new ReverbConvolver(channel, renderSliceSize, maxFFTSize,
                             convolverRenderPhase, useBackgroundThreads));
     m_convolvers.append(std::move(convolver));
 
     convolverRenderPhase += renderSliceSize;
   }
 
-  // For "True" stereo processing we allocate a temporary buffer to avoid repeatedly allocating it in the process() method.
-  // It can be bad to allocate memory in a real-time thread.
+  // For "True" stereo processing we allocate a temporary buffer to avoid
+  // repeatedly allocating it in the process() method.  It can be bad to
+  // allocate memory in a real-time thread.
   if (numResponseChannels == 4)
     m_tempBuffer = AudioBus::create(2, MaxFrameSize);
 }
 
 void Reverb::process(const AudioBus* sourceBus,
                      AudioBus* destinationBus,
                      size_t framesToProcess) {
   // Do a fairly comprehensive sanity check.
-  // If these conditions are satisfied, all of the source and destination pointers will be valid for the various matrixing cases.
+  // If these conditions are satisfied, all of the source and destination
+  // pointers will be valid for the various matrixing cases.
   bool isSafeToProcess = sourceBus && destinationBus &&
                          sourceBus->numberOfChannels() > 0 &&
                          destinationBus->numberOfChannels() > 0 &&
                          framesToProcess <= MaxFrameSize &&
                          framesToProcess <= sourceBus->length() &&
                          framesToProcess <= destinationBus->length();
 
   ASSERT(isSafeToProcess);
   if (!isSafeToProcess)
     return;
@@ skipping 67 matching lines @@
                              framesToProcess);
 
     // Process right virtual source
     m_convolvers[2]->process(sourceChannelR, tempChannelL, framesToProcess);
     m_convolvers[3]->process(sourceChannelR, tempChannelR, framesToProcess);
 
     destinationBus->sumFrom(*m_tempBuffer);
   } else if (numInputChannels == 1 && numReverbChannels == 4 &&
              numOutputChannels == 2) {
     // 1 -> 4 -> 2 (Processing mono with "True" stereo impulse response)
-    // This is an inefficient use of a four-channel impulse response, but we should handle the case.
+    // This is an inefficient use of a four-channel impulse response, but we
+    // should handle the case.
     AudioChannel* destinationChannelR = destinationBus->channel(1);
 
     AudioChannel* tempChannelL = m_tempBuffer->channel(0);
     AudioChannel* tempChannelR = m_tempBuffer->channel(1);
 
     // Process left virtual source
     m_convolvers[0]->process(sourceChannelL, destinationChannelL,
                              framesToProcess);
     m_convolvers[1]->process(sourceChannelL, destinationChannelR,
                              framesToProcess);
@@ skipping 13 matching lines @@
 void Reverb::reset() {
   for (size_t i = 0; i < m_convolvers.size(); ++i)
     m_convolvers[i]->reset();
 }
 
 size_t Reverb::latencyFrames() const {
   return !m_convolvers.isEmpty() ? m_convolvers.first()->latencyFrames() : 0;
 }
 
 }  // namespace blink