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. 4 5 #include "media/audio/audio_power_monitor.h" 6 7 #include <limits> 8 9 #include "base/time/time.h" 10 #include "media/base/audio_bus.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 namespace media { 14 15 static const int kSampleRate = 48000; 16 static const int kFramesPerBuffer = 128; 17 18 static const int kTimeConstantMillis = 5; 19 20 namespace { 21 22 // Container for each parameterized test's data (input and expected results). 23 class TestScenario { 24 public: 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); 29 } 30 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()); 38 return *this; 39 } 40 41 // Returns this TestScenario, but with a bad sample value placed in the middle 42 // of channel 0. 43 TestScenario WithABadSample(float bad_value) const { 44 TestScenario result(*this); 45 result.bus_->channel(0)[result.bus_->frames() / 2] = bad_value; 46 return result; 47 } 48 49 const AudioBus& data() const { 50 return *bus_; 51 } 52 53 float expected_power() const { 54 return expected_power_; 55 } 56 57 bool expected_clipped() const { 58 return expected_clipped_; 59 } 60 61 private: 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); 72 } 73 } 74 } 75 76 float expected_power_; 77 bool expected_clipped_; 78 scoped_ptr<AudioBus> bus_; 79 }; 80 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") 87 << "}"; 88 } 89 90 // An observer that receives power measurements. Each power measurement should 91 // should make progress towards the goal value. 92 class MeasurementObserver { 93 public: 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) {} 99 100 int measurement_count() const { 101 return measurement_count_; 102 } 103 104 float last_power_measurement() const { 105 return last_power_measurement_; 106 } 107 108 bool last_clipped() const { 109 return last_clipped_; 110 } 111 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_); 116 } else { 117 SCOPED_TRACE(::testing::Message() 118 << "Power: goal=" << goal_power_measurement_ 119 << "; last=" << last_power_measurement_ 120 << "; cur=" << cur_power_measurement); 121 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."; 126 } else { 127 EXPECT_GE(last_power_measurement_, cur_power_measurement) 128 << "Measurements should be monotonically decreasing."; 129 } 130 } else { 131 EXPECT_EQ(last_power_measurement_, cur_power_measurement) 132 << "Measurements are numerically unstable at goal value."; 133 } 134 } 135 136 last_power_measurement_ = cur_power_measurement; 137 last_clipped_ = clipped; 138 ++measurement_count_; 139 } 140 141 private: 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_; 147 bool last_clipped_; 148 149 DISALLOW_COPY_AND_ASSIGN(MeasurementObserver); 150 }; 151 152 } // namespace 153 154 class AudioPowerMonitorTest : public ::testing::TestWithParam<TestScenario> { 155 public: 156 AudioPowerMonitorTest() 157 : power_monitor_(kSampleRate, 158 base::TimeDelta::FromMilliseconds(kTimeConstantMillis)) { 159 } 160 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); 172 } 173 174 // Check that the results recorded by the observer are the same whole-number 175 // dBFS. 176 EXPECT_EQ(static_cast<int>(power), 177 static_cast<int>(observer.last_power_measurement())); 178 EXPECT_EQ(clipped, observer.last_clipped()); 179 } 180 181 private: 182 AudioPowerMonitor power_monitor_; 183 184 DISALLOW_COPY_AND_ASSIGN(AudioPowerMonitorTest); 185 }; 186 187 TEST_P(AudioPowerMonitorTest, MeasuresPowerOfSignal) { 188 const TestScenario& scenario = GetParam(); 189 190 scoped_ptr<AudioBus> zeroed_bus = 191 AudioBus::Create(scenario.data().channels(), scenario.data().frames()); 192 zeroed_bus->Zero(); 193 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); 203 } 204 205 static const float kMonoSilentNoise[] = { 206 0.01f, -0.01f 207 }; 208 209 static const float kMonoMaxAmplitude[] = { 210 1.0f 211 }; 212 213 static const float kMonoMaxAmplitude2[] = { 214 -1.0f, 1.0f 215 }; 216 217 static const float kMonoHalfMaxAmplitude[] = { 218 0.5f, -0.5f, 0.5f, -0.5f 219 }; 220 221 static const float kMonoAmplitudeClipped[] = { 222 2.0f, -2.0f 223 }; 224 225 static const float kMonoMaxAmplitudeWithClip[] = { 226 2.0f, 0.0, 0.0f, 0.0f 227 }; 228 229 static const float kMonoMaxAmplitudeWithClip2[] = { 230 4.0f, 0.0, 0.0f, 0.0f 231 }; 232 233 static const float kStereoSilentNoise[] = { 234 // left channel 235 0.005f, -0.005f, 236 // right channel 237 0.005f, -0.005f 238 }; 239 240 static const float kStereoMaxAmplitude[] = { 241 // left channel 242 1.0f, -1.0f, 243 // right channel 244 -1.0f, 1.0f 245 }; 246 247 static const float kRightChannelMaxAmplitude[] = { 248 // left channel 249 0.0f, 0.0f, 0.0f, 0.0f, 250 // right channel 251 -1.0f, 1.0f, -1.0f, 1.0f 252 }; 253 254 static const float kLeftChannelHalfMaxAmplitude[] = { 255 // left channel 256 0.5f, -0.5f, 0.5f, -0.5f, 257 // right channel 258 0.0f, 0.0f, 0.0f, 0.0f, 259 }; 260 261 static const float kStereoMixed[] = { 262 // left channel 263 0.5f, -0.5f, 0.5f, -0.5f, 264 // right channel 265 -1.0f, 1.0f, -1.0f, 1.0f 266 }; 267 268 static const float kStereoMixed2[] = { 269 // left channel 270 1.0f, -1.0f, 0.75f, -0.75f, 0.5f, -0.5f, 0.25f, -0.25f, 271 // right channel 272 0.25f, -0.25f, 0.5f, -0.5f, 0.75f, -0.75f, 1.0f, -1.0f 273 }; 274 275 INSTANTIATE_TEST_CASE_P( 276 Scenarios, AudioPowerMonitorTest, 277 ::testing::Values( 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))); 303 304 } // namespace media 305
