reflow comments in modules/{webaudio,vr}

third_party/WebKit/Source/modules/webaudio/ScriptProcessorNode.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 34 matching lines @@
                                                unsigned numberOfOutputChannels)
     : AudioHandler(NodeTypeJavaScript, node, sampleRate),
       m_doubleBufferIndex(0),
       m_bufferSize(bufferSize),
       m_bufferReadWriteIndex(0),
       m_numberOfInputChannels(numberOfInputChannels),
       m_numberOfOutputChannels(numberOfOutputChannels),
       m_internalInputBus(AudioBus::create(numberOfInputChannels,
                                           ProcessingSizeInFrames,
                                           false)) {
-  // Regardless of the allowed buffer sizes, we still need to process at the granularity of the AudioNode.
+  // Regardless of the allowed buffer sizes, we still need to process at the
+  // granularity of the AudioNode.
   if (m_bufferSize < ProcessingSizeInFrames)
     m_bufferSize = ProcessingSizeInFrames;
 
   DCHECK_LE(numberOfInputChannels, BaseAudioContext::maxNumberOfChannels());
 
   addInput();
   addOutput(numberOfOutputChannels);
 
   m_channelCount = numberOfInputChannels;
   setInternalChannelCountMode(Explicit);
@@ skipping 16 matching lines @@
   uninitialize();
 }
 
 void ScriptProcessorHandler::initialize() {
   if (isInitialized())
     return;
 
   float sampleRate = context()->sampleRate();
 
   // Create double buffers on both the input and output sides.
-  // These AudioBuffers will be directly accessed in the main thread by JavaScript.
+  // These AudioBuffers will be directly accessed in the main thread by
+  // JavaScript.
   for (unsigned i = 0; i < 2; ++i) {
     AudioBuffer* inputBuffer =
         m_numberOfInputChannels ? AudioBuffer::create(m_numberOfInputChannels,
                                                       bufferSize(), sampleRate)
                                 : 0;
     AudioBuffer* outputBuffer =
         m_numberOfOutputChannels ? AudioBuffer::create(m_numberOfOutputChannels,
                                                        bufferSize(), sampleRate)
                                  : 0;
 
     m_inputBuffers.append(inputBuffer);
     m_outputBuffers.append(outputBuffer);
   }
 
   AudioHandler::initialize();
 }
 
 void ScriptProcessorHandler::process(size_t framesToProcess) {
   // Discussion about inputs and outputs:
-  // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input and output (see inputBus and outputBus below).
-  // Additionally, there is a double-buffering for input and output which is exposed directly to JavaScript (see inputBuffer and outputBuffer below).
-  // This node is the producer for inputBuffer and the consumer for outputBuffer.
-  // The JavaScript code is the consumer of inputBuffer and the producer for outputBuffer.
+  // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input
+  // and output (see inputBus and outputBus below).  Additionally, there is a
+  // double-buffering for input and output which is exposed directly to
+  // JavaScript (see inputBuffer and outputBuffer below).  This node is the
+  // producer for inputBuffer and the consumer for outputBuffer.  The JavaScript
+  // code is the consumer of inputBuffer and the producer for outputBuffer.
 
   // Get input and output busses.
   AudioBus* inputBus = input(0).bus();
   AudioBus* outputBus = output(0).bus();
 
-  // Get input and output buffers. We double-buffer both the input and output sides.
+  // Get input and output buffers. We double-buffer both the input and output
+  // sides.
   unsigned doubleBufferIndex = this->doubleBufferIndex();
   bool isDoubleBufferIndexGood = doubleBufferIndex < 2 &&
                                  doubleBufferIndex < m_inputBuffers.size() &&
                                  doubleBufferIndex < m_outputBuffers.size();
   DCHECK(isDoubleBufferIndexGood);
   if (!isDoubleBufferIndexGood)
     return;
 
   AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
   AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
 
   // Check the consistency of input and output buffers.
   unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
   bool buffersAreGood =
       outputBuffer && bufferSize() == outputBuffer->length() &&
       m_bufferReadWriteIndex + framesToProcess <= bufferSize();
 
   // If the number of input channels is zero, it's ok to have inputBuffer = 0.
   if (m_internalInputBus->numberOfChannels())
     buffersAreGood =
         buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
 
   DCHECK(buffersAreGood);
   if (!buffersAreGood)
     return;
 
-  // We assume that bufferSize() is evenly divisible by framesToProcess - should always be true, but we should still check.
+  // We assume that bufferSize() is evenly divisible by framesToProcess - should
+  // always be true, but we should still check.
   bool isFramesToProcessGood = framesToProcess &&
                                bufferSize() >= framesToProcess &&
                                !(bufferSize() % framesToProcess);
   DCHECK(isFramesToProcessGood);
   if (!isFramesToProcessGood)
     return;
 
   unsigned numberOfOutputChannels = outputBus->numberOfChannels();
 
   bool channelsAreGood = (numberOfInputChannels == m_numberOfInputChannels) &&
@@ skipping 13 matching lines @@
   // Copy from the output buffer to the output.
   for (unsigned i = 0; i < numberOfOutputChannels; ++i)
     memcpy(outputBus->channel(i)->mutableData(),
            outputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex,
            sizeof(float) * framesToProcess);
 
   // Update the buffering index.
   m_bufferReadWriteIndex =
       (m_bufferReadWriteIndex + framesToProcess) % bufferSize();
 
-  // m_bufferReadWriteIndex will wrap back around to 0 when the current input and output buffers are full.
+  // m_bufferReadWriteIndex will wrap back around to 0 when the current input
+  // and output buffers are full.
   // When this happens, fire an event and swap buffers.
   if (!m_bufferReadWriteIndex) {
-    // Avoid building up requests on the main thread to fire process events when they're not being handled.
-    // This could be a problem if the main thread is very busy doing other things and is being held up handling previous requests.
-    // The audio thread can't block on this lock, so we call tryLock() instead.
+    // Avoid building up requests on the main thread to fire process events when
+    // they're not being handled.  This could be a problem if the main thread is
+    // very busy doing other things and is being held up handling previous
+    // requests.  The audio thread can't block on this lock, so we call
+    // tryLock() instead.
     MutexTryLocker tryLocker(m_processEventLock);
     if (!tryLocker.locked()) {
-      // We're late in handling the previous request. The main thread must be very busy.
-      // The best we can do is clear out the buffer ourself here.
+      // We're late in handling the previous request. The main thread must be
+      // very busy.  The best we can do is clear out the buffer ourself here.
       outputBuffer->zero();
     } else if (context()->getExecutionContext()) {
       // With the realtime context, execute the script code asynchronously
       // and do not wait.
       if (context()->hasRealtimeConstraint()) {
         // Fire the event on the main thread with the appropriate buffer
         // index.
         context()->getExecutionContext()->postTask(
             BLINK_FROM_HERE,
             createCrossThreadTask(&ScriptProcessorHandler::fireProcessEvent,
@@ skipping 33 matching lines @@
   AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
   DCHECK(outputBuffer);
   if (!outputBuffer)
     return;
 
   // Avoid firing the event if the document has already gone away.
   if (node() && context() && context()->getExecutionContext()) {
     // This synchronizes with process().
     MutexLocker processLocker(m_processEventLock);
 
-    // Calculate a playbackTime with the buffersize which needs to be processed each time onaudioprocess is called.
-    // The outputBuffer being passed to JS will be played after exhuasting previous outputBuffer by double-buffering.
+    // Calculate a playbackTime with the buffersize which needs to be processed
+    // each time onaudioprocess is called.  The outputBuffer being passed to JS
+    // will be played after exhuasting previous outputBuffer by
+    // double-buffering.
     double playbackTime = (context()->currentSampleFrame() + m_bufferSize) /
                           static_cast<double>(context()->sampleRate());
 
     // Call the JavaScript event handler which will do the audio processing.
     node()->dispatchEvent(
         AudioProcessingEvent::create(inputBuffer, outputBuffer, playbackTime));
   }
 }
 
 void ScriptProcessorHandler::fireProcessEventForOfflineAudioContext(
@@ skipping 68 matching lines @@
                                          size_t bufferSize,
                                          unsigned numberOfInputChannels,
                                          unsigned numberOfOutputChannels)
     : AudioNode(context), ActiveScriptWrappable(this) {
   setHandler(ScriptProcessorHandler::create(*this, sampleRate, bufferSize,
                                             numberOfInputChannels,
                                             numberOfOutputChannels));
 }
 
 static size_t chooseBufferSize() {
-  // Choose a buffer size based on the audio hardware buffer size. Arbitarily make it a power of
-  // two that is 4 times greater than the hardware buffer size.
+  // Choose a buffer size based on the audio hardware buffer size. Arbitarily
+  // make it a power of two that is 4 times greater than the hardware buffer
+  // size.
   // FIXME: What is the best way to choose this?
   size_t hardwareBufferSize = Platform::current()->audioHardwareBufferSize();
   size_t bufferSize =
       1 << static_cast<unsigned>(log2(4 * hardwareBufferSize) + 0.5);
 
   if (bufferSize < 256)
     return 256;
   if (bufferSize > 16384)
     return 16384;
 
@@ skipping 114 matching lines @@
 
   // If |onaudioprocess| event handler is defined, the node should not be
   // GCed even if it is out of scope.
   if (hasEventListeners(EventTypeNames::audioprocess))
     return true;
 
   return false;
 }
 
 }  // namespace blink