reflow comments in platform/audio

third_party/WebKit/Source/platform/audio/VectorMath.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
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
  */
 
 #include "platform/audio/VectorMath.h"
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/MathExtras.h"
 #include <stdint.h>
 
 #if OS(MACOSX)
 #include <Accelerate/Accelerate.h>
 #endif
 
 #if CPU(X86) || CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
 #if HAVE(ARM_NEON_INTRINSICS)
 #include <arm_neon.h>
 #endif
 
 #include <math.h>
 #include <algorithm>
 
 namespace blink {
 
 namespace VectorMath {
 
 #if OS(MACOSX)
 // On the Mac we use the highly optimized versions in Accelerate.framework
-// In 32-bit mode (__ppc__ or __i386__) <Accelerate/Accelerate.h> includes <vecLib/vDSP_translate.h> which defines macros of the same name as
-// our namespaced function names, so we must handle this case differently. Other architectures (64bit, ARM, etc.) do not include this header file.
+// In 32-bit mode (__ppc__ or __i386__) <Accelerate/Accelerate.h> includes
+// <vecLib/vDSP_translate.h> which defines macros of the same name as
+// our namespaced function names, so we must handle this case differently. Other
+// architectures (64bit, ARM, etc.) do not include this header file.
 
 void vsmul(const float* sourceP,
            int sourceStride,
            const float* scale,
            float* destP,
            int destStride,
            size_t framesToProcess) {
 #if CPU(X86)
   ::vsmul(sourceP, sourceStride, scale, destP, destStride, framesToProcess);
 #else
@@ skipping 99 matching lines @@
           const float* scale,
           float* destP,
           int destStride,
           size_t framesToProcess) {
   int n = framesToProcess;
 
 #if CPU(X86) || CPU(X86_64)
   if ((sourceStride == 1) && (destStride == 1)) {
     float k = *scale;
 
-    // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the sourceP address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
       *destP += k * *sourceP;
       sourceP++;
       destP++;
       n--;
     }
 
     // Now the sourceP is aligned, use SSE.
     int tailFrames = n % 4;
     const float* endP = destP + n - tailFrames;
@@ skipping 55 matching lines @@
            const float* scale,
            float* destP,
            int destStride,
            size_t framesToProcess) {
   int n = framesToProcess;
 
 #if CPU(X86) || CPU(X86_64)
   if ((sourceStride == 1) && (destStride == 1)) {
     float k = *scale;
 
-    // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the sourceP address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<size_t>(sourceP) & 0x0F) && n) {
       *destP = k * *sourceP;
       sourceP++;
       destP++;
       n--;
     }
 
     // Now the sourceP address is aligned and start to apply SSE.
     int group = n / 4;
     __m128 mScale = _mm_set_ps1(k);
@@ skipping 61 matching lines @@
           int sourceStride1,
           const float* source2P,
           int sourceStride2,
           float* destP,
           int destStride,
           size_t framesToProcess) {
   int n = framesToProcess;
 
 #if CPU(X86) || CPU(X86_64)
   if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
-    // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the sourceP address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<size_t>(source1P) & 0x0F) && n) {
       *destP = *source1P + *source2P;
       source1P++;
       source2P++;
       destP++;
       n--;
     }
 
     // Now the source1P address is aligned and start to apply SSE.
     int group = n / 4;
@@ skipping 99 matching lines @@
           int sourceStride1,
           const float* source2P,
           int sourceStride2,
           float* destP,
           int destStride,
           size_t framesToProcess) {
   int n = framesToProcess;
 
 #if CPU(X86) || CPU(X86_64)
   if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
-    // If the source1P address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the source1P address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<uintptr_t>(source1P) & 0x0F) && n) {
       *destP = *source1P * *source2P;
       source1P++;
       source2P++;
       destP++;
       n--;
     }
 
     // Now the source1P address aligned and start to apply SSE.
     int tailFrames = n % 4;
@@ skipping 57 matching lines @@
 
 void zvmul(const float* real1P,
            const float* imag1P,
            const float* real2P,
            const float* imag2P,
            float* realDestP,
            float* imagDestP,
            size_t framesToProcess) {
   unsigned i = 0;
 #if CPU(X86) || CPU(X86_64)
-  // Only use the SSE optimization in the very common case that all addresses are 16-byte aligned.
-  // Otherwise, fall through to the scalar code below.
+  // Only use the SSE optimization in the very common case that all addresses
+  // are 16-byte aligned.  Otherwise, fall through to the scalar code below.
   if (!(reinterpret_cast<uintptr_t>(real1P) & 0x0F) &&
       !(reinterpret_cast<uintptr_t>(imag1P) & 0x0F) &&
       !(reinterpret_cast<uintptr_t>(real2P) & 0x0F) &&
       !(reinterpret_cast<uintptr_t>(imag2P) & 0x0F) &&
       !(reinterpret_cast<uintptr_t>(realDestP) & 0x0F) &&
       !(reinterpret_cast<uintptr_t>(imagDestP) & 0x0F)) {
     unsigned endSize = framesToProcess - framesToProcess % 4;
     while (i < endSize) {
       __m128 real1 = _mm_load_ps(real1P + i);
       __m128 real2 = _mm_load_ps(real2P + i);
@@ skipping 38 matching lines @@
 
 void vsvesq(const float* sourceP,
             int sourceStride,
             float* sumP,
             size_t framesToProcess) {
   int n = framesToProcess;
   float sum = 0;
 
 #if CPU(X86) || CPU(X86_64)
   if (sourceStride == 1) {
-    // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the sourceP address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
       float sample = *sourceP;
       sum += sample * sample;
       sourceP++;
       n--;
     }
 
     // Now the sourceP is aligned, use SSE.
     int tailFrames = n % 4;
     const float* endP = sourceP + n - tailFrames;
@@ skipping 47 matching lines @@
 
 void vmaxmgv(const float* sourceP,
              int sourceStride,
              float* maxP,
              size_t framesToProcess) {
   int n = framesToProcess;
   float max = 0;
 
 #if CPU(X86) || CPU(X86_64)
   if (sourceStride == 1) {
-    // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
+    // If the sourceP address is not 16-byte aligned, the first several frames
+    // (at most three) should be processed separately.
     while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
       max = std::max(max, fabsf(*sourceP));
       sourceP++;
       n--;
     }
 
     // Now the sourceP is aligned, use SSE.
     int tailFrames = n % 4;
     const float* endP = sourceP + n - tailFrames;
     __m128 source;
     __m128 mMax = _mm_setzero_ps();
     int mask = 0x7FFFFFFF;
     __m128 mMask = _mm_set1_ps(*reinterpret_cast<float*>(&mask));
 
     while (sourceP < endP) {
       source = _mm_load_ps(sourceP);
-      // Calculate the absolute value by anding source with mask, the sign bit is set to 0.
+      // Calculate the absolute value by anding source with mask, the sign bit
+      // is set to 0.
       source = _mm_and_ps(source, mMask);
       mMax = _mm_max_ps(mMax, source);
       sourceP += 4;
     }
 
     // Get max from the SSE results.
     const float* groupMaxP = reinterpret_cast<float*>(&mMax);
     max = std::max(max, groupMaxP[0]);
     max = std::max(max, groupMaxP[1]);
     max = std::max(max, groupMaxP[2]);
@@ skipping 65 matching lines @@
     sourceP += sourceStride;
     destP += destStride;
   }
 }
 
 #endif  // OS(MACOSX)
 
 }  // namespace VectorMath
 
 }  // namespace blink