reflow comments in modules/{webaudio,vr}

third_party/WebKit/Source/modules/webaudio/ConvolverNode.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 18 matching lines @@
 #include "modules/webaudio/AudioNodeInput.h"
 #include "modules/webaudio/AudioNodeOutput.h"
 #include "modules/webaudio/ConvolverNode.h"
 #include "modules/webaudio/ConvolverOptions.h"
 #include "platform/audio/Reverb.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 // Note about empirical tuning:
 // The maximum FFT size affects reverb performance and accuracy.
-// If the reverb is single-threaded and processes entirely in the real-time audio thread,
-// it's important not to make this too high.  In this case 8192 is a good value.
-// But, the Reverb object is multi-threaded, so we want this as high as possible without losing too much accuracy.
-// Very large FFTs will have worse phase errors. Given these constraints 32768 is a good compromise.
+// If the reverb is single-threaded and processes entirely in the real-time
+// audio thread, it's important not to make this too high.  In this case 8192 is
+// a good value.  But, the Reverb object is multi-threaded, so we want this as
+// high as possible without losing too much accuracy.  Very large FFTs will have
+// worse phase errors. Given these constraints 32768 is a good compromise.
 const size_t MaxFFTSize = 32768;
 
 namespace blink {
 
 ConvolverHandler::ConvolverHandler(AudioNode& node, float sampleRate)
     : AudioHandler(NodeTypeConvolver, node, sampleRate), m_normalize(true) {
   addInput();
   addOutput(2);
 
   // Node-specific default mixing rules.
@@ skipping 17 matching lines @@
   AudioBus* outputBus = output(0).bus();
   DCHECK(outputBus);
 
   // Synchronize with possible dynamic changes to the impulse response.
   MutexTryLocker tryLocker(m_processLock);
   if (tryLocker.locked()) {
     if (!isInitialized() || !m_reverb) {
       outputBus->zero();
     } else {
       // Process using the convolution engine.
-      // Note that we can handle the case where nothing is connected to the input, in which case we'll just feed silence into the convolver.
-      // FIXME:  If we wanted to get fancy we could try to factor in the 'tail time' and stop processing once the tail dies down if
+      // Note that we can handle the case where nothing is connected to the
+      // input, in which case we'll just feed silence into the convolver.
+      // FIXME:  If we wanted to get fancy we could try to factor in the 'tail
+      // time' and stop processing once the tail dies down if
       // we keep getting fed silence.
       m_reverb->process(input(0).bus(), outputBus, framesToProcess);
     }
   } else {
-    // Too bad - the tryLock() failed.  We must be in the middle of setting a new impulse response.
+    // Too bad - the tryLock() failed.  We must be in the middle of setting a
+    // new impulse response.
     outputBus->zero();
   }
 }
 
 void ConvolverHandler::setBuffer(AudioBuffer* buffer,
                                  ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
   if (!buffer)
     return;
 
   if (buffer->sampleRate() != context()->sampleRate()) {
     exceptionState.throwDOMException(
         NotSupportedError,
         "The buffer sample rate of " + String::number(buffer->sampleRate()) +
             " does not match the context rate of " +
             String::number(context()->sampleRate()) + " Hz.");
     return;
   }
 
   unsigned numberOfChannels = buffer->numberOfChannels();
   size_t bufferLength = buffer->length();
 
-  // The current implementation supports only 1-, 2-, or 4-channel impulse responses, with the
-  // 4-channel response being interpreted as true-stereo (see Reverb class).
+  // The current implementation supports only 1-, 2-, or 4-channel impulse
+  // responses, with the 4-channel response being interpreted as true-stereo
+  // (see Reverb class).
   bool isChannelCountGood =
       numberOfChannels == 1 || numberOfChannels == 2 || numberOfChannels == 4;
 
   if (!isChannelCountGood) {
     exceptionState.throwDOMException(
         NotSupportedError, "The buffer must have 1, 2, or 4 channels, not " +
                                String::number(numberOfChannels));
     return;
   }
 
-  // Wrap the AudioBuffer by an AudioBus. It's an efficient pointer set and not a memcpy().
-  // This memory is simply used in the Reverb constructor and no reference to it is kept for later use in that class.
+  // Wrap the AudioBuffer by an AudioBus. It's an efficient pointer set and not
+  // a memcpy().  This memory is simply used in the Reverb constructor and no
+  // reference to it is kept for later use in that class.
   RefPtr<AudioBus> bufferBus =
       AudioBus::create(numberOfChannels, bufferLength, false);
   for (unsigned i = 0; i < numberOfChannels; ++i)
     bufferBus->setChannelMemory(i, buffer->getChannelData(i)->data(),
                                 bufferLength);
 
   bufferBus->setSampleRate(buffer->sampleRate());
 
   // Create the reverb with the given impulse response.
   std::unique_ptr<Reverb> reverb = wrapUnique(
@@ skipping 13 matching lines @@
   return m_buffer.get();
 }
 
 double ConvolverHandler::tailTime() const {
   MutexTryLocker tryLocker(m_processLock);
   if (tryLocker.locked())
     return m_reverb
                ? m_reverb->impulseResponseLength() /
                      static_cast<double>(sampleRate())
                : 0;
-  // Since we don't want to block the Audio Device thread, we return a large value
-  // instead of trying to acquire the lock.
+  // Since we don't want to block the Audio Device thread, we return a large
+  // value instead of trying to acquire the lock.
   return std::numeric_limits<double>::infinity();
 }
 
 double ConvolverHandler::latencyTime() const {
   MutexTryLocker tryLocker(m_processLock);
   if (tryLocker.locked())
     return m_reverb
                ? m_reverb->latencyFrames() / static_cast<double>(sampleRate())
                : 0;
-  // Since we don't want to block the Audio Device thread, we return a large value
-  // instead of trying to acquire the lock.
+  // Since we don't want to block the Audio Device thread, we return a large
+  // value instead of trying to acquire the lock.
   return std::numeric_limits<double>::infinity();
 }
 
 // ----------------------------------------------------------------
 
 ConvolverNode::ConvolverNode(BaseAudioContext& context) : AudioNode(context) {
   setHandler(ConvolverHandler::create(*this, context.sampleRate()));
 }
 
 ConvolverNode* ConvolverNode::create(BaseAudioContext& context,
@@ skipping 41 matching lines @@
 
 bool ConvolverNode::normalize() const {
   return convolverHandler().normalize();
 }
 
 void ConvolverNode::setNormalize(bool normalize) {
   convolverHandler().setNormalize(normalize);
 }
 
 }  // namespace blink