audio_converter_unittest.cc 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  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. #include "media/base/audio_converter.h"
  5. #include <stddef.h>
  6. #include <memory>
  7. #include <tuple>
  8. #include "base/strings/string_number_conversions.h"
  9. #include "media/base/audio_timestamp_helper.h"
  10. #include "media/base/fake_audio_render_callback.h"
  11. #include "testing/gmock/include/gmock/gmock.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace media {
  14. // Parameters which control the many input case tests.
  15. static const int kConvertInputs = 8;
  16. static const int kConvertCycles = 3;
  17. // Parameters used for testing.
  18. static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
  19. static const int kHighLatencyBufferSize = 2048;
  20. static const int kLowLatencyBufferSize = 256;
  21. static const int kSampleRate = 48000;
  22. // Number of full sine wave cycles for each Render() call.
  23. static const int kSineCycles = 4;
  24. // Tuple of <input rate, output rate, output channel layout, epsilon>.
  25. typedef std::tuple<int, int, ChannelLayout, double> AudioConverterTestData;
  26. class AudioConverterTest
  27. : public testing::TestWithParam<AudioConverterTestData> {
  28. public:
  29. AudioConverterTest() : epsilon_(std::get<3>(GetParam())) {
  30. // Create input and output parameters based on test parameters.
  31. input_parameters_ =
  32. AudioParameters(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
  33. std::get<0>(GetParam()), kHighLatencyBufferSize);
  34. output_parameters_ = AudioParameters(
  35. AudioParameters::AUDIO_PCM_LOW_LATENCY, std::get<2>(GetParam()),
  36. std::get<1>(GetParam()), kLowLatencyBufferSize);
  37. converter_ = std::make_unique<AudioConverter>(input_parameters_,
  38. output_parameters_, false);
  39. audio_bus_ = AudioBus::Create(output_parameters_);
  40. expected_audio_bus_ = AudioBus::Create(output_parameters_);
  41. // Allocate one callback for generating expected results.
  42. double step = kSineCycles / static_cast<double>(
  43. output_parameters_.frames_per_buffer());
  44. expected_callback_ =
  45. std::make_unique<FakeAudioRenderCallback>(step, kSampleRate);
  46. }
  47. AudioConverterTest(const AudioConverterTest&) = delete;
  48. AudioConverterTest& operator=(const AudioConverterTest&) = delete;
  49. // Creates |count| input callbacks to be used for conversion testing.
  50. void InitializeInputs(int count) {
  51. // Setup FakeAudioRenderCallback step to compensate for resampling.
  52. double scale_factor = input_parameters_.sample_rate() /
  53. static_cast<double>(output_parameters_.sample_rate());
  54. double step = kSineCycles / (scale_factor *
  55. static_cast<double>(output_parameters_.frames_per_buffer()));
  56. for (int i = 0; i < count; ++i) {
  57. fake_callbacks_.push_back(
  58. std::make_unique<FakeAudioRenderCallback>(step, kSampleRate));
  59. converter_->AddInput(fake_callbacks_[i].get());
  60. }
  61. }
  62. // Resets all input callbacks to a pristine state.
  63. void Reset() {
  64. converter_->Reset();
  65. for (size_t i = 0; i < fake_callbacks_.size(); ++i)
  66. fake_callbacks_[i]->reset();
  67. expected_callback_->reset();
  68. }
  69. // Sets the volume on all input callbacks to |volume|.
  70. void SetVolume(float volume) {
  71. for (size_t i = 0; i < fake_callbacks_.size(); ++i)
  72. fake_callbacks_[i]->set_volume(volume);
  73. }
  74. // Validates audio data between |audio_bus_| and |expected_audio_bus_| from
  75. // |index|..|frames| after |scale| is applied to the expected audio data.
  76. bool ValidateAudioData(int index, int frames, float scale) {
  77. for (int i = 0; i < audio_bus_->channels(); ++i) {
  78. for (int j = index; j < frames; ++j) {
  79. double error = fabs(audio_bus_->channel(i)[j] -
  80. expected_audio_bus_->channel(i)[j] * scale);
  81. if (error > epsilon_) {
  82. EXPECT_NEAR(expected_audio_bus_->channel(i)[j] * scale,
  83. audio_bus_->channel(i)[j], epsilon_)
  84. << " i=" << i << ", j=" << j;
  85. return false;
  86. }
  87. }
  88. }
  89. return true;
  90. }
  91. // Runs a single Convert() stage, fills |expected_audio_bus_| appropriately,
  92. // and validates equality with |audio_bus_| after |scale| is applied.
  93. bool RenderAndValidateAudioData(float scale) {
  94. // Render actual audio data.
  95. converter_->Convert(audio_bus_.get());
  96. // Render expected audio data.
  97. expected_callback_->Render(base::TimeDelta(), base::TimeTicks::Now(), 0,
  98. expected_audio_bus_.get());
  99. // Zero out unused channels in the expected AudioBus just as AudioConverter
  100. // would during channel mixing.
  101. for (int i = input_parameters_.channels();
  102. i < output_parameters_.channels(); ++i) {
  103. memset(expected_audio_bus_->channel(i), 0,
  104. audio_bus_->frames() * sizeof(*audio_bus_->channel(i)));
  105. }
  106. return ValidateAudioData(0, audio_bus_->frames(), scale);
  107. }
  108. // Fills |audio_bus_| fully with |value|.
  109. void FillAudioData(float value) {
  110. for (int i = 0; i < audio_bus_->channels(); ++i) {
  111. std::fill(audio_bus_->channel(i),
  112. audio_bus_->channel(i) + audio_bus_->frames(), value);
  113. }
  114. }
  115. // Verifies converter output with a |inputs| number of transform inputs.
  116. void RunTest(int inputs) {
  117. InitializeInputs(inputs);
  118. SetVolume(0);
  119. for (int i = 0; i < kConvertCycles; ++i)
  120. ASSERT_TRUE(RenderAndValidateAudioData(0));
  121. Reset();
  122. // Set a different volume for each input and verify the results.
  123. float total_scale = 0;
  124. for (size_t i = 0; i < fake_callbacks_.size(); ++i) {
  125. float volume = static_cast<float>(i) / fake_callbacks_.size();
  126. total_scale += volume;
  127. fake_callbacks_[i]->set_volume(volume);
  128. }
  129. for (int i = 0; i < kConvertCycles; ++i)
  130. ASSERT_TRUE(RenderAndValidateAudioData(total_scale));
  131. Reset();
  132. // Remove every other input.
  133. for (size_t i = 1; i < fake_callbacks_.size(); i += 2)
  134. converter_->RemoveInput(fake_callbacks_[i].get());
  135. SetVolume(1);
  136. float scale = inputs > 1 ? inputs / 2.0f : inputs;
  137. for (int i = 0; i < kConvertCycles; ++i)
  138. ASSERT_TRUE(RenderAndValidateAudioData(scale));
  139. }
  140. protected:
  141. virtual ~AudioConverterTest() = default;
  142. // Converter under test.
  143. std::unique_ptr<AudioConverter> converter_;
  144. // Input and output parameters used for AudioConverter construction.
  145. AudioParameters input_parameters_;
  146. AudioParameters output_parameters_;
  147. // Destination AudioBus for AudioConverter output.
  148. std::unique_ptr<AudioBus> audio_bus_;
  149. // AudioBus containing expected results for comparison with |audio_bus_|.
  150. std::unique_ptr<AudioBus> expected_audio_bus_;
  151. // Vector of all input callbacks used to drive AudioConverter::Convert().
  152. std::vector<std::unique_ptr<FakeAudioRenderCallback>> fake_callbacks_;
  153. // Parallel input callback which generates the expected output.
  154. std::unique_ptr<FakeAudioRenderCallback> expected_callback_;
  155. // Epsilon value with which to perform comparisons between |audio_bus_| and
  156. // |expected_audio_bus_|.
  157. double epsilon_;
  158. };
  159. // Ensure the buffer delay provided by AudioConverter is accurate.
  160. TEST(AudioConverterTest, AudioDelayAndDiscreteChannelCount) {
  161. // Choose input and output parameters such that the transform must make
  162. // multiple calls to fill the buffer.
  163. AudioParameters input_parameters(AudioParameters::AUDIO_PCM_LINEAR,
  164. CHANNEL_LAYOUT_DISCRETE, kSampleRate,
  165. kLowLatencyBufferSize);
  166. input_parameters.set_channels_for_discrete(10);
  167. AudioParameters output_parameters(AudioParameters::AUDIO_PCM_LINEAR,
  168. CHANNEL_LAYOUT_DISCRETE, kSampleRate * 2,
  169. kHighLatencyBufferSize);
  170. output_parameters.set_channels_for_discrete(5);
  171. AudioConverter converter(input_parameters, output_parameters, false);
  172. FakeAudioRenderCallback callback(0.2, kSampleRate);
  173. std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
  174. converter.AddInput(&callback);
  175. converter.Convert(audio_bus.get());
  176. // double input_sample_rate = input_parameters.sample_rate();
  177. // int fill_count =
  178. // (output_parameters.frames_per_buffer() * input_sample_rate /
  179. // output_parameters.sample_rate()) /
  180. // input_parameters.frames_per_buffer();
  181. //
  182. // This magic number is the accumulated MultiChannelResampler delay after
  183. // |fill_count| (4) callbacks to provide input. The number of frames delayed
  184. // is an implementation detail of the SincResampler chunk size (480 for the
  185. // first two callbacks, 512 for the last two callbacks). See
  186. // SincResampler.ChunkSize().
  187. int kExpectedDelay = 992;
  188. auto expected_delay =
  189. AudioTimestampHelper::FramesToTime(kExpectedDelay, kSampleRate);
  190. EXPECT_EQ(expected_delay, callback.last_delay());
  191. EXPECT_EQ(input_parameters.channels(), callback.last_channel_count());
  192. }
  193. TEST_P(AudioConverterTest, ArbitraryOutputRequestSize) {
  194. // Resize output bus to be half of |output_parameters_|'s frames_per_buffer().
  195. audio_bus_ = AudioBus::Create(output_parameters_.channels(),
  196. output_parameters_.frames_per_buffer() / 2);
  197. RunTest(1);
  198. }
  199. TEST_P(AudioConverterTest, NoInputs) {
  200. FillAudioData(1.0f);
  201. EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
  202. }
  203. TEST_P(AudioConverterTest, OneInput) {
  204. RunTest(1);
  205. }
  206. TEST_P(AudioConverterTest, ManyInputs) {
  207. RunTest(kConvertInputs);
  208. }
  209. INSTANTIATE_TEST_SUITE_P(
  210. AudioConverterTest,
  211. AudioConverterTest,
  212. testing::Values(
  213. // No resampling. No channel mixing.
  214. std::make_tuple(44100, 44100, CHANNEL_LAYOUT_STEREO, 0.00000048),
  215. // Upsampling. Channel upmixing.
  216. std::make_tuple(44100, 48000, CHANNEL_LAYOUT_QUAD, 0.033),
  217. // Downsampling. Channel downmixing.
  218. std::make_tuple(48000, 41000, CHANNEL_LAYOUT_MONO, 0.042)));
  219. } // namespace media