Varispeed support for SincResampler.

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.
 //
 // Input buffer layout, dividing the total buffer into regions (r0_ - r5_):
 //
 // |----------------|-----------------------------------------|----------------|
 //
 //                                   kBlockSize + kKernelSize / 2
 //                   <--------------------------------------------------------->
@@ skipping 19 matching lines @@
 //
 // Note: we're glossing over how the sub-sample handling works with
 // |virtual_source_idx_|, etc.
 
 // 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/cpu.h"
 #include "base/logging.h"
 
 #if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
 #include <arm_neon.h>
 #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.
+  // So we should adjust the low pass filter cutoff slightly downward to avoid
+  // some aliasing at the very high-end.
+  // TODO(crogers): this value is empirical and to be more exact should vary
+  // depending on kKernelSize.
+  sinc_scale_factor *= 0.9;
+
+  return sinc_scale_factor;
+}
+
 SincResampler::SincResampler(double io_sample_rate_ratio, const ReadCB& read_cb)
     : io_sample_rate_ratio_(io_sample_rate_ratio),
       virtual_source_idx_(0),
       buffer_primed_(false),
       read_cb_(read_cb),
       // Create input buffers with a 16-byte alignment for SSE optimizations.
       kernel_storage_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
+      kernel_pre_sinc_storage_(static_cast<float*>(
+          base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
+      kernel_window_storage_(static_cast<float*>(
+          base::AlignedAlloc(sizeof(float) * kKernelStorageSize, 16))),
       input_buffer_(static_cast<float*>(
           base::AlignedAlloc(sizeof(float) * kBufferSize, 16))),
 #if defined(ARCH_CPU_X86_FAMILY) && !defined(__SSE__)
       convolve_proc_(base::CPU().has_sse() ? Convolve_SSE : Convolve_C),
 #endif
       // Setup various region pointers in the buffer (see diagram above).
       r0_(input_buffer_.get() + kKernelSize / 2),
       r1_(input_buffer_.get()),
       r2_(r0_),
       r3_(r0_ + kBlockSize - kKernelSize / 2),
@@ skipping 14 matching lines @@
   DCHECK_EQ(r2_ - r1_, r5_ - r2_);
   // r3_ left of r4_, r5_ left of r0_ and r3_ size correct.
   DCHECK_EQ(r4_ - r3_, r5_ - r0_);
   // r3_, r4_ size correct and r4_ at the end of the buffer.
   DCHECK_EQ(r4_ + (r4_ - r3_), r1_ + kBufferSize);
   // r5_ size correct and at the end of the buffer.
   DCHECK_EQ(r5_ + kBlockSize, r1_ + kBufferSize);
 
   memset(kernel_storage_.get(), 0,
          sizeof(*kernel_storage_.get()) * kKernelStorageSize);
+  memset(kernel_pre_sinc_storage_.get(), 0,
+         sizeof(*kernel_pre_sinc_storage_.get()) * kKernelStorageSize);
+  memset(kernel_window_storage_.get(), 0,
+         sizeof(*kernel_window_storage_.get()) * kKernelStorageSize);
   memset(input_buffer_.get(), 0, sizeof(*input_buffer_.get()) * kBufferSize);
 
   InitializeKernel();
 }
 
 SincResampler::~SincResampler() {}
 
 void SincResampler::InitializeKernel() {
   // Blackman window parameters.
   static const double kAlpha = 0.16;
   static const double kA0 = 0.5 * (1.0 - kAlpha);
   static const double kA1 = 0.5;
   static const double kA2 = 0.5 * kAlpha;
 
-  // |sinc_scale_factor| is basically the normalized cutoff frequency of the
-  // low-pass filter.
-  double sinc_scale_factor =
-      io_sample_rate_ratio_ > 1.0 ? 1.0 / io_sample_rate_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.
-  // So we should adjust the low pass filter cutoff slightly downward to avoid
-  // some aliasing at the very high-end.
-  // TODO(crogers): this value is empirical and to be more exact should vary
-  // depending on kKernelSize.
-  sinc_scale_factor *= 0.9;
-
   // Generates a set of windowed sinc() kernels.
   // We generate a range of sub-sample offsets from 0.0 to 1.0.
+  const double sinc_scale_factor = SincScaleFactor(io_sample_rate_ratio_);
   for (int offset_idx = 0; offset_idx <= kKernelOffsetCount; ++offset_idx) {
-    double subsample_offset =
-        static_cast<double>(offset_idx) / kKernelOffsetCount;
+    const float subsample_offset =
+        static_cast<float>(offset_idx) / kKernelOffsetCount;
 
     for (int i = 0; i < kKernelSize; ++i) {
-      // Compute the sinc with offset.
-      double s =
-          sinc_scale_factor * M_PI * (i - kKernelSize / 2 - subsample_offset);
-      double sinc = (!s ? 1.0 : sin(s) / s) * sinc_scale_factor;
+      const int idx = i + offset_idx * kKernelSize;
+      const float pre_sinc = M_PI * (i - kKernelSize / 2 - subsample_offset);
+      kernel_pre_sinc_storage_[idx] = pre_sinc;
 
       // Compute Blackman window, matching the offset of the sinc().
-      double x = (i - subsample_offset) / kKernelSize;
-      double window = kA0 - kA1 * cos(2.0 * M_PI * x) + kA2
+      const float x = (i - subsample_offset) / kKernelSize;
+      const float window = kA0 - kA1 * cos(2.0 * M_PI * x) + kA2
           * cos(4.0 * M_PI * x);
+      kernel_window_storage_[idx] = window;
 
-      // Window the sinc() function and store at the correct offset.
-      kernel_storage_.get()[i + offset_idx * kKernelSize] = sinc * window;
+      // Compute the sinc with offset, then window the sinc() function and store
+      // at the correct offset.
+      if (pre_sinc == 0) {
+        kernel_storage_[idx] = sinc_scale_factor * window;
+      } else {
+        kernel_storage_[idx] =
+            window * sin(sinc_scale_factor * pre_sinc) / pre_sinc;
+      }
     }
   }
 }
+
+void SincResampler::SetRatio(double io_sample_rate_ratio) {
+  if (fabs(io_sample_rate_ratio_ - io_sample_rate_ratio) <
+      std::numeric_limits<double>::epsilon()) {
+    return;
+  }
+
+  io_sample_rate_ratio_ = io_sample_rate_ratio;
+
+  // Optimize reinitialization by reusing values which are independent of
+  // |sinc_scale_factor|.  Provides a 3x speedup.
+  const double sinc_scale_factor = SincScaleFactor(io_sample_rate_ratio_);
+  for (int offset_idx = 0; offset_idx <= kKernelOffsetCount; ++offset_idx) {
+    for (int i = 0; i < kKernelSize; ++i) {
+      const int idx = i + offset_idx * kKernelSize;
+      const float window = kernel_window_storage_[idx];
+      const float pre_sinc = kernel_pre_sinc_storage_[idx];
+
+      if (pre_sinc == 0) {
+        kernel_storage_[idx] = sinc_scale_factor * window;
+      } else {
+        kernel_storage_[idx] =
+            window * sin(sinc_scale_factor * pre_sinc) / pre_sinc;
+      }
+    }
+  }
+}
 
 // If we know the minimum architecture avoid function hopping for CPU detection.
 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(__SSE__)
 #define CONVOLVE_FUNC Convolve_SSE
 #else
 // X86 CPU detection required.  |convolve_proc_| will be set upon construction.
 // TODO(dalecurtis): Once Chrome moves to a SSE baseline this can be removed.
 #define CONVOLVE_FUNC convolve_proc_
 #endif
@@ skipping 117 matching lines @@
       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