media/base/audio_converter_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/command_line.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/scoped_vector.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/time/time.h"
  16 #include "media/base/audio_converter.h"
  17 #include "media/base/fake_audio_render_callback.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace media {
  22
  23 // Command line switch for runtime adjustment of benchmark iterations.
  24 static const char kBenchmarkIterations[] = "audio-converter-iterations";
  25 static const int kDefaultIterations = 10;
  26
  27 // Parameters which control the many input case tests.
  28 static const int kConvertInputs = 8;
  29 static const int kConvertCycles = 3;
  30
  31 // Parameters used for testing.
  32 static const int kBitsPerChannel = 32;
  33 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
  34 static const int kHighLatencyBufferSize = 2048;
  35 static const int kLowLatencyBufferSize = 256;
  36 static const int kSampleRate = 48000;
  37
  38 // Number of full sine wave cycles for each Render() call.
  39 static const int kSineCycles = 4;
  40
  41 // Tuple of <input rate, output rate, output channel layout, epsilon>.
  42 typedef std::tr1::tuple<int, int, ChannelLayout, double> AudioConverterTestData;
  43 class AudioConverterTest
  44     : public testing::TestWithParam<AudioConverterTestData> {
  45  public:
  46   AudioConverterTest()
  47       : epsilon_(std::tr1::get<3>(GetParam())) {
  48     // Create input and output parameters based on test parameters.
  49     input_parameters_ = AudioParameters(
  50         AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
  51         std::tr1::get<0>(GetParam()), kBitsPerChannel, kHighLatencyBufferSize);
  52     output_parameters_ = AudioParameters(
  53         AudioParameters::AUDIO_PCM_LOW_LATENCY, std::tr1::get<2>(GetParam()),
  54         std::tr1::get<1>(GetParam()), 16, kLowLatencyBufferSize);
  55
  56     converter_.reset(new AudioConverter(
  57         input_parameters_, output_parameters_, false));
  58
  59     audio_bus_ = AudioBus::Create(output_parameters_);
  60     expected_audio_bus_ = AudioBus::Create(output_parameters_);
  61
  62     // Allocate one callback for generating expected results.
  63     double step = kSineCycles / static_cast<double>(
  64         output_parameters_.frames_per_buffer());
  65     expected_callback_.reset(new FakeAudioRenderCallback(step));
  66   }
  67
  68   // Creates |count| input callbacks to be used for conversion testing.
  69   void InitializeInputs(int count) {
  70     // Setup FakeAudioRenderCallback step to compensate for resampling.
  71     double scale_factor = input_parameters_.sample_rate() /
  72         static_cast<double>(output_parameters_.sample_rate());
  73     double step = kSineCycles / (scale_factor *
  74         static_cast<double>(output_parameters_.frames_per_buffer()));
  75
  76     for (int i = 0; i < count; ++i) {
  77       fake_callbacks_.push_back(new FakeAudioRenderCallback(step));
  78       converter_->AddInput(fake_callbacks_[i]);
  79     }
  80   }
  81
  82   // Resets all input callbacks to a pristine state.
  83   void Reset() {
  84     converter_->Reset();
  85     for (size_t i = 0; i < fake_callbacks_.size(); ++i)
  86       fake_callbacks_[i]->reset();
  87     expected_callback_->reset();
  88   }
  89
  90   // Sets the volume on all input callbacks to |volume|.
  91   void SetVolume(float volume) {
  92     for (size_t i = 0; i < fake_callbacks_.size(); ++i)
  93       fake_callbacks_[i]->set_volume(volume);
  94   }
  95
  96   // Validates audio data between |audio_bus_| and |expected_audio_bus_| from
  97   // |index|..|frames| after |scale| is applied to the expected audio data.
  98   bool ValidateAudioData(int index, int frames, float scale) {
  99     for (int i = 0; i < audio_bus_->channels(); ++i) {
 100       for (int j = index; j < frames; ++j) {
 101         double error = fabs(audio_bus_->channel(i)[j] -
 102             expected_audio_bus_->channel(i)[j] * scale);
 103         if (error > epsilon_) {
 104           EXPECT_NEAR(expected_audio_bus_->channel(i)[j] * scale,
 105                       audio_bus_->channel(i)[j], epsilon_)
 106               << " i=" << i << ", j=" << j;
 107           return false;
 108         }
 109       }
 110     }
 111     return true;
 112   }
 113
 114   // Runs a single Convert() stage, fills |expected_audio_bus_| appropriately,
 115   // and validates equality with |audio_bus_| after |scale| is applied.
 116   bool RenderAndValidateAudioData(float scale) {
 117     // Render actual audio data.
 118     converter_->Convert(audio_bus_.get());
 119
 120     // Render expected audio data.
 121     expected_callback_->Render(expected_audio_bus_.get(), 0);
 122
 123     // Zero out unused channels in the expected AudioBus just as AudioConverter
 124     // would during channel mixing.
 125     for (int i = input_parameters_.channels();
 126          i < output_parameters_.channels(); ++i) {
 127       memset(expected_audio_bus_->channel(i), 0,
 128              audio_bus_->frames() * sizeof(*audio_bus_->channel(i)));
 129     }
 130
 131     return ValidateAudioData(0, audio_bus_->frames(), scale);
 132   }
 133
 134   // Fills |audio_bus_| fully with |value|.
 135   void FillAudioData(float value) {
 136     for (int i = 0; i < audio_bus_->channels(); ++i) {
 137       std::fill(audio_bus_->channel(i),
 138                 audio_bus_->channel(i) + audio_bus_->frames(), value);
 139     }
 140   }
 141
 142   // Verifies converter output with a |inputs| number of transform inputs.
 143   void RunTest(int inputs) {
 144     InitializeInputs(inputs);
 145
 146     SetVolume(0);
 147     for (int i = 0; i < kConvertCycles; ++i)
 148       ASSERT_TRUE(RenderAndValidateAudioData(0));
 149
 150     Reset();
 151
 152     // Set a different volume for each input and verify the results.
 153     float total_scale = 0;
 154     for (size_t i = 0; i < fake_callbacks_.size(); ++i) {
 155       float volume = static_cast<float>(i) / fake_callbacks_.size();
 156       total_scale += volume;
 157       fake_callbacks_[i]->set_volume(volume);
 158     }
 159     for (int i = 0; i < kConvertCycles; ++i)
 160       ASSERT_TRUE(RenderAndValidateAudioData(total_scale));
 161
 162     Reset();
 163
 164     // Remove every other input.
 165     for (size_t i = 1; i < fake_callbacks_.size(); i += 2)
 166       converter_->RemoveInput(fake_callbacks_[i]);
 167
 168     SetVolume(1);
 169     float scale = inputs > 1 ? inputs / 2.0f : inputs;
 170     for (int i = 0; i < kConvertCycles; ++i)
 171       ASSERT_TRUE(RenderAndValidateAudioData(scale));
 172   }
 173
 174  protected:
 175   virtual ~AudioConverterTest() {}
 176
 177   // Converter under test.
 178   scoped_ptr<AudioConverter> converter_;
 179
 180   // Input and output parameters used for AudioConverter construction.
 181   AudioParameters input_parameters_;
 182   AudioParameters output_parameters_;
 183
 184   // Destination AudioBus for AudioConverter output.
 185   scoped_ptr<AudioBus> audio_bus_;
 186
 187   // AudioBus containing expected results for comparison with |audio_bus_|.
 188   scoped_ptr<AudioBus> expected_audio_bus_;
 189
 190   // Vector of all input callbacks used to drive AudioConverter::Convert().
 191   ScopedVector<FakeAudioRenderCallback> fake_callbacks_;
 192
 193   // Parallel input callback which generates the expected output.
 194   scoped_ptr<FakeAudioRenderCallback> expected_callback_;
 195
 196   // Epsilon value with which to perform comparisons between |audio_bus_| and
 197   // |expected_audio_bus_|.
 198   double epsilon_;
 199
 200   DISALLOW_COPY_AND_ASSIGN(AudioConverterTest);
 201 };
 202
 203 // Ensure the buffer delay provided by AudioConverter is accurate.
 204 TEST(AudioConverterTest, AudioDelay) {
 205   // Choose input and output parameters such that the transform must make
 206   // multiple calls to fill the buffer.
 207   AudioParameters input_parameters = AudioParameters(
 208       AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
 209       kBitsPerChannel, kLowLatencyBufferSize);
 210   AudioParameters output_parameters = AudioParameters(
 211       AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate * 2,
 212       kBitsPerChannel, kHighLatencyBufferSize);
 213
 214   AudioConverter converter(input_parameters, output_parameters, false);
 215   FakeAudioRenderCallback callback(0.2);
 216   scoped_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
 217   converter.AddInput(&callback);
 218   converter.Convert(audio_bus.get());
 219
 220   // Calculate the expected buffer delay for given AudioParameters.
 221   double input_sample_rate = input_parameters.sample_rate();
 222   int fill_count =
 223       (output_parameters.frames_per_buffer() * input_sample_rate /
 224        output_parameters.sample_rate()) / input_parameters.frames_per_buffer();
 225
 226   base::TimeDelta input_frame_duration = base::TimeDelta::FromMicroseconds(
 227       base::Time::kMicrosecondsPerSecond / input_sample_rate);
 228
 229   int expected_last_delay_milliseconds =
 230       fill_count * input_parameters.frames_per_buffer() *
 231       input_frame_duration.InMillisecondsF();
 232
 233   EXPECT_EQ(expected_last_delay_milliseconds,
 234             callback.last_audio_delay_milliseconds());
 235 }
 236
 237 // InputCallback that zero's out the provided AudioBus.  Used for benchmarking.
 238 class NullInputProvider : public AudioConverter::InputCallback {
 239  public:
 240   NullInputProvider() {}
 241   virtual ~NullInputProvider() {}
 242
 243   virtual double ProvideInput(AudioBus* audio_bus,
 244                               base::TimeDelta buffer_delay) OVERRIDE {
 245     audio_bus->Zero();
 246     return 1;
 247   }
 248 };
 249
 250 // Benchmark for audio conversion.  Original benchmarks were run with
 251 // --audio-converter-iterations=50000.
 252 TEST(AudioConverterTest, ConvertBenchmark) {
 253   int benchmark_iterations = kDefaultIterations;
 254   std::string iterations(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 255       kBenchmarkIterations));
 256   base::StringToInt(iterations, &benchmark_iterations);
 257   if (benchmark_iterations < kDefaultIterations)
 258     benchmark_iterations = kDefaultIterations;
 259
 260   NullInputProvider fake_input1;
 261   NullInputProvider fake_input2;
 262   NullInputProvider fake_input3;
 263
 264   printf("Benchmarking %d iterations:\n", benchmark_iterations);
 265
 266   {
 267     // Create input and output parameters to convert between the two most common
 268     // sets of parameters (as indicated via UMA data).
 269     AudioParameters input_params(
 270         AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO,
 271         48000, 16, 2048);
 272     AudioParameters output_params(
 273         AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
 274         44100, 16, 440);
 275     scoped_ptr<AudioBus> output_bus = AudioBus::Create(output_params);
 276
 277     scoped_ptr<AudioConverter> converter(
 278         new AudioConverter(input_params, output_params, true));
 279     converter->AddInput(&fake_input1);
 280     converter->AddInput(&fake_input2);
 281     converter->AddInput(&fake_input3);
 282
 283     // Benchmark Convert() w/ FIFO.
 284     base::TimeTicks start = base::TimeTicks::HighResNow();
 285     for (int i = 0; i < benchmark_iterations; ++i) {
 286       converter->Convert(output_bus.get());
 287     }
 288     double total_time_ms =
 289         (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 290     printf("Convert() w/ Resampling took %.2fms.\n", total_time_ms);
 291   }
 292
 293   // Create input and output parameters to convert between common buffer sizes
 294   // without any resampling for the FIFO vs no FIFO benchmarks.
 295   AudioParameters input_params(
 296       AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
 297       44100, 16, 2048);
 298   AudioParameters output_params(
 299       AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO,
 300       44100, 16, 440);
 301   scoped_ptr<AudioBus> output_bus = AudioBus::Create(output_params);
 302
 303   {
 304     scoped_ptr<AudioConverter> converter(
 305         new AudioConverter(input_params, output_params, false));
 306     converter->AddInput(&fake_input1);
 307     converter->AddInput(&fake_input2);
 308     converter->AddInput(&fake_input3);
 309
 310     // Benchmark Convert() w/ FIFO.
 311     base::TimeTicks start = base::TimeTicks::HighResNow();
 312     for (int i = 0; i < benchmark_iterations; ++i) {
 313       converter->Convert(output_bus.get());
 314     }
 315     double total_time_ms =
 316         (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 317     printf("Convert() w/ FIFO took %.2fms.\n", total_time_ms);
 318   }
 319
 320   {
 321     scoped_ptr<AudioConverter> converter(
 322         new AudioConverter(input_params, output_params, true));
 323     converter->AddInput(&fake_input1);
 324     converter->AddInput(&fake_input2);
 325     converter->AddInput(&fake_input3);
 326
 327     // Benchmark Convert() w/o FIFO.
 328     base::TimeTicks start = base::TimeTicks::HighResNow();
 329     for (int i = 0; i < benchmark_iterations; ++i) {
 330       converter->Convert(output_bus.get());
 331     }
 332     double total_time_ms =
 333         (base::TimeTicks::HighResNow() - start).InMillisecondsF();
 334     printf("Convert() w/o FIFO took %.2fms.\n", total_time_ms);
 335   }
 336 }
 337
 338 TEST_P(AudioConverterTest, NoInputs) {
 339   FillAudioData(1.0f);
 340   EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
 341 }
 342
 343 TEST_P(AudioConverterTest, OneInput) {
 344   RunTest(1);
 345 }
 346
 347 TEST_P(AudioConverterTest, ManyInputs) {
 348   RunTest(kConvertInputs);
 349 }
 350
 351 INSTANTIATE_TEST_CASE_P(
 352     AudioConverterTest, AudioConverterTest, testing::Values(
 353         // No resampling. No channel mixing.
 354         std::tr1::make_tuple(44100, 44100, CHANNEL_LAYOUT_STEREO, 0.00000048),
 355
 356         // Upsampling. Channel upmixing.
 357         std::tr1::make_tuple(44100, 48000, CHANNEL_LAYOUT_QUAD, 0.033),
 358
 359         // Downsampling. Channel downmixing.
 360         std::tr1::make_tuple(48000, 41000, CHANNEL_LAYOUT_MONO, 0.042)));
 361
 362 }  // namespace media