media/base/sinc_resampler_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // MSVC++ requires this to be set before any other includes to get M_PI.
   6 #define _USE_MATH_DEFINES
   7
   8 #include <cmath>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/command_line.h"
  13 #include "base/cpu.h"
  14 #include "base/logging.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/stringize_macros.h"
  17 #include "base/time.h"
  18 #include "build/build_config.h"
  19 #include "media/base/sinc_resampler.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using testing::_;
  24
  25 namespace media {
  26
  27 static const double kSampleRateRatio = 192000.0 / 44100.0;
  28 static const double kKernelInterpolationFactor = 0.5;
  29
  30 // Command line switch for runtime adjustment of ConvolveBenchmark iterations.
  31 static const char kConvolveIterations[] = "convolve-iterations";
  32
  33 // Helper class to ensure ChunkedResample() functions properly.
  34 class MockSource {
  35  public:
  36   MOCK_METHOD2(ProvideInput, void(int frames, float* destination));
  37 };
  38
  39 ACTION(ClearBuffer) {
  40   memset(arg1, 0, arg0 * sizeof(float));
  41 }
  42
  43 ACTION(FillBuffer) {
  44   // Value chosen arbitrarily such that SincResampler resamples it to something
  45   // easily representable on all platforms; e.g., using kSampleRateRatio this
  46   // becomes 1.81219.
  47   memset(arg1, 64, arg0 * sizeof(float));
  48 }
  49
  50 // Test requesting multiples of ChunkSize() frames results in the proper number
  51 // of callbacks.
  52 TEST(SincResamplerTest, ChunkedResample) {
  53   MockSource mock_source;
  54
  55   // Choose a high ratio of input to output samples which will result in quick
  56   // exhaustion of SincResampler's internal buffers.
  57   SincResampler resampler(
  58       kSampleRateRatio, SincResampler::kDefaultRequestSize,
  59       base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
  60
  61   static const int kChunks = 2;
  62   int max_chunk_size = resampler.ChunkSize() * kChunks;
  63   scoped_ptr<float[]> resampled_destination(new float[max_chunk_size]);
  64
  65   // Verify requesting ChunkSize() frames causes a single callback.
  66   EXPECT_CALL(mock_source, ProvideInput(_, _))
  67       .Times(1).WillOnce(ClearBuffer());
  68   resampler.Resample(resampler.ChunkSize(), resampled_destination.get());
  69
  70   // Verify requesting kChunks * ChunkSize() frames causes kChunks callbacks.
  71   testing::Mock::VerifyAndClear(&mock_source);
  72   EXPECT_CALL(mock_source, ProvideInput(_, _))
  73       .Times(kChunks).WillRepeatedly(ClearBuffer());
  74   resampler.Resample(max_chunk_size, resampled_destination.get());
  75 }
  76
  77 // Test flush resets the internal state properly.
  78 TEST(SincResamplerTest, Flush) {
  79   MockSource mock_source;
  80   SincResampler resampler(
  81       kSampleRateRatio, SincResampler::kDefaultRequestSize,
  82       base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
  83   scoped_ptr<float[]> resampled_destination(new float[resampler.ChunkSize()]);
  84
  85   // Fill the resampler with junk data.
  86   EXPECT_CALL(mock_source, ProvideInput(_, _))
  87       .Times(1).WillOnce(FillBuffer());
  88   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
  89   ASSERT_NE(resampled_destination[0], 0);
  90
  91   // Flush and request more data, which should all be zeros now.
  92   resampler.Flush();
  93   testing::Mock::VerifyAndClear(&mock_source);
  94   EXPECT_CALL(mock_source, ProvideInput(_, _))
  95       .Times(1).WillOnce(ClearBuffer());
  96   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
  97   for (int i = 0; i < resampler.ChunkSize() / 2; ++i)
  98     ASSERT_FLOAT_EQ(resampled_destination[i], 0);
  99 }
 100
 101 // Test flush resets the internal state properly.
 102 TEST(SincResamplerTest, DISABLED_SetRatioBench) {
 103   MockSource mock_source;
 104   SincResampler resampler(
 105       kSampleRateRatio, SincResampler::kDefaultRequestSize,
 106       base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
 107
 108   base::TimeTicks start = base::TimeTicks::HighResNow();
 109   for (int i = 1; i < 10000; ++i)
 110     resampler.SetRatio(1.0 / i);
 111   double total_time_c_ms =
 112       (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 113   printf("SetRatio() took %.2fms.\n", total_time_c_ms);
 114 }
 115
 116
 117 // Define platform independent function name for Convolve* tests.
 118 #if defined(ARCH_CPU_X86_FAMILY)
 119 #define CONVOLVE_FUNC Convolve_SSE
 120 #elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
 121 #define CONVOLVE_FUNC Convolve_NEON
 122 #endif
 123
 124 // Ensure various optimized Convolve() methods return the same value.  Only run
 125 // this test if other optimized methods exist, otherwise the default Convolve()
 126 // will be tested by the parameterized SincResampler tests below.
 127 #if defined(CONVOLVE_FUNC)
 128 TEST(SincResamplerTest, Convolve) {
 129 #if defined(ARCH_CPU_X86_FAMILY)
 130   ASSERT_TRUE(base::CPU().has_sse());
 131 #endif
 132
 133   // Initialize a dummy resampler.
 134   MockSource mock_source;
 135   SincResampler resampler(
 136       kSampleRateRatio, SincResampler::kDefaultRequestSize,
 137       base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
 138
 139   // The optimized Convolve methods are slightly more precise than Convolve_C(),
 140   // so comparison must be done using an epsilon.
 141   static const double kEpsilon = 0.00000005;
 142
 143   // Use a kernel from SincResampler as input and kernel data, this has the
 144   // benefit of already being properly sized and aligned for Convolve_SSE().
 145   double result = resampler.Convolve_C(
 146       resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
 147       resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 148   double result2 = resampler.CONVOLVE_FUNC(
 149       resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
 150       resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 151   EXPECT_NEAR(result2, result, kEpsilon);
 152
 153   // Test Convolve() w/ unaligned input pointer.
 154   result = resampler.Convolve_C(
 155       resampler.kernel_storage_.get() + 1, resampler.kernel_storage_.get(),
 156       resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 157   result2 = resampler.CONVOLVE_FUNC(
 158       resampler.kernel_storage_.get() + 1, resampler.kernel_storage_.get(),
 159       resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 160   EXPECT_NEAR(result2, result, kEpsilon);
 161 }
 162 #endif
 163
 164 // Benchmark for the various Convolve() methods.  Make sure to build with
 165 // branding=Chrome so that DCHECKs are compiled out when benchmarking.  Original
 166 // benchmarks were run with --convolve-iterations=50000000.
 167 TEST(SincResamplerTest, ConvolveBenchmark) {
 168   // Initialize a dummy resampler.
 169   MockSource mock_source;
 170   SincResampler resampler(
 171       kSampleRateRatio, SincResampler::kDefaultRequestSize,
 172       base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
 173
 174   // Retrieve benchmark iterations from command line.
 175   int convolve_iterations = 10;
 176   std::string iterations(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 177       kConvolveIterations));
 178   if (!iterations.empty())
 179     base::StringToInt(iterations, &convolve_iterations);
 180
 181   printf("Benchmarking %d iterations:\n", convolve_iterations);
 182
 183   // Benchmark Convolve_C().
 184   base::TimeTicks start = base::TimeTicks::HighResNow();
 185   for (int i = 0; i < convolve_iterations; ++i) {
 186     resampler.Convolve_C(
 187         resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
 188         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 189   }
 190   double total_time_c_ms =
 191       (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 192   printf("Convolve_C took %.2fms.\n", total_time_c_ms);
 193
 194 #if defined(CONVOLVE_FUNC)
 195 #if defined(ARCH_CPU_X86_FAMILY)
 196   ASSERT_TRUE(base::CPU().has_sse());
 197 #endif
 198
 199   // Benchmark with unaligned input pointer.
 200   start = base::TimeTicks::HighResNow();
 201   for (int j = 0; j < convolve_iterations; ++j) {
 202     resampler.CONVOLVE_FUNC(
 203         resampler.kernel_storage_.get() + 1, resampler.kernel_storage_.get(),
 204         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 205   }
 206   double total_time_optimized_unaligned_ms =
 207       (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 208   printf(STRINGIZE(CONVOLVE_FUNC) " (unaligned) took %.2fms; which is %.2fx "
 209          "faster than Convolve_C.\n", total_time_optimized_unaligned_ms,
 210          total_time_c_ms / total_time_optimized_unaligned_ms);
 211
 212   // Benchmark with aligned input pointer.
 213   start = base::TimeTicks::HighResNow();
 214   for (int j = 0; j < convolve_iterations; ++j) {
 215     resampler.CONVOLVE_FUNC(
 216         resampler.kernel_storage_.get(), resampler.kernel_storage_.get(),
 217         resampler.kernel_storage_.get(), kKernelInterpolationFactor);
 218   }
 219   double total_time_optimized_aligned_ms =
 220       (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 221   printf(STRINGIZE(CONVOLVE_FUNC) " (aligned) took %.2fms; which is %.2fx "
 222          "faster than Convolve_C and %.2fx faster than "
 223          STRINGIZE(CONVOLVE_FUNC) " (unaligned).\n",
 224          total_time_optimized_aligned_ms,
 225          total_time_c_ms / total_time_optimized_aligned_ms,
 226          total_time_optimized_unaligned_ms / total_time_optimized_aligned_ms);
 227 #endif
 228 }
 229
 230 #undef CONVOLVE_FUNC
 231
 232 // Fake audio source for testing the resampler.  Generates a sinusoidal linear
 233 // chirp (http://en.wikipedia.org/wiki/Chirp) which can be tuned to stress the
 234 // resampler for the specific sample rate conversion being used.
 235 class SinusoidalLinearChirpSource {
 236  public:
 237   SinusoidalLinearChirpSource(int sample_rate,
 238                               int samples,
 239                               double max_frequency)
 240       : sample_rate_(sample_rate),
 241         total_samples_(samples),
 242         max_frequency_(max_frequency),
 243         current_index_(0) {
 244     // Chirp rate.
 245     double duration = static_cast<double>(total_samples_) / sample_rate_;
 246     k_ = (max_frequency_ - kMinFrequency) / duration;
 247   }
 248
 249   virtual ~SinusoidalLinearChirpSource() {}
 250
 251   void ProvideInput(int frames, float* destination) {
 252     for (int i = 0; i < frames; ++i, ++current_index_) {
 253       // Filter out frequencies higher than Nyquist.
 254       if (Frequency(current_index_) > 0.5 * sample_rate_) {
 255         destination[i] = 0;
 256       } else {
 257         // Calculate time in seconds.
 258         double t = static_cast<double>(current_index_) / sample_rate_;
 259
 260         // Sinusoidal linear chirp.
 261         destination[i] = sin(2 * M_PI * (kMinFrequency * t + (k_ / 2) * t * t));
 262       }
 263     }
 264   }
 265
 266   double Frequency(int position) {
 267     return kMinFrequency + position * (max_frequency_ - kMinFrequency)
 268         / total_samples_;
 269   }
 270
 271  private:
 272   enum {
 273     kMinFrequency = 5
 274   };
 275
 276   double sample_rate_;
 277   int total_samples_;
 278   double max_frequency_;
 279   double k_;
 280   int current_index_;
 281
 282   DISALLOW_COPY_AND_ASSIGN(SinusoidalLinearChirpSource);
 283 };
 284
 285 typedef std::tr1::tuple<int, int, double, double> SincResamplerTestData;
 286 class SincResamplerTest
 287     : public testing::TestWithParam<SincResamplerTestData> {
 288  public:
 289   SincResamplerTest()
 290       : input_rate_(std::tr1::get<0>(GetParam())),
 291         output_rate_(std::tr1::get<1>(GetParam())),
 292         rms_error_(std::tr1::get<2>(GetParam())),
 293         low_freq_error_(std::tr1::get<3>(GetParam())) {
 294   }
 295
 296   virtual ~SincResamplerTest() {}
 297
 298  protected:
 299   int input_rate_;
 300   int output_rate_;
 301   double rms_error_;
 302   double low_freq_error_;
 303 };
 304
 305 // Tests resampling using a given input and output sample rate.
 306 TEST_P(SincResamplerTest, Resample) {
 307   // Make comparisons using one second of data.
 308   static const double kTestDurationSecs = 1;
 309   int input_samples = kTestDurationSecs * input_rate_;
 310   int output_samples = kTestDurationSecs * output_rate_;
 311
 312   // Nyquist frequency for the input sampling rate.
 313   double input_nyquist_freq = 0.5 * input_rate_;
 314
 315   // Source for data to be resampled.
 316   SinusoidalLinearChirpSource resampler_source(
 317       input_rate_, input_samples, input_nyquist_freq);
 318
 319   const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
 320   SincResampler resampler(
 321       io_ratio, SincResampler::kDefaultRequestSize,
 322       base::Bind(&SinusoidalLinearChirpSource::ProvideInput,
 323                  base::Unretained(&resampler_source)));
 324
 325   // Force an update to the sample rate ratio to ensure dyanmic sample rate
 326   // changes are working correctly.
 327   scoped_ptr<float[]> kernel(new float[SincResampler::kKernelStorageSize]);
 328   memcpy(kernel.get(), resampler.get_kernel_for_testing(),
 329          SincResampler::kKernelStorageSize);
 330   resampler.SetRatio(M_PI);
 331   ASSERT_NE(0, memcmp(kernel.get(), resampler.get_kernel_for_testing(),
 332                       SincResampler::kKernelStorageSize));
 333   resampler.SetRatio(io_ratio);
 334   ASSERT_EQ(0, memcmp(kernel.get(), resampler.get_kernel_for_testing(),
 335                       SincResampler::kKernelStorageSize));
 336
 337   // TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
 338   // allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
 339   scoped_ptr<float[]> resampled_destination(new float[output_samples]);
 340   scoped_ptr<float[]> pure_destination(new float[output_samples]);
 341
 342   // Generate resampled signal.
 343   resampler.Resample(output_samples, resampled_destination.get());
 344
 345   // Generate pure signal.
 346   SinusoidalLinearChirpSource pure_source(
 347       output_rate_, output_samples, input_nyquist_freq);
 348   pure_source.ProvideInput(output_samples, pure_destination.get());
 349
 350   // Range of the Nyquist frequency (0.5 * min(input rate, output_rate)) which
 351   // we refer to as low and high.
 352   static const double kLowFrequencyNyquistRange = 0.7;
 353   static const double kHighFrequencyNyquistRange = 0.9;
 354
 355   // Calculate Root-Mean-Square-Error and maximum error for the resampling.
 356   double sum_of_squares = 0;
 357   double low_freq_max_error = 0;
 358   double high_freq_max_error = 0;
 359   int minimum_rate = std::min(input_rate_, output_rate_);
 360   double low_frequency_range = kLowFrequencyNyquistRange * 0.5 * minimum_rate;
 361   double high_frequency_range = kHighFrequencyNyquistRange * 0.5 * minimum_rate;
 362   for (int i = 0; i < output_samples; ++i) {
 363     double error = fabs(resampled_destination[i] - pure_destination[i]);
 364
 365     if (pure_source.Frequency(i) < low_frequency_range) {
 366       if (error > low_freq_max_error)
 367         low_freq_max_error = error;
 368     } else if (pure_source.Frequency(i) < high_frequency_range) {
 369       if (error > high_freq_max_error)
 370         high_freq_max_error = error;
 371     }
 372     // TODO(dalecurtis): Sanity check frequencies > kHighFrequencyNyquistRange.
 373
 374     sum_of_squares += error * error;
 375   }
 376
 377   double rms_error = sqrt(sum_of_squares / output_samples);
 378
 379   // Convert each error to dbFS.
 380   #define DBFS(x) 20 * log10(x)
 381   rms_error = DBFS(rms_error);
 382   low_freq_max_error = DBFS(low_freq_max_error);
 383   high_freq_max_error = DBFS(high_freq_max_error);
 384
 385   EXPECT_LE(rms_error, rms_error_);
 386   EXPECT_LE(low_freq_max_error, low_freq_error_);
 387
 388   // All conversions currently have a high frequency error around -6 dbFS.
 389   static const double kHighFrequencyMaxError = -6.02;
 390   EXPECT_LE(high_freq_max_error, kHighFrequencyMaxError);
 391 }
 392
 393 // Almost all conversions have an RMS error of around -14 dbFS.
 394 static const double kResamplingRMSError = -14.58;
 395
 396 // Thresholds chosen arbitrarily based on what each resampling reported during
 397 // testing.  All thresholds are in dbFS, http://en.wikipedia.org/wiki/DBFS.
 398 INSTANTIATE_TEST_CASE_P(
 399     SincResamplerTest, SincResamplerTest, testing::Values(
 400         // To 44.1kHz
 401         std::tr1::make_tuple(8000, 44100, kResamplingRMSError, -62.73),
 402         std::tr1::make_tuple(11025, 44100, kResamplingRMSError, -72.19),
 403         std::tr1::make_tuple(16000, 44100, kResamplingRMSError, -62.54),
 404         std::tr1::make_tuple(22050, 44100, kResamplingRMSError, -73.53),
 405         std::tr1::make_tuple(32000, 44100, kResamplingRMSError, -63.32),
 406         std::tr1::make_tuple(44100, 44100, kResamplingRMSError, -73.53),
 407         std::tr1::make_tuple(48000, 44100, -15.01, -64.04),
 408         std::tr1::make_tuple(96000, 44100, -18.49, -25.51),
 409         std::tr1::make_tuple(192000, 44100, -20.50, -13.31),
 410
 411         // To 48kHz
 412         std::tr1::make_tuple(8000, 48000, kResamplingRMSError, -63.43),
 413         std::tr1::make_tuple(11025, 48000, kResamplingRMSError, -62.61),
 414         std::tr1::make_tuple(16000, 48000, kResamplingRMSError, -63.96),
 415         std::tr1::make_tuple(22050, 48000, kResamplingRMSError, -62.42),
 416         std::tr1::make_tuple(32000, 48000, kResamplingRMSError, -64.04),
 417         std::tr1::make_tuple(44100, 48000, kResamplingRMSError, -62.63),
 418         std::tr1::make_tuple(48000, 48000, kResamplingRMSError, -73.52),
 419         std::tr1::make_tuple(96000, 48000, -18.40, -28.44),
 420         std::tr1::make_tuple(192000, 48000, -20.43, -14.11),
 421
 422         // To 96kHz
 423         std::tr1::make_tuple(8000, 96000, kResamplingRMSError, -63.19),
 424         std::tr1::make_tuple(11025, 96000, kResamplingRMSError, -62.61),
 425         std::tr1::make_tuple(16000, 96000, kResamplingRMSError, -63.39),
 426         std::tr1::make_tuple(22050, 96000, kResamplingRMSError, -62.42),
 427         std::tr1::make_tuple(32000, 96000, kResamplingRMSError, -63.95),
 428         std::tr1::make_tuple(44100, 96000, kResamplingRMSError, -62.63),
 429         std::tr1::make_tuple(48000, 96000, kResamplingRMSError, -73.52),
 430         std::tr1::make_tuple(96000, 96000, kResamplingRMSError, -73.52),
 431         std::tr1::make_tuple(192000, 96000, kResamplingRMSError, -28.41),
 432
 433         // To 192kHz
 434         std::tr1::make_tuple(8000, 192000, kResamplingRMSError, -63.10),
 435         std::tr1::make_tuple(11025, 192000, kResamplingRMSError, -62.61),
 436         std::tr1::make_tuple(16000, 192000, kResamplingRMSError, -63.14),
 437         std::tr1::make_tuple(22050, 192000, kResamplingRMSError, -62.42),
 438         std::tr1::make_tuple(32000, 192000, kResamplingRMSError, -63.38),
 439         std::tr1::make_tuple(44100, 192000, kResamplingRMSError, -62.63),
 440         std::tr1::make_tuple(48000, 192000, kResamplingRMSError, -73.44),
 441         std::tr1::make_tuple(96000, 192000, kResamplingRMSError, -73.52),
 442         std::tr1::make_tuple(192000, 192000, kResamplingRMSError, -73.52)));
 443
 444 }  // namespace media