src/third_party/webrtc/common_audio/resampler/push_sinc_resampler_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <math.h>
  12
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "webrtc/common_audio/include/audio_util.h"
  16 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
  17 #include "webrtc/common_audio/resampler/sinusoidal_linear_chirp_source.h"
  18 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  19 #include "webrtc/system_wrappers/interface/tick_util.h"
  20 #include "webrtc/typedefs.h"
  21
  22 namespace webrtc {
  23
  24 typedef std::tr1::tuple<int, int, double, double> PushSincResamplerTestData;
  25 class PushSincResamplerTest
  26     : public testing::TestWithParam<PushSincResamplerTestData> {
  27  public:
  28   PushSincResamplerTest()
  29       : input_rate_(std::tr1::get<0>(GetParam())),
  30         output_rate_(std::tr1::get<1>(GetParam())),
  31         rms_error_(std::tr1::get<2>(GetParam())),
  32         low_freq_error_(std::tr1::get<3>(GetParam())) {
  33   }
  34
  35   virtual ~PushSincResamplerTest() {}
  36
  37  protected:
  38   void ResampleBenchmarkTest(bool int_format);
  39   void ResampleTest(bool int_format);
  40
  41   int input_rate_;
  42   int output_rate_;
  43   double rms_error_;
  44   double low_freq_error_;
  45 };
  46
  47 class ZeroSource : public SincResamplerCallback {
  48  public:
  49   void Run(int frames, float* destination) {
  50     memset(destination, 0, sizeof(float) * frames);
  51   }
  52 };
  53
  54 void PushSincResamplerTest::ResampleBenchmarkTest(bool int_format) {
  55   const int input_samples = input_rate_ / 100;
  56   const int output_samples = output_rate_ / 100;
  57   const int kResampleIterations = 500000;
  58
  59   // Source for data to be resampled.
  60   ZeroSource resampler_source;
  61
  62   scoped_ptr<float[]> resampled_destination(new float[output_samples]);
  63   scoped_ptr<float[]> source(new float[input_samples]);
  64   scoped_ptr<int16_t[]> source_int(new int16_t[input_samples]);
  65   scoped_ptr<int16_t[]> destination_int(new int16_t[output_samples]);
  66
  67   resampler_source.Run(input_samples, source.get());
  68   for (int i = 0; i < input_samples; ++i) {
  69     source_int[i] = static_cast<int16_t>(floor(32767 * source[i] + 0.5));
  70   }
  71
  72   printf("Benchmarking %d iterations of %d Hz -> %d Hz:\n",
  73          kResampleIterations, input_rate_, output_rate_);
  74   const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
  75   SincResampler sinc_resampler(io_ratio, SincResampler::kDefaultRequestSize,
  76                                &resampler_source);
  77   TickTime start = TickTime::Now();
  78   for (int i = 0; i < kResampleIterations; ++i) {
  79     sinc_resampler.Resample(output_samples, resampled_destination.get());
  80   }
  81   double total_time_sinc_us = (TickTime::Now() - start).Microseconds();
  82   printf("SincResampler took %.2f us per frame.\n",
  83          total_time_sinc_us / kResampleIterations);
  84
  85   PushSincResampler resampler(input_samples, output_samples);
  86   start = TickTime::Now();
  87   if (int_format) {
  88     for (int i = 0; i < kResampleIterations; ++i) {
  89       EXPECT_EQ(output_samples,
  90                 resampler.Resample(source_int.get(),
  91                                    input_samples,
  92                                    destination_int.get(),
  93                                    output_samples));
  94     }
  95   } else {
  96     for (int i = 0; i < kResampleIterations; ++i) {
  97       EXPECT_EQ(output_samples,
  98                 resampler.Resample(source.get(),
  99                                    input_samples,
 100                                    resampled_destination.get(),
 101                                    output_samples));
 102     }
 103   }
 104   double total_time_us = (TickTime::Now() - start).Microseconds();
 105   printf("PushSincResampler took %.2f us per frame; which is a %.1f%% overhead "
 106          "on SincResampler.\n\n", total_time_us / kResampleIterations,
 107          (total_time_us - total_time_sinc_us) / total_time_sinc_us * 100);
 108 }
 109
 110 // Disabled because it takes too long to run routinely. Use for performance
 111 // benchmarking when needed.
 112 TEST_P(PushSincResamplerTest, DISABLED_BenchmarkInt) {
 113   ResampleBenchmarkTest(true);
 114 }
 115
 116 TEST_P(PushSincResamplerTest, DISABLED_BenchmarkFloat) {
 117   ResampleBenchmarkTest(false);
 118 }
 119
 120 // Tests resampling using a given input and output sample rate.
 121 void PushSincResamplerTest::ResampleTest(bool int_format) {
 122   // Make comparisons using one second of data.
 123   static const double kTestDurationSecs = 1;
 124   // 10 ms blocks.
 125   const int kNumBlocks = kTestDurationSecs * 100;
 126   const int input_block_size = input_rate_ / 100;
 127   const int output_block_size = output_rate_ / 100;
 128   const int input_samples = kTestDurationSecs * input_rate_;
 129   const int output_samples = kTestDurationSecs * output_rate_;
 130
 131   // Nyquist frequency for the input sampling rate.
 132   const double input_nyquist_freq = 0.5 * input_rate_;
 133
 134   // Source for data to be resampled.
 135   SinusoidalLinearChirpSource resampler_source(
 136       input_rate_, input_samples, input_nyquist_freq, 0);
 137
 138   PushSincResampler resampler(input_block_size, output_block_size);
 139
 140   // TODO(dalecurtis): If we switch to AVX/SSE optimization, we'll need to
 141   // allocate these on 32-byte boundaries and ensure they're sized % 32 bytes.
 142   scoped_ptr<float[]> resampled_destination(new float[output_samples]);
 143   scoped_ptr<float[]> pure_destination(new float[output_samples]);
 144   scoped_ptr<float[]> source(new float[input_samples]);
 145   scoped_ptr<int16_t[]> source_int(new int16_t[input_block_size]);
 146   scoped_ptr<int16_t[]> destination_int(new int16_t[output_block_size]);
 147
 148   // The sinc resampler has an implicit delay of approximately half the kernel
 149   // size at the input sample rate. By moving to a push model, this delay
 150   // becomes explicit and is managed by zero-stuffing in PushSincResampler. We
 151   // deal with it in the test by delaying the "pure" source to match. It must be
 152   // checked before the first call to Resample(), because ChunkSize() will
 153   // change afterwards.
 154   const int output_delay_samples = output_block_size -
 155       resampler.get_resampler_for_testing()->ChunkSize();
 156
 157   // Generate resampled signal.
 158   // With the PushSincResampler, we produce the signal block-by-10ms-block
 159   // rather than in a single pass, to exercise how it will be used in WebRTC.
 160   resampler_source.Run(input_samples, source.get());
 161   if (int_format) {
 162     for (int i = 0; i < kNumBlocks; ++i) {
 163       ScaleAndRoundToInt16(
 164           &source[i * input_block_size], input_block_size, source_int.get());
 165       EXPECT_EQ(output_block_size,
 166                 resampler.Resample(source_int.get(),
 167                                    input_block_size,
 168                                    destination_int.get(),
 169                                    output_block_size));
 170       ScaleToFloat(destination_int.get(),
 171                    output_block_size,
 172                    &resampled_destination[i * output_block_size]);
 173     }
 174   } else {
 175     for (int i = 0; i < kNumBlocks; ++i) {
 176       EXPECT_EQ(
 177           output_block_size,
 178           resampler.Resample(&source[i * input_block_size],
 179                              input_block_size,
 180                              &resampled_destination[i * output_block_size],
 181                              output_block_size));
 182     }
 183   }
 184
 185   // Generate pure signal.
 186   SinusoidalLinearChirpSource pure_source(
 187       output_rate_, output_samples, input_nyquist_freq, output_delay_samples);
 188   pure_source.Run(output_samples, pure_destination.get());
 189
 190   // Range of the Nyquist frequency (0.5 * min(input rate, output_rate)) which
 191   // we refer to as low and high.
 192   static const double kLowFrequencyNyquistRange = 0.7;
 193   static const double kHighFrequencyNyquistRange = 0.9;
 194
 195   // Calculate Root-Mean-Square-Error and maximum error for the resampling.
 196   double sum_of_squares = 0;
 197   double low_freq_max_error = 0;
 198   double high_freq_max_error = 0;
 199   int minimum_rate = std::min(input_rate_, output_rate_);
 200   double low_frequency_range = kLowFrequencyNyquistRange * 0.5 * minimum_rate;
 201   double high_frequency_range = kHighFrequencyNyquistRange * 0.5 * minimum_rate;
 202
 203   for (int i = 0; i < output_samples; ++i) {
 204     double error = fabs(resampled_destination[i] - pure_destination[i]);
 205
 206     if (pure_source.Frequency(i) < low_frequency_range) {
 207       if (error > low_freq_max_error)
 208         low_freq_max_error = error;
 209     } else if (pure_source.Frequency(i) < high_frequency_range) {
 210       if (error > high_freq_max_error)
 211         high_freq_max_error = error;
 212     }
 213     // TODO(dalecurtis): Sanity check frequencies > kHighFrequencyNyquistRange.
 214
 215     sum_of_squares += error * error;
 216   }
 217
 218   double rms_error = sqrt(sum_of_squares / output_samples);
 219
 220   // Convert each error to dbFS.
 221   #define DBFS(x) 20 * log10(x)
 222   rms_error = DBFS(rms_error);
 223   // In order to keep the thresholds in this test identical to SincResamplerTest
 224   // we must account for the quantization error introduced by truncating from
 225   // float to int. This happens twice (once at input and once at output) and we
 226   // allow for the maximum possible error (1 / 32767) for each step.
 227   //
 228   // The quantization error is insignificant in the RMS calculation so does not
 229   // need to be accounted for there.
 230   low_freq_max_error = DBFS(low_freq_max_error - 2.0 / 32767);
 231   high_freq_max_error = DBFS(high_freq_max_error - 2.0 / 32767);
 232
 233   EXPECT_LE(rms_error, rms_error_);
 234   EXPECT_LE(low_freq_max_error, low_freq_error_);
 235
 236   // All conversions currently have a high frequency error around -6 dbFS.
 237   static const double kHighFrequencyMaxError = -6.02;
 238   EXPECT_LE(high_freq_max_error, kHighFrequencyMaxError);
 239 }
 240
 241 TEST_P(PushSincResamplerTest, ResampleInt) { ResampleTest(true); }
 242
 243 TEST_P(PushSincResamplerTest, ResampleFloat) { ResampleTest(false); }
 244
 245 // Almost all conversions have an RMS error of around -14 dbFS.
 246 static const double kResamplingRMSError = -14.42;
 247
 248 // Thresholds chosen arbitrarily based on what each resampling reported during
 249 // testing.  All thresholds are in dbFS, http://en.wikipedia.org/wiki/DBFS.
 250 INSTANTIATE_TEST_CASE_P(
 251     PushSincResamplerTest,
 252     PushSincResamplerTest,
 253     testing::Values(
 254         // First run through the rates tested in SincResamplerTest. The
 255         // thresholds are identical.
 256         //
 257         // We don't test rates which fail to provide an integer number of
 258         // samples in a 10 ms block (22050 and 11025 Hz). WebRTC doesn't support
 259         // these rates in any case (for the same reason).
 260
 261         // To 44.1kHz
 262         std::tr1::make_tuple(8000, 44100, kResamplingRMSError, -62.73),
 263         std::tr1::make_tuple(16000, 44100, kResamplingRMSError, -62.54),
 264         std::tr1::make_tuple(32000, 44100, kResamplingRMSError, -63.32),
 265         std::tr1::make_tuple(44100, 44100, kResamplingRMSError, -73.53),
 266         std::tr1::make_tuple(48000, 44100, -15.01, -64.04),
 267         std::tr1::make_tuple(96000, 44100, -18.49, -25.51),
 268         std::tr1::make_tuple(192000, 44100, -20.50, -13.31),
 269
 270         // To 48kHz
 271         std::tr1::make_tuple(8000, 48000, kResamplingRMSError, -63.43),
 272         std::tr1::make_tuple(16000, 48000, kResamplingRMSError, -63.96),
 273         std::tr1::make_tuple(32000, 48000, kResamplingRMSError, -64.04),
 274         std::tr1::make_tuple(44100, 48000, kResamplingRMSError, -62.63),
 275         std::tr1::make_tuple(48000, 48000, kResamplingRMSError, -73.52),
 276         std::tr1::make_tuple(96000, 48000, -18.40, -28.44),
 277         std::tr1::make_tuple(192000, 48000, -20.43, -14.11),
 278
 279         // To 96kHz
 280         std::tr1::make_tuple(8000, 96000, kResamplingRMSError, -63.19),
 281         std::tr1::make_tuple(16000, 96000, kResamplingRMSError, -63.39),
 282         std::tr1::make_tuple(32000, 96000, kResamplingRMSError, -63.95),
 283         std::tr1::make_tuple(44100, 96000, kResamplingRMSError, -62.63),
 284         std::tr1::make_tuple(48000, 96000, kResamplingRMSError, -73.52),
 285         std::tr1::make_tuple(96000, 96000, kResamplingRMSError, -73.52),
 286         std::tr1::make_tuple(192000, 96000, kResamplingRMSError, -28.41),
 287
 288         // To 192kHz
 289         std::tr1::make_tuple(8000, 192000, kResamplingRMSError, -63.10),
 290         std::tr1::make_tuple(16000, 192000, kResamplingRMSError, -63.14),
 291         std::tr1::make_tuple(32000, 192000, kResamplingRMSError, -63.38),
 292         std::tr1::make_tuple(44100, 192000, kResamplingRMSError, -62.63),
 293         std::tr1::make_tuple(48000, 192000, kResamplingRMSError, -73.44),
 294         std::tr1::make_tuple(96000, 192000, kResamplingRMSError, -73.52),
 295         std::tr1::make_tuple(192000, 192000, kResamplingRMSError, -73.52),
 296
 297         // Next run through some additional cases interesting for WebRTC.
 298         // We skip some extreme downsampled cases (192 -> {8, 16}, 96 -> 8)
 299         // because they violate |kHighFrequencyMaxError|, which is not
 300         // unexpected. It's very unlikely that we'll see these conversions in
 301         // practice anyway.
 302
 303         // To 8 kHz
 304         std::tr1::make_tuple(8000, 8000, kResamplingRMSError, -75.50),
 305         std::tr1::make_tuple(16000, 8000, -18.56, -28.79),
 306         std::tr1::make_tuple(32000, 8000, -20.36, -14.13),
 307         std::tr1::make_tuple(44100, 8000, -21.00, -11.39),
 308         std::tr1::make_tuple(48000, 8000, -20.96, -11.04),
 309
 310         // To 16 kHz
 311         std::tr1::make_tuple(8000, 16000, kResamplingRMSError, -70.30),
 312         std::tr1::make_tuple(16000, 16000, kResamplingRMSError, -75.51),
 313         std::tr1::make_tuple(32000, 16000, -18.48, -28.59),
 314         std::tr1::make_tuple(44100, 16000, -19.30, -19.67),
 315         std::tr1::make_tuple(48000, 16000, -19.81, -18.11),
 316         std::tr1::make_tuple(96000, 16000, -20.95, -10.96),
 317
 318         // To 32 kHz
 319         std::tr1::make_tuple(8000, 32000, kResamplingRMSError, -70.30),
 320         std::tr1::make_tuple(16000, 32000, kResamplingRMSError, -75.51),
 321         std::tr1::make_tuple(32000, 32000, kResamplingRMSError, -75.51),
 322         std::tr1::make_tuple(44100, 32000, -16.44, -51.10),
 323         std::tr1::make_tuple(48000, 32000, -16.90, -44.03),
 324         std::tr1::make_tuple(96000, 32000, -19.61, -18.04),
 325         std::tr1::make_tuple(192000, 32000, -21.02, -10.94)));
 326
 327 }  // namespace webrtc