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 37 matching lines @@
 namespace media {
 
 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();
+  InitializeKernel(true);
 }
 
 SincResampler::~SincResampler() {}
 
-void SincResampler::InitializeKernel() {
+void SincResampler::InitializeKernel(bool first_run) {
   // 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;
 
+  if (!first_run) {

[Chris Rogers, 2013/04/08 19:38:11]

A simple comment explaining the optimization we're doing would be nice.

[DaleCurtis, 2013/04/15 20:27:31]

Done.

+    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 double s = sinc_scale_factor * kernel_pre_sinc_storage_[idx];
+        const double sinc = (s == 0 ? 1.0 : sin(s) / s) * sinc_scale_factor;
+        kernel_storage_[idx] = sinc * kernel_window_storage_[idx];
+      }
+    }
+    return;
+  }
+
   // Generates a set of windowed sinc() kernels.
   // We generate a range of sub-sample offsets from 0.0 to 1.0.
   for (int offset_idx = 0; offset_idx <= kKernelOffsetCount; ++offset_idx) {
     double subsample_offset =
         static_cast<double>(offset_idx) / kKernelOffsetCount;
 
     for (int i = 0; i < kKernelSize; ++i) {
+      double pre_sinc = M_PI * (i - kKernelSize / 2 - subsample_offset);
+
       // 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;
+      double s = sinc_scale_factor * pre_sinc;
+      double sinc = (s == 0 ? 1.0 : sin(s) / s) * sinc_scale_factor;
 
       // 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
           * cos(4.0 * M_PI * x);
 
+      const int idx = i + offset_idx * kKernelSize;
+
       // Window the sinc() function and store at the correct offset.
-      kernel_storage_.get()[i + offset_idx * kKernelSize] = sinc * window;
+      kernel_pre_sinc_storage_[idx] = pre_sinc;
+      kernel_window_storage_[idx] = window;
+      kernel_storage_[idx] = sinc * window;
     }
   }
 }
 
+void SincResampler::UpdateSampleRateRatio(double io_sample_rate_ratio) {
+  io_sample_rate_ratio_ = io_sample_rate_ratio;
+  InitializeKernel(false);
+}
+
 // 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
 #elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
@@ skipping 116 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