reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/MultiChannelResampler.cpp

 /*
  * Copyright (C) 2011 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 16 matching lines @@
  */
 
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/MultiChannelResampler.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
-// ChannelProvider provides a single channel of audio data (one channel at a time) for each channel
-// of data provided to us in a multi-channel provider.
+// ChannelProvider provides a single channel of audio data (one channel at a
+// time) for each channel of data provided to us in a multi-channel provider.
 
 class ChannelProvider final : public AudioSourceProvider {
  public:
   ChannelProvider(AudioSourceProvider* multiChannelProvider,
                   unsigned numberOfChannels)
       : m_multiChannelProvider(multiChannelProvider),
         m_numberOfChannels(numberOfChannels),
         m_currentChannel(0),
         m_framesToProcess(0) {}
 
-  // provideInput() will be called once for each channel, starting with the first channel.
-  // Each time it's called, it will provide the next channel of data.
+  // provideInput() will be called once for each channel, starting with the
+  // first channel.  Each time it's called, it will provide the next channel of
+  // data.
   void provideInput(AudioBus* bus, size_t framesToProcess) override {
     bool isBusGood = bus && bus->numberOfChannels() == 1;
     ASSERT(isBusGood);
     if (!isBusGood)
       return;
 
-    // Get the data from the multi-channel provider when the first channel asks for it.
-    // For subsequent channels, we can just dish out the channel data from that (stored in m_multiChannelBus).
+    // Get the data from the multi-channel provider when the first channel asks
+    // for it.  For subsequent channels, we can just dish out the channel data
+    // from that (stored in m_multiChannelBus).
     if (!m_currentChannel) {
       m_framesToProcess = framesToProcess;
       m_multiChannelBus = AudioBus::create(m_numberOfChannels, framesToProcess);
       m_multiChannelProvider->provideInput(m_multiChannelBus.get(),
                                            framesToProcess);
     }
 
-    // All channels must ask for the same amount. This should always be the case, but let's just make sure.
+    // All channels must ask for the same amount. This should always be the
+    // case, but let's just make sure.
     bool isGood =
         m_multiChannelBus.get() && framesToProcess == m_framesToProcess;
     ASSERT(isGood);
     if (!isGood)
       return;
 
     // Copy the channel data from what we received from m_multiChannelProvider.
     ASSERT(m_currentChannel <= m_numberOfChannels);
     if (m_currentChannel < m_numberOfChannels) {
       memcpy(bus->channel(0)->mutableData(),
              m_multiChannelBus->channel(m_currentChannel)->data(),
              sizeof(float) * framesToProcess);
       ++m_currentChannel;
     }
   }
 
  private:
   AudioSourceProvider* m_multiChannelProvider;
   RefPtr<AudioBus> m_multiChannelBus;
   unsigned m_numberOfChannels;
   unsigned m_currentChannel;
-  size_t
-      m_framesToProcess;  // Used to verify that all channels ask for the same amount.
+  size_t m_framesToProcess;  // Used to verify that all channels ask for the

[dcheng, 2016/10/03 01:21:04]

Nit: put this comment on the previous line to avoid wrapping

[Nico, 2016/10/03 02:15:24]

Done (I'm not sure I agree with it though; it's 2 lines either way and this way
it's more clear what the comment refers to)

+                             // same amount.
 };
 
 }  // namespace
 
 MultiChannelResampler::MultiChannelResampler(double scaleFactor,
                                              unsigned numberOfChannels)
     : m_numberOfChannels(numberOfChannels) {
   // Create each channel's resampler.
   for (unsigned channelIndex = 0; channelIndex < numberOfChannels;
        ++channelIndex)
     m_kernels.append(wrapUnique(new SincResampler(scaleFactor)));
 }
 
 void MultiChannelResampler::process(AudioSourceProvider* provider,
                                     AudioBus* destination,
                                     size_t framesToProcess) {
-  // The provider can provide us with multi-channel audio data. But each of our single-channel resamplers (kernels)
-  // below requires a provider which provides a single unique channel of data.
-  // channelProvider wraps the original multi-channel provider and dishes out one channel at a time.
+  // The provider can provide us with multi-channel audio data. But each of our
+  // single-channel resamplers (kernels) below requires a provider which
+  // provides a single unique channel of data.  channelProvider wraps the
+  // original multi-channel provider and dishes out one channel at a time.
   ChannelProvider channelProvider(provider, m_numberOfChannels);
 
   for (unsigned channelIndex = 0; channelIndex < m_numberOfChannels;
        ++channelIndex) {
-    // Depending on the sample-rate scale factor, and the internal buffering used in a SincResampler
-    // kernel, this call to process() will only sometimes call provideInput() on the channelProvider.
-    // However, if it calls provideInput() for the first channel, then it will call it for the remaining
-    // channels, since they all buffer in the same way and are processing the same number of frames.
+    // Depending on the sample-rate scale factor, and the internal buffering
+    // used in a SincResampler kernel, this call to process() will only
+    // sometimes call provideInput() on the channelProvider.  However, if it
+    // calls provideInput() for the first channel, then it will call it for the
+    // remaining channels, since they all buffer in the same way and are
+    // processing the same number of frames.
     m_kernels[channelIndex]->process(
         &channelProvider, destination->channel(channelIndex)->mutableData(),
         framesToProcess);
   }
 }
 
 }  // namespace blink