reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/ReverbConvolverStage.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 51 matching lines @@
   } else {
     ASSERT(!stageOffset);
     ASSERT(stageLength <= fftSize / 2);
 
     m_directKernel = wrapUnique(new AudioFloatArray(fftSize / 2));
     m_directKernel->copyToRange(impulseResponse, 0, stageLength);
     m_directConvolver = wrapUnique(new DirectConvolver(renderSliceSize));
   }
   m_temporaryBuffer.allocate(renderSliceSize);
 
-  // The convolution stage at offset stageOffset needs to have a corresponding delay to cancel out the offset.
+  // The convolution stage at offset stageOffset needs to have a corresponding
+  // delay to cancel out the offset.
   size_t totalDelay = stageOffset + reverbTotalLatency;
 
-  // But, the FFT convolution itself incurs fftSize / 2 latency, so subtract this out...
+  // But, the FFT convolution itself incurs fftSize / 2 latency, so subtract
+  // this out...
   size_t halfSize = fftSize / 2;
   if (!m_directMode) {
     ASSERT(totalDelay >= halfSize);
     if (totalDelay >= halfSize)
       totalDelay -= halfSize;
   }
 
-  // We divide up the total delay, into pre and post delay sections so that we can schedule at exactly the moment when the FFT will happen.
-  // This is coordinated with the other stages, so they don't all do their FFTs at the same time...
+  // We divide up the total delay, into pre and post delay sections so that we
+  // can schedule at exactly the moment when the FFT will happen.  This is
+  // coordinated with the other stages, so they don't all do their FFTs at the
+  // same time...
   int maxPreDelayLength = std::min(halfSize, totalDelay);
   m_preDelayLength = totalDelay > 0 ? renderPhase % maxPreDelayLength : 0;
   if (m_preDelayLength > totalDelay)
     m_preDelayLength = 0;
 
   m_postDelayLength = totalDelay - m_preDelayLength;
   m_preReadWriteIndex = 0;
   m_framesProcessed = 0;  // total frames processed so far
 
   size_t delayBufferSize =
@@ skipping 17 matching lines @@
   if (!source)
     return;
 
   // Deal with pre-delay stream : note special handling of zero delay.
 
   const float* preDelayedSource;
   float* preDelayedDestination;
   float* temporaryBuffer;
   bool isTemporaryBufferSafe = false;
   if (m_preDelayLength > 0) {
-    // Handles both the read case (call to process() ) and the write case (memcpy() )
+    // Handles both the read case (call to process() ) and the write case
+    // (memcpy() )
     bool isPreDelaySafe =
         m_preReadWriteIndex + framesToProcess <= m_preDelayBuffer.size();
     ASSERT(isPreDelaySafe);
     if (!isPreDelaySafe)
       return;
 
     isTemporaryBufferSafe = framesToProcess <= m_temporaryBuffer.size();
 
     preDelayedDestination = m_preDelayBuffer.data() + m_preReadWriteIndex;
     preDelayedSource = preDelayedDestination;
     temporaryBuffer = m_temporaryBuffer.data();
   } else {
     // Zero delay
     preDelayedDestination = 0;
     preDelayedSource = source;
     temporaryBuffer = m_preDelayBuffer.data();
 
     isTemporaryBufferSafe = framesToProcess <= m_preDelayBuffer.size();
   }
 
   ASSERT(isTemporaryBufferSafe);
   if (!isTemporaryBufferSafe)
     return;
 
   if (m_framesProcessed < m_preDelayLength) {
-    // For the first m_preDelayLength frames don't process the convolver, instead simply buffer in the pre-delay.
-    // But while buffering the pre-delay, we still need to update our index.
+    // For the first m_preDelayLength frames don't process the convolver,
+    // instead simply buffer in the pre-delay.  But while buffering the
+    // pre-delay, we still need to update our index.
     m_accumulationBuffer->updateReadIndex(&m_accumulationReadIndex,
                                           framesToProcess);
   } else {
     // Now, run the convolution (into the delay buffer).
     // An expensive FFT will happen every fftSize / 2 frames.
     // We process in-place here...
     if (!m_directMode)
       m_fftConvolver->process(m_fftKernel.get(), preDelayedSource,
                               temporaryBuffer, framesToProcess);
     else
@@ skipping 24 matching lines @@
     m_fftConvolver->reset();
   else
     m_directConvolver->reset();
   m_preDelayBuffer.zero();
   m_accumulationReadIndex = 0;
   m_inputReadIndex = 0;
   m_framesProcessed = 0;
 }
 
 }  // namespace blink