Experiment with AVX optimizations for FMAC, FMUL operations.

media/base/sinc_resampler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Initial input buffer layout, dividing into regions r0_ to r4_ (note: r0_, r3_
 // and r4_ will move after the first load):
 //
 // |----------------|-----------------------------------------|----------------|
 //
 //                                        request_frames_
@@ skipping 64 matching lines @@
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "media/base/sinc_resampler.h"
 
 #include <cmath>
 #include <limits>
 
 #include "base/logging.h"
-#include "build/build_config.h"
-
-#if defined(ARCH_CPU_X86_FAMILY)
-#include <xmmintrin.h>
-#define CONVOLVE_FUNC Convolve_SSE
-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
-#include <arm_neon.h>
-#define CONVOLVE_FUNC Convolve_NEON
-#else
-#define CONVOLVE_FUNC Convolve_C
-#endif
 
 namespace media {
 
 static double SincScaleFactor(double io_ratio) {
   // |sinc_scale_factor| is basically the normalized cutoff frequency of the
   // low-pass filter.
   double sinc_scale_factor = io_ratio > 1.0 ? 1.0 / io_ratio : 1.0;
 
   // The sinc function is an idealized brick-wall filter, but since we're
   // windowing it the transition from pass to stop does not happen right away.
@@ skipping 78 matching lines @@
 
     for (int i = 0; i < kKernelSize; ++i) {
       const int idx = i + offset_idx * kKernelSize;
       const float pre_sinc =
           static_cast<float>(M_PI * (i - kKernelSize / 2 - subsample_offset));
       kernel_pre_sinc_storage_[idx] = pre_sinc;
 
       // Compute Blackman window, matching the offset of the sinc().
       const float x = (i - subsample_offset) / kKernelSize;
       const float window = static_cast<float>(kA0 - kA1 * cos(2.0 * M_PI * x) +
-          kA2 * cos(4.0 * M_PI * x));
+                                              kA2 * cos(4.0 * M_PI * x));
       kernel_window_storage_[idx] = window;
 
       // Compute the sinc with offset, then window the sinc() function and store
       // at the correct offset.
       kernel_storage_[idx] = static_cast<float>(
           window * (pre_sinc ? sin(sinc_scale_factor * pre_sinc) / pre_sinc
                              : sinc_scale_factor));
     }
   }
 }
@@ skipping 52 matching lines @@
       DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(k1) & 0x0F);
       DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(k2) & 0x0F);
 
       // Initialize input pointer based on quantized |virtual_source_idx_|.
       const float* input_ptr = r1_ + source_idx;
 
       // Figure out how much to weight each kernel's "convolution".
       const double kernel_interpolation_factor =
           virtual_offset_idx - offset_idx;
       *destination++ =
-          CONVOLVE_FUNC(input_ptr, k1, k2, kernel_interpolation_factor);
+          vector_math::Convolve(input_ptr, k1, k2, kernel_interpolation_factor);
 
       // Advance the virtual index.
       virtual_source_idx_ += io_sample_rate_ratio_;
       if (!--remaining_frames)
         return;
     }
 
     // Wrap back around to the start.
     DCHECK_GE(virtual_source_idx_, block_size_);
     virtual_source_idx_ -= block_size_;
@@ skipping 24 matching lines @@
   buffer_primed_ = false;
   memset(input_buffer_.get(), 0,
          sizeof(*input_buffer_.get()) * input_buffer_size_);
   UpdateRegions(false);
 }
 
 double SincResampler::BufferedFrames() const {
   return buffer_primed_ ? request_frames_ - virtual_source_idx_ : 0;
 }
 
-float SincResampler::Convolve_C(const float* input_ptr, const float* k1,
-                                const float* k2,
-                                double kernel_interpolation_factor) {
-  float sum1 = 0;
-  float sum2 = 0;
-
-  // Generate a single output sample.  Unrolling this loop hurt performance in
-  // local testing.
-  int n = kKernelSize;
-  while (n--) {
-    sum1 += *input_ptr * *k1++;
-    sum2 += *input_ptr++ * *k2++;
-  }
-
-  // Linearly interpolate the two "convolutions".
-  return static_cast<float>((1.0 - kernel_interpolation_factor) * sum1 +
-      kernel_interpolation_factor * sum2);
-}
-
-#if defined(ARCH_CPU_X86_FAMILY)
-float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,
-                                  const float* k2,
-                                  double kernel_interpolation_factor) {
-  __m128 m_input;
-  __m128 m_sums1 = _mm_setzero_ps();
-  __m128 m_sums2 = _mm_setzero_ps();
-
-  // Based on |input_ptr| alignment, we need to use loadu or load.  Unrolling
-  // these loops hurt performance in local testing.
-  if (reinterpret_cast<uintptr_t>(input_ptr) & 0x0F) {
-    for (int i = 0; i < kKernelSize; i += 4) {
-      m_input = _mm_loadu_ps(input_ptr + i);
-      m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
-      m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
-    }
-  } else {
-    for (int i = 0; i < kKernelSize; i += 4) {
-      m_input = _mm_load_ps(input_ptr + i);
-      m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
-      m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
-    }
-  }
-
-  // Linearly interpolate the two "convolutions".
-  m_sums1 = _mm_mul_ps(m_sums1, _mm_set_ps1(
-      static_cast<float>(1.0 - kernel_interpolation_factor)));
-  m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1(
-      static_cast<float>(kernel_interpolation_factor)));
-  m_sums1 = _mm_add_ps(m_sums1, m_sums2);
-
-  // Sum components together.
-  float result;
-  m_sums2 = _mm_add_ps(_mm_movehl_ps(m_sums1, m_sums1), m_sums1);
-  _mm_store_ss(&result, _mm_add_ss(m_sums2, _mm_shuffle_ps(
-      m_sums2, m_sums2, 1)));
-
-  return result;
-}
-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
-float SincResampler::Convolve_NEON(const float* input_ptr, const float* k1,
-                                   const float* k2,
-                                   double kernel_interpolation_factor) {
-  float32x4_t m_input;
-  float32x4_t m_sums1 = vmovq_n_f32(0);
-  float32x4_t m_sums2 = vmovq_n_f32(0);
-
-  const float* upper = input_ptr + kKernelSize;
-  for (; input_ptr < upper; ) {
-    m_input = vld1q_f32(input_ptr);
-    input_ptr += 4;
-    m_sums1 = vmlaq_f32(m_sums1, m_input, vld1q_f32(k1));
-    k1 += 4;
-    m_sums2 = vmlaq_f32(m_sums2, m_input, vld1q_f32(k2));
-    k2 += 4;
-  }
-
-  // Linearly interpolate the two "convolutions".
-  m_sums1 = vmlaq_f32(
-      vmulq_f32(m_sums1, vmovq_n_f32(1.0 - kernel_interpolation_factor)),
-      m_sums2, vmovq_n_f32(kernel_interpolation_factor));
-
-  // Sum components together.
-  float32x2_t m_half = vadd_f32(vget_high_f32(m_sums1), vget_low_f32(m_sums1));
-  return vget_lane_f32(vpadd_f32(m_half, m_half), 0);
-}
-#endif
-
 }  // namespace media