Collapse AudioRendererMixer and OnMoreDataResampler into AudioTransform.

media/base/audio_transform_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.
+
+// MSVC++ requires this to be set before any other includes to get M_PI.
+#define _USE_MATH_DEFINES
+
+#include <cmath>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/string_number_conversions.h"
+#include "base/time.h"
+#include "media/base/audio_transform.h"
+#include "media/base/fake_audio_render_callback.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+// Command line switch for runtime adjustment of benchmark iterations.
+static const char kBenchmarkIterations[] = "audio-converter-iterations";
+static const int kDefaultIterations = 10;
+
+// Parameters which control the many input case tests.
+static const int kConvertInputs = 8;
+static const int kConvertCycles = 3;
+
+// Parameters used for testing.
+static const int kBitsPerChannel = 32;
+static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
+static const int kHighLatencyBufferSize = 2048;
+static const int kLowLatencyBufferSize = 256;
+static const int kSampleRate = 48000;
+
+// Number of full sine wave cycles for each Render() call.
+static const int kSineCycles = 4;
+
+// Tuple of <input sampling rate, output sampling rate, epsilon>.
+typedef std::tr1::tuple<int, int, double> AudioConverterTestData;
+class AudioConverterTest
+    : public testing::TestWithParam<AudioConverterTestData> {
+ public:
+  AudioConverterTest()
+      : epsilon_(std::tr1::get<2>(GetParam())) {
+    // Create input and output parameters based on test parameters.
+    input_parameters_ = AudioParameters(
+        AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
+        std::tr1::get<0>(GetParam()), kBitsPerChannel, kHighLatencyBufferSize);
+    output_parameters_ = AudioParameters(
+        AudioParameters::AUDIO_PCM_LOW_LATENCY, kChannelLayout,
+        std::tr1::get<1>(GetParam()), 16, kLowLatencyBufferSize);
+
+    converter_.reset(new AudioConverter(
+        input_parameters_, output_parameters_, false));
+
+    audio_bus_ = AudioBus::Create(output_parameters_);
+    expected_audio_bus_ = AudioBus::Create(output_parameters_);
+
+    // Allocate one callback for generating expected results.
+    double step = kSineCycles / static_cast<double>(
+        output_parameters_.frames_per_buffer());
+    expected_callback_.reset(new FakeAudioRenderCallback(step));
+  }
+
+  void InitializeInputs(int count) {
+    // Setup FakeAudioRenderCallback step to compensate for resampling.
+    double scale_factor = input_parameters_.sample_rate() /
+        static_cast<double>(output_parameters_.sample_rate());
+    double step = kSineCycles / (scale_factor *
+        static_cast<double>(output_parameters_.frames_per_buffer()));
+
+    for (int i = 0; i < count; ++i) {
+      fake_callbacks_.push_back(new FakeAudioRenderCallback(step));
+      converter_->AddInput(fake_callbacks_[i]);
+    }
+  }
+
+  void Reset() {
+    converter_->Reset();
+    for (size_t i = 0; i < fake_callbacks_.size(); ++i)
+      fake_callbacks_[i]->reset();
+    expected_callback_->reset();
+  }
+
+  void SetVolume(float volume) {
+    for (size_t i = 0; i < fake_callbacks_.size(); ++i)
+      fake_callbacks_[i]->set_volume(volume);
+  }
+
+  bool ValidateAudioData(int index, int frames, float scale) {
+    for (int i = 0; i < audio_bus_->channels(); ++i) {
+      for (int j = index; j < frames; j++) {
+        double error = fabs(audio_bus_->channel(i)[j] -
+            expected_audio_bus_->channel(i)[j] * scale);
+        if (error > epsilon_) {
+          EXPECT_NEAR(expected_audio_bus_->channel(i)[j] * scale,
+                      audio_bus_->channel(i)[j], epsilon_)
+              << " i=" << i << ", j=" << j;
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  bool RenderAndValidateAudioData(float scale) {
+    // Render actual audio data.
+    converter_->Convert(audio_bus_.get());
+
+    // Render expected audio data.
+    expected_callback_->Render(expected_audio_bus_.get(), 0);
+
+    return ValidateAudioData(0, audio_bus_->frames(), scale);
+  }
+
+  // Fill |audio_bus_| fully with |value|.
+  void FillAudioData(float value) {
+    for (int i = 0; i < audio_bus_->channels(); ++i) {
+      std::fill(audio_bus_->channel(i),
+                audio_bus_->channel(i) + audio_bus_->frames(), value);
+    }
+  }
+
+  // Verify output with a number of transform inputs.
+  void RunTest(int inputs) {
+    InitializeInputs(inputs);
+
+    SetVolume(0);
+    for (int i = 0; i < kConvertCycles; ++i)
+      ASSERT_TRUE(RenderAndValidateAudioData(0));
+
+    Reset();
+
+    // Set a different volume for each input and verify the results.
+    float total_scale = 0;
+    for (size_t i = 0; i < fake_callbacks_.size(); ++i) {
+      float volume = static_cast<float>(i) / fake_callbacks_.size();
+      total_scale += volume;
+      fake_callbacks_[i]->set_volume(volume);
+    }
+    for (int i = 0; i < kConvertCycles; ++i)
+      ASSERT_TRUE(RenderAndValidateAudioData(total_scale));
+
+    Reset();
+
+    // Remove every other input.
+    for (size_t i = 1; i < fake_callbacks_.size(); i += 2)
+      converter_->RemoveInput(fake_callbacks_[i]);
+
+    SetVolume(1);
+    float scale = inputs > 1 ? inputs / 2.0f : inputs;
+    for (int i = 0; i < kConvertCycles; ++i)
+      ASSERT_TRUE(RenderAndValidateAudioData(scale));
+  }
+
+ protected:
+  virtual ~AudioConverterTest() {}
+
+  scoped_ptr<AudioConverter> converter_;
+  AudioParameters input_parameters_;
+  AudioParameters output_parameters_;
+  scoped_ptr<AudioBus> audio_bus_;
+  scoped_ptr<AudioBus> expected_audio_bus_;
+  ScopedVector<FakeAudioRenderCallback> fake_callbacks_;
+  scoped_ptr<FakeAudioRenderCallback> expected_callback_;
+  double epsilon_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioConverterTest);
+};
+
+// Ensure the buffer delay provided by AudioConverter is accurate.
+TEST(AudioConverterTest, AudioDelay) {
+  // Choose input and output parameters such that the transform must make
+  // multiple calls to fill the buffer.
+  AudioParameters input_parameters = AudioParameters(
+      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate,
+      kBitsPerChannel, kLowLatencyBufferSize);
+  AudioParameters output_parameters = AudioParameters(
+      AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout, kSampleRate * 2,
+      kBitsPerChannel, kHighLatencyBufferSize);
+
+  AudioConverter converter(input_parameters, output_parameters, false);
+  FakeAudioRenderCallback callback(0.2);
+  scoped_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
+  converter.AddInput(&callback);
+  converter.Convert(audio_bus.get());
+
+  // Calculate the expected buffer delay for given AudioParameters.
+  double input_sample_rate = input_parameters.sample_rate();
+  int fill_count =
+      (output_parameters.frames_per_buffer() * input_sample_rate /
+       output_parameters.sample_rate()) / input_parameters.frames_per_buffer();
+
+  base::TimeDelta input_frame_duration = base::TimeDelta::FromMicroseconds(
+      base::Time::kMicrosecondsPerSecond / input_sample_rate);
+
+  int expected_last_delay_milliseconds =
+      fill_count * input_parameters.frames_per_buffer() *
+      input_frame_duration.InMillisecondsF();
+
+  EXPECT_EQ(expected_last_delay_milliseconds,
+            callback.last_audio_delay_milliseconds());
+}
+
+// Benchmark for audio conversion.  Original benchmarks were run with
+// --audio-converter-iterations=50000.
+TEST(AudioConverterTest, ConvertBenchmark) {

[scherkus (not reviewing), 2012/11/17 01:04:37]

is this going to run every time and logspam to console?

it can be DISABLED_ and combined with --gtest_also_run_disabled_tests
--gtest_filter=AudioConvererTest.ConvertBenchmark

[DaleCurtis, 2012/11/17 01:07:14]

Yes and yes it could be. fischman and I discussed this some time back and
settled on leaving it enabled with a small number of iterations (see
SincResampler and VectorMath unittests). Two printfs() in one test aren't going
to be even noticed by anyone.

[scherkus (not reviewing), 2012/11/20 00:51:10]

I'll let it slide but this is some slippery-slope reasonsing :)

+  int benchmark_iterations = kDefaultIterations;
+  std::string iterations(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      kBenchmarkIterations));
+  base::StringToInt(iterations, &benchmark_iterations);
+  if (benchmark_iterations < kDefaultIterations)
+    benchmark_iterations = kDefaultIterations;
+
+  // Create input and output parameters to convert between the two most common
+  // sets of parameters (as indicated via UMA data).
+  AudioParameters input_params(
+      AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_MONO, 48000, 16, 2048);
+  AudioParameters output_params(
+      AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 44100, 16, 440);
+  scoped_ptr<AudioConverter> converter(
+      new AudioConverter(input_params, output_params, false));
+
+  scoped_ptr<AudioBus> output_bus = AudioBus::Create(output_params);
+  FakeAudioRenderCallback fake_input1(0.2);
+  FakeAudioRenderCallback fake_input2(0.4);
+  FakeAudioRenderCallback fake_input3(0.6);
+  converter->AddInput(&fake_input1);
+  converter->AddInput(&fake_input2);
+  converter->AddInput(&fake_input3);
+
+  printf("Benchmarking %d iterations:\n", benchmark_iterations);
+
+  // Benchmark Convert() w/ FIFO.
+  base::TimeTicks start = base::TimeTicks::HighResNow();
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    converter->Convert(output_bus.get());
+  }
+  double total_time_ms =
+      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
+  printf("Convert() w/ FIFO took %.2fms.\n", total_time_ms);
+
+  converter.reset(new AudioConverter(input_params, output_params, true));
+  converter->AddInput(&fake_input1);
+  converter->AddInput(&fake_input2);
+  converter->AddInput(&fake_input3);
+
+  // Benchmark Convert() w/o FIFO.
+  start = base::TimeTicks::HighResNow();
+  for (int i = 0; i < benchmark_iterations; ++i) {
+    converter->Convert(output_bus.get());
+  }
+  total_time_ms =
+      (base::TimeTicks::HighResNow() - start).InMillisecondsF();
+  printf("Convert() w/o FIFO took %.2fms.\n", total_time_ms);
+}
+
+TEST_P(AudioConverterTest, NoInputs) {
+  FillAudioData(1.0f);
+  EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
+}
+
+TEST_P(AudioConverterTest, OneInput) {
+  RunTest(1);
+}
+
+TEST_P(AudioConverterTest, ManyInputs) {
+  RunTest(kConvertInputs);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    // TODO(dalecurtis): Add test cases for channel transforms.
+    AudioConverterTest, AudioConverterTest, testing::Values(
+        // No resampling.
+        std::tr1::make_tuple(44100, 44100, 0.00000048),
+
+        // Upsampling.
+        std::tr1::make_tuple(44100, 48000, 0.033),
+
+        // Downsampling.
+        std::tr1::make_tuple(48000, 41000, 0.042)));
+
+}  // namespace media