DO NOT COMMIT. Diff of downstream webrtc resampler commit for review purposes.

media/base/sinc_resampler_unittest.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.
+/*
+ *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Modified from the Chromium original:
+// src/media/base/sinc_resampler_unittest.cc
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include <cmath>
 
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/command_line.h"
-#include "base/cpu.h"
-#include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringize_macros.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-#include "media/base/sinc_resampler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/common_audio/resampler/sinc_resampler.h"
+#include "webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h"
+#include "webrtc/system_wrappers/interface/cpu_features_wrapper.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+#include "webrtc/system_wrappers/interface/stringize_macros.h"
+#include "webrtc/system_wrappers/interface/tick_util.h"
+#include "webrtc/test/test_suite.h"
 
 using testing::_;
 
-namespace media {
+namespace webrtc {
 
 static const double kSampleRateRatio = 192000.0 / 44100.0;
 static const double kKernelInterpolationFactor = 0.5;
 
-// Command line switch for runtime adjustment of ConvolveBenchmark iterations.
-static const char kConvolveIterations[] = "convolve-iterations";
-
 // Helper class to ensure ChunkedResample() functions properly.
-class MockSource {
+class MockSource : public SincResamplerCallback {
  public:
-  MOCK_METHOD2(ProvideInput, void(int frames, float* destination));
+  MOCK_METHOD2(Run, void(int frames, float* destination));
 };
 
 ACTION(ClearBuffer) {
   memset(arg1, 0, arg0 * sizeof(float));
 }
 
 ACTION(FillBuffer) {
   // Value chosen arbitrarily such that SincResampler resamples it to something
   // easily representable on all platforms; e.g., using kSampleRateRatio this
   // becomes 1.81219.
   memset(arg1, 64, arg0 * sizeof(float));
 }
 
 // Test requesting multiples of ChunkSize() frames results in the proper number
 // of callbacks.
 TEST(SincResamplerTest, ChunkedResample) {
   MockSource mock_source;
 
   // Choose a high ratio of input to output samples which will result in quick
   // exhaustion of SincResampler's internal buffers.
-  SincResampler resampler(
-      kSampleRateRatio, SincResampler::kDefaultRequestSize,
-      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
+  SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
+                          &mock_source);
 
   static const int kChunks = 2;
   int max_chunk_size = resampler.ChunkSize() * kChunks;
-  scoped_ptr<float[]> resampled_destination(new float[max_chunk_size]);
+  scoped_array<float> resampled_destination(new float[max_chunk_size]);
 
   // Verify requesting ChunkSize() frames causes a single callback.
-  EXPECT_CALL(mock_source, ProvideInput(_, _))
+  EXPECT_CALL(mock_source, Run(_, _))
       .Times(1).WillOnce(ClearBuffer());
   resampler.Resample(resampler.ChunkSize(), resampled_destination.get());
 
   // Verify requesting kChunks * ChunkSize() frames causes kChunks callbacks.
   testing::Mock::VerifyAndClear(&mock_source);
-  EXPECT_CALL(mock_source, ProvideInput(_, _))
+  EXPECT_CALL(mock_source, Run(_, _))
       .Times(kChunks).WillRepeatedly(ClearBuffer());
   resampler.Resample(max_chunk_size, resampled_destination.get());
 }
 
 // Test flush resets the internal state properly.
 TEST(SincResamplerTest, Flush) {
   MockSource mock_source;
-  SincResampler resampler(
-      kSampleRateRatio, SincResampler::kDefaultRequestSize,
-      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
-  scoped_ptr<float[]> resampled_destination(new float[resampler.ChunkSize()]);
+  SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
+                          &mock_source);
+  scoped_array<float> resampled_destination(new float[resampler.ChunkSize()]);
 
   // Fill the resampler with junk data.
-  EXPECT_CALL(mock_source, ProvideInput(_, _))
+  EXPECT_CALL(mock_source, Run(_, _))
       .Times(1).WillOnce(FillBuffer());
   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
   ASSERT_NE(resampled_destination[0], 0);
 
   // Flush and request more data, which should all be zeros now.
   resampler.Flush();
   testing::Mock::VerifyAndClear(&mock_source);
-  EXPECT_CALL(mock_source, ProvideInput(_, _))
+  EXPECT_CALL(mock_source, Run(_, _))
       .Times(1).WillOnce(ClearBuffer());
   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
   for (int i = 0; i < resampler.ChunkSize() / 2; ++i)
     ASSERT_FLOAT_EQ(resampled_destination[i], 0);
 }
 
 // Test flush resets the internal state properly.
 TEST(SincResamplerTest, DISABLED_SetRatioBench) {
   MockSource mock_source;
-  SincResampler resampler(
-      kSampleRateRatio, SincResampler::kDefaultRequestSize,
-      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
+  SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
+                          &mock_source);
 
-  base::TimeTicks start = base::TimeTicks::HighResNow();
+  TickTime start = TickTime::Now();
   for (int i = 1; i < 10000; ++i)
     resampler.SetRatio(1.0 / i);
-  double total_time_c_ms =
-      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
-  printf("SetRatio() took %.2fms.\n", total_time_c_ms);
+  double total_time_c_us = (TickTime::Now() - start).Microseconds();
+  printf("SetRatio() took %.2fms.\n", total_time_c_us / 1000);
 }
 
 
 // Define platform independent function name for Convolve* tests.
-#if defined(ARCH_CPU_X86_FAMILY)
+#if defined(WEBRTC_ARCH_X86_FAMILY)
 #define CONVOLVE_FUNC Convolve_SSE
-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#elif defined(WEBRTC_ARCH_ARM_V7)
 #define CONVOLVE_FUNC Convolve_NEON
 #endif
 
 // Ensure various optimized Convolve() methods return the same value.  Only run
 // this test if other optimized methods exist, otherwise the default Convolve()
 // will be tested by the parameterized SincResampler tests below.
 #if defined(CONVOLVE_FUNC)
 TEST(SincResamplerTest, Convolve) {
-#if defined(ARCH_CPU_X86_FAMILY)
-  ASSERT_TRUE(base::CPU().has_sse());
+#if defined(WEBRTC_ARCH_X86_FAMILY)
+  ASSERT_TRUE(WebRtc_GetCPUInfo(kSSE2));
+#elif defined(WEBRTC_ARCH_ARM_V7)
+  ASSERT_TRUE(WebRtc_GetCPUFeaturesARM() & kCPUFeatureNEON);
 #endif
 
   // Initialize a dummy resampler.
   MockSource mock_source;
-  SincResampler resampler(
-      kSampleRateRatio, SincResampler::kDefaultRequestSize,
-      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
+  SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
+                          &mock_source);
 
   // The optimized Convolve methods are slightly more precise than Convolve_C(),
   // so comparison must be done using an epsilon.
   static const double kEpsilon = 0.00000005;
 
   // Use a kernel from SincResampler as input and kernel data, this has the
   // benefit of already being properly sized and aligned for Convolve_SSE().
   double result = resampler.Convolve_C(
       resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
       resampler.kernel_storage_.get(), kKernelInterpolationFactor);
@@ skipping 12 matching lines @@
   EXPECT_NEAR(result2, result, kEpsilon);
 }
 #endif
 
 // Benchmark for the various Convolve() methods.  Make sure to build with
 // branding=Chrome so that DCHECKs are compiled out when benchmarking.  Original
 // benchmarks were run with --convolve-iterations=50000000.
 TEST(SincResamplerTest, ConvolveBenchmark) {
   // Initialize a dummy resampler.
   MockSource mock_source;
-  SincResampler resampler(
-      kSampleRateRatio, SincResampler::kDefaultRequestSize,
-      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
+  SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
+                          &mock_source);
 
   // Retrieve benchmark iterations from command line.
-  int convolve_iterations = 10;
-  std::string iterations(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      kConvolveIterations));
-  if (!iterations.empty())
-    base::StringToInt(iterations, &convolve_iterations);
+  // TODO(ajm): Reintroduce this as a command line option.
+  const int kConvolveIterations = 1000000;
 
-  printf("Benchmarking %d iterations:\n", convolve_iterations);
+  printf("Benchmarking %d iterations:\n", kConvolveIterations);
 
   // Benchmark Convolve_C().
-  base::TimeTicks start = base::TimeTicks::HighResNow();
-  for (int i = 0; i < convolve_iterations; ++i) {
+  TickTime start = TickTime::Now();
+  for (int i = 0; i < kConvolveIterations; ++i) {
     resampler.Convolve_C(
         resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
   }
-  double total_time_c_ms =
-      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
-  printf("Convolve_C took %.2fms.\n", total_time_c_ms);
+  double total_time_c_us = (TickTime::Now() - start).Microseconds();
+  printf("Convolve_C took %.2fms.\n", total_time_c_us / 1000);
 
 #if defined(CONVOLVE_FUNC)
-#if defined(ARCH_CPU_X86_FAMILY)
-  ASSERT_TRUE(base::CPU().has_sse());
+#if defined(WEBRTC_ARCH_X86_FAMILY)
+  ASSERT_TRUE(WebRtc_GetCPUInfo(kSSE2));
+#elif defined(WEBRTC_ARCH_ARM_V7)
+  ASSERT_TRUE(WebRtc_GetCPUFeaturesARM() & kCPUFeatureNEON);
 #endif
 
   // Benchmark with unaligned input pointer.
-  start = base::TimeTicks::HighResNow();
-  for (int j = 0; j < convolve_iterations; ++j) {
+  start = TickTime::Now();
+  for (int j = 0; j < kConvolveIterations; ++j) {
     resampler.CONVOLVE_FUNC(
         resampler.kernel_storage_.get() + 1, resampler.kernel_storage_.get(),
         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
   }
-  double total_time_optimized_unaligned_ms =
-      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
-  printf(STRINGIZE(CONVOLVE_FUNC) " (unaligned) took %.2fms; which is %.2fx "
-         "faster than Convolve_C.\n", total_time_optimized_unaligned_ms,
-         total_time_c_ms / total_time_optimized_unaligned_ms);
+  double total_time_optimized_unaligned_us =
+      (TickTime::Now() - start).Microseconds();
+  printf(STRINGIZE(CONVOLVE_FUNC) "(unaligned) took %.2fms; which is %.2fx "
+         "faster than Convolve_C.\n", total_time_optimized_unaligned_us / 1000,
+         total_time_c_us / total_time_optimized_unaligned_us);
 
   // Benchmark with aligned input pointer.
-  start = base::TimeTicks::HighResNow();
-  for (int j = 0; j < convolve_iterations; ++j) {
+  start = TickTime::Now();
+  for (int j = 0; j < kConvolveIterations; ++j) {
     resampler.CONVOLVE_FUNC(
         resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
   }
-  double total_time_optimized_aligned_ms =
-      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
+  double total_time_optimized_aligned_us =
+      (TickTime::Now() - start).Microseconds();
   printf(STRINGIZE(CONVOLVE_FUNC) " (aligned) took %.2fms; which is %.2fx "
          "faster than Convolve_C and %.2fx faster than "
          STRINGIZE(CONVOLVE_FUNC) " (unaligned).\n",
-         total_time_optimized_aligned_ms,
-         total_time_c_ms / total_time_optimized_aligned_ms,
-         total_time_optimized_unaligned_ms / total_time_optimized_aligned_ms);
+         total_time_optimized_aligned_us / 1000,
+         total_time_c_us / total_time_optimized_aligned_us,
+         total_time_optimized_unaligned_us / total_time_optimized_aligned_us);
 #endif
 }
 
 #undef CONVOLVE_FUNC
 
-// Fake audio source for testing the resampler.  Generates a sinusoidal linear
-// chirp (http://en.wikipedia.org/wiki/Chirp) which can be tuned to stress the
-// resampler for the specific sample rate conversion being used.
-class SinusoidalLinearChirpSource {
- public:
-  SinusoidalLinearChirpSource(int sample_rate,
-                              int samples,
-                              double max_frequency)
-      : sample_rate_(sample_rate),
-        total_samples_(samples),
-        max_frequency_(max_frequency),
-        current_index_(0) {
-    // Chirp rate.
-    double duration = static_cast<double>(total_samples_) / sample_rate_;
-    k_ = (max_frequency_ - kMinFrequency) / duration;
-  }
-
-  virtual ~SinusoidalLinearChirpSource() {}
-
-  void ProvideInput(int frames, float* destination) {
-    for (int i = 0; i < frames; ++i, ++current_index_) {
-      // Filter out frequencies higher than Nyquist.
-      if (Frequency(current_index_) > 0.5 * sample_rate_) {
-        destination[i] = 0;
-      } else {
-        // Calculate time in seconds.
-        double t = static_cast<double>(current_index_) / sample_rate_;
-
-        // Sinusoidal linear chirp.
-        destination[i] = sin(2 * M_PI * (kMinFrequency * t + (k_ / 2) * t * t));
-      }
-    }
-  }
-
-  double Frequency(int position) {
-    return kMinFrequency + position * (max_frequency_ - kMinFrequency)
-        / total_samples_;
-  }
-
- private:
-  enum {
-    kMinFrequency = 5
-  };
-
-  double sample_rate_;
-  int total_samples_;
-  double max_frequency_;
-  double k_;
-  int current_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(SinusoidalLinearChirpSource);
-};
-
 typedef std::tr1::tuple<int, int, double, double> SincResamplerTestData;
 class SincResamplerTest
     : public testing::TestWithParam<SincResamplerTestData> {
  public:
   SincResamplerTest()
       : input_rate_(std::tr1::get<0>(GetParam())),
         output_rate_(std::tr1::get<1>(GetParam())),
         rms_error_(std::tr1::get<2>(GetParam())),
         low_freq_error_(std::tr1::get<3>(GetParam())) {
   }
 
   virtual ~SincResamplerTest() {}
 
  protected:
   int input_rate_;
   int output_rate_;
   double rms_error_;
   double low_freq_error_;
 };
 
 // Tests resampling using a given input and output sample rate.
 TEST_P(SincResamplerTest, Resample) {
   // Make comparisons using one second of data.
   static const double kTestDurationSecs = 1;
-  int input_samples = kTestDurationSecs * input_rate_;
-  int output_samples = kTestDurationSecs * output_rate_;
+  const int input_samples = kTestDurationSecs * input_rate_;
+  const int output_samples = kTestDurationSecs * output_rate_;
 
   // Nyquist frequency for the input sampling rate.
-  double input_nyquist_freq = 0.5 * input_rate_;
+  const double input_nyquist_freq = 0.5 * input_rate_;
 
   // Source for data to be resampled.
   SinusoidalLinearChirpSource resampler_source(
-      input_rate_, input_samples, input_nyquist_freq);
+      input_rate_, input_samples, input_nyquist_freq, 0);
 
   const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
-  SincResampler resampler(
-      io_ratio, SincResampler::kDefaultRequestSize,
-      base::Bind(&SinusoidalLinearChirpSource::ProvideInput,
-                 base::Unretained(&resampler_source)));
+  SincResampler resampler(io_ratio, SincResampler::kDefaultRequestSize,
+                          &resampler_source);
 
   // Force an update to the sample rate ratio to ensure dyanmic sample rate
   // changes are working correctly.
-  scoped_ptr<float[]> kernel(new float[SincResampler::kKernelStorageSize]);
+  scoped_array<float> kernel(new float[SincResampler::kKernelStorageSize]);
   memcpy(kernel.get(), resampler.get_kernel_for_testing(),
          SincResampler::kKernelStorageSize);
   resampler.SetRatio(M_PI);
   ASSERT_NE(0, memcmp(kernel.get(), resampler.get_kernel_for_testing(),
                       SincResampler::kKernelStorageSize));
   resampler.SetRatio(io_ratio);
   ASSERT_EQ(0, memcmp(kernel.get(), resampler.get_kernel_for_testing(),
                       SincResampler::kKernelStorageSize));
 
   // TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
   // allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
-  scoped_ptr<float[]> resampled_destination(new float[output_samples]);
-  scoped_ptr<float[]> pure_destination(new float[output_samples]);
+  scoped_array<float> resampled_destination(new float[output_samples]);
+  scoped_array<float> pure_destination(new float[output_samples]);
 
   // Generate resampled signal.
   resampler.Resample(output_samples, resampled_destination.get());
 
   // Generate pure signal.
   SinusoidalLinearChirpSource pure_source(
-      output_rate_, output_samples, input_nyquist_freq);
-  pure_source.ProvideInput(output_samples, pure_destination.get());
+      output_rate_, output_samples, input_nyquist_freq, 0);
+  pure_source.Run(output_samples, pure_destination.get());
 
   // Range of the Nyquist frequency (0.5 * min(input rate, output_rate)) which
   // we refer to as low and high.
   static const double kLowFrequencyNyquistRange = 0.7;
   static const double kHighFrequencyNyquistRange = 0.9;
 
   // Calculate Root-Mean-Square-Error and maximum error for the resampling.
   double sum_of_squares = 0;
   double low_freq_max_error = 0;
   double high_freq_max_error = 0;
@@ skipping 75 matching lines @@
         std::tr1::make_tuple(8000, 192000, kResamplingRMSError, -63.10),
         std::tr1::make_tuple(11025, 192000, kResamplingRMSError, -62.61),
         std::tr1::make_tuple(16000, 192000, kResamplingRMSError, -63.14),
         std::tr1::make_tuple(22050, 192000, kResamplingRMSError, -62.42),
         std::tr1::make_tuple(32000, 192000, kResamplingRMSError, -63.38),
         std::tr1::make_tuple(44100, 192000, kResamplingRMSError, -62.63),
         std::tr1::make_tuple(48000, 192000, kResamplingRMSError, -73.44),
         std::tr1::make_tuple(96000, 192000, kResamplingRMSError, -73.52),
         std::tr1::make_tuple(192000, 192000, kResamplingRMSError, -73.52)));
 
-}  // namespace media
+}  // namespace webrtc