reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/FFTFrame.h

 /*
  * 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 28 matching lines @@
 #if OS(MACOSX)
 #include <Accelerate/Accelerate.h>
 #elif USE(WEBAUDIO_OPENMAX_DL_FFT)
 #include <dl/sp/api/omxSP.h>
 #elif USE(WEBAUDIO_FFMPEG)
 struct RDFTContext;
 #endif
 
 namespace blink {
 
-// Defines the interface for an "FFT frame", an object which is able to perform a forward
-// and reverse FFT, internally storing the resultant frequency-domain data.
+// Defines the interface for an "FFT frame", an object which is able to perform
+// a forward and reverse FFT, internally storing the resultant frequency-domain
+// data.
 
 class PLATFORM_EXPORT FFTFrame {
   USING_FAST_MALLOC(FFTFrame);
 
  public:
-  // The constructors, destructor, and methods up to the CROSS-PLATFORM section have platform-dependent implementations.
+  // The constructors, destructor, and methods up to the CROSS-PLATFORM section
+  // have platform-dependent implementations.
 
   FFTFrame(unsigned fftSize);
-  FFTFrame();  // creates a blank/empty frame for later use with createInterpolatedFrame()
+  // creates a blank/empty frame for later use with createInterpolatedFrame()
+  FFTFrame();
   FFTFrame(const FFTFrame& frame);
   ~FFTFrame();
 
   static void initialize();
   static void cleanup();
   void doFFT(const float* data);
   void doInverseFFT(float* data);
 
   float* realData() const { return const_cast<float*>(m_realData.data()); }
   float* imagData() const { return const_cast<float*>(m_imagData.data()); }
 
   unsigned fftSize() const { return m_FFTSize; }
   unsigned log2FFTSize() const { return m_log2FFTSize; }
 
   // CROSS-PLATFORM
   // The remaining public methods have cross-platform implementations:
 
   // Interpolates from frame1 -> frame2 as x goes from 0.0 -> 1.0
   static std::unique_ptr<FFTFrame> createInterpolatedFrame(
       const FFTFrame& frame1,
       const FFTFrame& frame2,
       double x);
-  void doPaddedFFT(const float* data,
-                   size_t dataSize);  // zero-padding with dataSize <= fftSize
+  // zero-padding with dataSize <= fftSize
+  void doPaddedFFT(const float* data, size_t dataSize);
   double extractAverageGroupDelay();
   void addConstantGroupDelay(double sampleFrameDelay);
-  void multiply(
-      const FFTFrame&);  // multiplies ourself with frame : effectively operator*=()
+  // multiplies ourself with frame : effectively operator*=()
+  void multiply(const FFTFrame&);
 
  private:
   void interpolateFrequencyComponents(const FFTFrame& frame1,
                                       const FFTFrame& frame2,
                                       double x);
 
   unsigned m_FFTSize;
   unsigned m_log2FFTSize;
   AudioFloatArray m_realData;
   AudioFloatArray m_imagData;
@@ skipping 15 matching lines @@
   static OMXFFTSpec_R_F32* contextForSize(unsigned log2FFTSize);
   OMXFFTSpec_R_F32* m_forwardContext;
   OMXFFTSpec_R_F32* m_inverseContext;
   AudioFloatArray m_complexData;
 #endif
 };
 
 }  // namespace blink
 
 #endif  // FFTFrame_h