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