WebAudio: Add SSE2 optimization for DirectConvolver

Source/platform/audio/DirectConvolver.cpp

 /*
  * Copyright (C) 2012 Intel 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 21 matching lines @@
 
 #include "platform/audio/DirectConvolver.h"
 
 #if OS(MACOSX)
 #include <Accelerate/Accelerate.h>
 #endif
 
 #include "platform/audio/VectorMath.h"
 #include "wtf/CPU.h"
 
+#if (CPU(X86) || CPU(X86_64)) && !(OS(MACOSX) || USE(WEBAUDIO_IPP))
+#include <emmintrin.h>
+#endif
+
 namespace blink {
 
 using namespace VectorMath;
 
 DirectConvolver::DirectConvolver(size_t inputBlockSize)
     : m_inputBlockSize(inputBlockSize)
 #if USE(WEBAUDIO_IPP)
     , m_overlayBuffer(inputBlockSize)
 #endif // USE(WEBAUDIO_IPP)
     , m_buffer(inputBlockSize * 2)
@@ skipping 38 matching lines @@
     // Copy samples to 2nd half of input buffer.
     memcpy(inputP, sourceP, sizeof(float) * framesToProcess);
 
 #if OS(MACOSX)
 #if CPU(X86)
     conv(inputP - kernelSize + 1, 1, kernelP + kernelSize - 1, -1, destP, 1, framesToProcess, kernelSize);
 #else
     vDSP_conv(inputP - kernelSize + 1, 1, kernelP + kernelSize - 1, -1, destP, 1, framesToProcess, kernelSize);
 #endif // CPU(X86)
 #else
+    size_t i = 0;
+#if CPU(X86) || CPU(X86_64)
+    // Convolution using SSE2. Currently only do this if both |kernelSize| and |framesToProcess|
+    // are multiples of 4. If not, use the straightforward loop below.
+
+    if ((kernelSize % 4 == 0) && (framesToProcess % 4 == 0)) {
+        // AudioFloatArray's are always aligned on at least a 16-byte boundary.
+        AudioFloatArray kernelBuffer(4 * kernelSize);
+        __m128* kernelReversed = reinterpret_cast<__m128*>(kernelBuffer.data());
+
+        // Reverse the kernel and repeat each value across a vector
+        for (i = 0; i < kernelSize; ++i) {
+            kernelReversed[i] = _mm_set1_ps(kernelP[kernelSize - i - 1]);
+        }
+
+        float* inputStartP = inputP - kernelSize + 1;
+
+        // Do convolution with 4 inputs at a time.
+        for (i = 0; i < framesToProcess; i += 4) {
+            __m128 convolutionSum;
+
+            convolutionSum = _mm_setzero_ps();
+
+            // |kernelSize| is a multiple of 4 so we can unroll the loop by 4, manually.
+            for (size_t k = 0; k < kernelSize; k += 4) {
+                size_t dataOffset = i + k;
+
+                for (size_t m = 0; m < 4; ++m) {
+                    __m128 sourceBlock;
+                    __m128 product;
+
+                    sourceBlock = _mm_loadu_ps(inputStartP + dataOffset + m);
+                    product = _mm_mul_ps(kernelReversed[k + m], sourceBlock);
+                    convolutionSum = _mm_add_ps(convolutionSum, product);
+                }
+            }
+            _mm_storeu_ps(destP + i, convolutionSum);
+        }
+    } else {
+#endif
+
     // FIXME: The macro can be further optimized to avoid pipeline stalls. One possibility is to maintain 4 separate sums and change the macro to CONVOLVE_FOUR_SAMPLES.
 #define CONVOLVE_ONE_SAMPLE                 \
     do {                                    \
         sum += inputP[i - j] * kernelP[j];  \
         j++;                                \
     } while (0)
 
-    size_t i = 0;
     while (i < framesToProcess) {
         size_t j = 0;
         float sum = 0;
 
         // FIXME: SSE optimization may be applied here.
         if (kernelSize == 32) {
             CONVOLVE_ONE_SAMPLE; // 1
             CONVOLVE_ONE_SAMPLE; // 2
             CONVOLVE_ONE_SAMPLE; // 3
             CONVOLVE_ONE_SAMPLE; // 4
@@ skipping 243 matching lines @@
             CONVOLVE_ONE_SAMPLE; // 127
             CONVOLVE_ONE_SAMPLE; // 128
         } else {
             while (j < kernelSize) {
                 // Non-optimized using actual while loop.
                 CONVOLVE_ONE_SAMPLE;
             }
         }
         destP[i++] = sum;
     }
+#if CPU(X86) || CPU(X86_64)
+    }
+#endif
 #endif // OS(MACOSX)
 
     // Copy 2nd half of input buffer to 1st half.
     memcpy(m_buffer.data(), inputP, sizeof(float) * framesToProcess);
 #endif
 }
 
 void DirectConvolver::reset()
 {
     m_buffer.zero();
 #if USE(WEBAUDIO_IPP)
     m_overlayBuffer.zero();
 #endif // USE(WEBAUDIO_IPP)
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)