1 // Copyright 2013 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.
5 #include "media/audio/audio_power_monitor.h"
9 #include "base/time/time.h"
10 #include "media/base/audio_bus.h"
11 #include "testing/gtest/include/gtest/gtest.h"
15 static const int kSampleRate = 48000;
16 static const int kFramesPerBuffer = 128;
18 static const int kTimeConstantMillis = 5;
22 // Container for each parameterized test's data (input and expected results).
25 TestScenario(const float* data, int num_channels, int num_frames,
26 float expected_power, bool expected_clipped)
27 : expected_power_(expected_power), expected_clipped_(expected_clipped) {
28 CreatePopulatedBuffer(data, num_channels, num_frames);
31 // Copy constructor and assignment operator for ::testing::Values(...).
32 TestScenario(const TestScenario& other) { *this = other; }
33 TestScenario& operator=(const TestScenario& other) {
34 this->expected_power_ = other.expected_power_;
35 this->expected_clipped_ = other.expected_clipped_;
36 this->bus_ = AudioBus::Create(other.bus_->channels(), other.bus_->frames());
37 other.bus_->CopyTo(this->bus_.get());
41 // Returns this TestScenario, but with a bad sample value placed in the middle
43 TestScenario WithABadSample(float bad_value) const {
44 TestScenario result(*this);
45 result.bus_->channel(0)[result.bus_->frames() / 2] = bad_value;
49 const AudioBus& data() const {
53 float expected_power() const {
54 return expected_power_;
57 bool expected_clipped() const {
58 return expected_clipped_;
62 // Creates an AudioBus, sized and populated with kFramesPerBuffer frames of
63 // data. The given test |data| is repeated to fill the buffer.
64 void CreatePopulatedBuffer(
65 const float* data, int num_channels, int num_frames) {
66 bus_ = AudioBus::Create(num_channels, kFramesPerBuffer);
67 for (int ch = 0; ch < num_channels; ++ch) {
68 for (int frames = 0; frames < kFramesPerBuffer; frames += num_frames) {
69 const int num_to_copy = std::min(num_frames, kFramesPerBuffer - frames);
70 memcpy(bus_->channel(ch) + frames, data + num_frames * ch,
71 sizeof(float) * num_to_copy);
76 float expected_power_;
77 bool expected_clipped_;
78 scoped_ptr<AudioBus> bus_;
81 // Value printer for TestScenario. Required to prevent Valgrind "access to
82 // uninitialized memory" errors (http://crbug.com/263315).
83 ::std::ostream& operator<<(::std::ostream& os, const TestScenario& ts) {
84 return os << "{" << ts.data().channels() << "-channel signal} --> {"
85 << ts.expected_power() << " dBFS, "
86 << (ts.expected_clipped() ? "clipped" : "not clipped")
90 // An observer that receives power measurements. Each power measurement should
91 // should make progress towards the goal value.
92 class MeasurementObserver {
94 MeasurementObserver(float goal_power_measurement, bool goal_clipped)
95 : goal_power_measurement_(goal_power_measurement),
96 goal_clipped_(goal_clipped), measurement_count_(0),
97 last_power_measurement_(AudioPowerMonitor::zero_power()),
98 last_clipped_(false) {}
100 int measurement_count() const {
101 return measurement_count_;
104 float last_power_measurement() const {
105 return last_power_measurement_;
108 bool last_clipped() const {
109 return last_clipped_;
112 void OnPowerMeasured(float cur_power_measurement, bool clipped) {
113 if (measurement_count_ == 0) {
114 measurements_should_increase_ =
115 (cur_power_measurement < goal_power_measurement_);
117 SCOPED_TRACE(::testing::Message()
118 << "Power: goal=" << goal_power_measurement_
119 << "; last=" << last_power_measurement_
120 << "; cur=" << cur_power_measurement);
122 if (last_power_measurement_ != goal_power_measurement_) {
123 if (measurements_should_increase_) {
124 EXPECT_LE(last_power_measurement_, cur_power_measurement)
125 << "Measurements should be monotonically increasing.";
127 EXPECT_GE(last_power_measurement_, cur_power_measurement)
128 << "Measurements should be monotonically decreasing.";
131 EXPECT_EQ(last_power_measurement_, cur_power_measurement)
132 << "Measurements are numerically unstable at goal value.";
136 last_power_measurement_ = cur_power_measurement;
137 last_clipped_ = clipped;
138 ++measurement_count_;
142 const float goal_power_measurement_;
143 const bool goal_clipped_;
144 int measurement_count_;
145 bool measurements_should_increase_;
146 float last_power_measurement_;
149 DISALLOW_COPY_AND_ASSIGN(MeasurementObserver);
154 class AudioPowerMonitorTest : public ::testing::TestWithParam<TestScenario> {
156 AudioPowerMonitorTest()
157 : power_monitor_(kSampleRate,
158 base::TimeDelta::FromMilliseconds(kTimeConstantMillis)) {
161 void FeedAndCheckExpectedPowerIsMeasured(
162 const AudioBus& bus, float power, bool clipped) {
163 // Feed the AudioPowerMonitor, read measurements from it, and record them in
164 // MeasurementObserver.
165 static const int kNumFeedIters = 100;
166 MeasurementObserver observer(power, clipped);
167 for (int i = 0; i < kNumFeedIters; ++i) {
168 power_monitor_.Scan(bus, bus.frames());
169 const std::pair<float, bool>& reading =
170 power_monitor_.ReadCurrentPowerAndClip();
171 observer.OnPowerMeasured(reading.first, reading.second);
174 // Check that the results recorded by the observer are the same whole-number
176 EXPECT_EQ(static_cast<int>(power),
177 static_cast<int>(observer.last_power_measurement()));
178 EXPECT_EQ(clipped, observer.last_clipped());
182 AudioPowerMonitor power_monitor_;
184 DISALLOW_COPY_AND_ASSIGN(AudioPowerMonitorTest);
187 TEST_P(AudioPowerMonitorTest, MeasuresPowerOfSignal) {
188 const TestScenario& scenario = GetParam();
190 scoped_ptr<AudioBus> zeroed_bus =
191 AudioBus::Create(scenario.data().channels(), scenario.data().frames());
194 // Send a "zero power" audio signal, then this scenario's audio signal, then
195 // the "zero power" audio signal again; testing that the power monitor
196 // measurements match expected values.
197 FeedAndCheckExpectedPowerIsMeasured(
198 *zeroed_bus, AudioPowerMonitor::zero_power(), false);
199 FeedAndCheckExpectedPowerIsMeasured(
200 scenario.data(), scenario.expected_power(), scenario.expected_clipped());
201 FeedAndCheckExpectedPowerIsMeasured(
202 *zeroed_bus, AudioPowerMonitor::zero_power(), false);
205 static const float kMonoSilentNoise[] = {
209 static const float kMonoMaxAmplitude[] = {
213 static const float kMonoMaxAmplitude2[] = {
217 static const float kMonoHalfMaxAmplitude[] = {
218 0.5f, -0.5f, 0.5f, -0.5f
221 static const float kMonoAmplitudeClipped[] = {
225 static const float kMonoMaxAmplitudeWithClip[] = {
226 2.0f, 0.0, 0.0f, 0.0f
229 static const float kMonoMaxAmplitudeWithClip2[] = {
230 4.0f, 0.0, 0.0f, 0.0f
233 static const float kStereoSilentNoise[] = {
240 static const float kStereoMaxAmplitude[] = {
247 static const float kRightChannelMaxAmplitude[] = {
249 0.0f, 0.0f, 0.0f, 0.0f,
251 -1.0f, 1.0f, -1.0f, 1.0f
254 static const float kLeftChannelHalfMaxAmplitude[] = {
256 0.5f, -0.5f, 0.5f, -0.5f,
258 0.0f, 0.0f, 0.0f, 0.0f,
261 static const float kStereoMixed[] = {
263 0.5f, -0.5f, 0.5f, -0.5f,
265 -1.0f, 1.0f, -1.0f, 1.0f
268 static const float kStereoMixed2[] = {
270 1.0f, -1.0f, 0.75f, -0.75f, 0.5f, -0.5f, 0.25f, -0.25f,
272 0.25f, -0.25f, 0.5f, -0.5f, 0.75f, -0.75f, 1.0f, -1.0f
275 INSTANTIATE_TEST_CASE_P(
276 Scenarios, AudioPowerMonitorTest,
278 TestScenario(kMonoSilentNoise, 1, 2, -40, false),
279 TestScenario(kMonoMaxAmplitude, 1, 1,
280 AudioPowerMonitor::max_power(), false),
281 TestScenario(kMonoMaxAmplitude2, 1, 2,
282 AudioPowerMonitor::max_power(), false),
283 TestScenario(kMonoHalfMaxAmplitude, 1, 4, -6, false),
284 TestScenario(kMonoAmplitudeClipped, 1, 2,
285 AudioPowerMonitor::max_power(), true),
286 TestScenario(kMonoMaxAmplitudeWithClip, 1, 4,
287 AudioPowerMonitor::max_power(), true),
288 TestScenario(kMonoMaxAmplitudeWithClip2, 1, 4,
289 AudioPowerMonitor::max_power(), true),
290 TestScenario(kMonoSilentNoise, 1, 2,
291 AudioPowerMonitor::zero_power(), false).
292 WithABadSample(std::numeric_limits<float>::infinity()),
293 TestScenario(kMonoHalfMaxAmplitude, 1, 4,
294 AudioPowerMonitor::zero_power(), false).
295 WithABadSample(std::numeric_limits<float>::quiet_NaN()),
296 TestScenario(kStereoSilentNoise, 2, 2, -46, false),
297 TestScenario(kStereoMaxAmplitude, 2, 2,
298 AudioPowerMonitor::max_power(), false),
299 TestScenario(kRightChannelMaxAmplitude, 2, 4, -3, false),
300 TestScenario(kLeftChannelHalfMaxAmplitude, 2, 4, -9, false),
301 TestScenario(kStereoMixed, 2, 4, -2, false),
302 TestScenario(kStereoMixed2, 2, 8, -3, false)));