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 #include "remoting/client/audio_player.h" 6 7 #include "base/compiler_specific.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "testing/gtest/include/gtest/gtest.h" 10 11 namespace { 12 13 const int kAudioSamplesPerFrame = 25; 14 const int kAudioSampleBytes = 4; 15 const int kAudioFrameBytes = kAudioSamplesPerFrame * kAudioSampleBytes; 16 const int kPaddingBytes = 16; 17 18 // TODO(garykac): Generate random audio data in the tests rather than having 19 // a single constant value. 20 const uint8 kDefaultBufferData = 0x5A; 21 const uint8 kDummyAudioData = 0x8B; 22 23 } // namespace 24 25 namespace remoting { 26 27 class FakeAudioPlayer : public AudioPlayer { 28 public: 29 FakeAudioPlayer() { 30 } 31 32 virtual bool ResetAudioPlayer(AudioPacket::SamplingRate) OVERRIDE { 33 return true; 34 } 35 36 virtual uint32 GetSamplesPerFrame() OVERRIDE { 37 return kAudioSamplesPerFrame; 38 } 39 }; 40 41 class AudioPlayerTest : public ::testing::Test { 42 protected: 43 virtual void SetUp() { 44 audio_.reset(new FakeAudioPlayer()); 45 buffer_.reset(new char[kAudioFrameBytes + kPaddingBytes]); 46 } 47 48 virtual void TearDown() { 49 } 50 51 void ConsumeAudioFrame() { 52 uint8* buffer = reinterpret_cast<uint8*>(buffer_.get()); 53 memset(buffer, kDefaultBufferData, kAudioFrameBytes + kPaddingBytes); 54 AudioPlayer::AudioPlayerCallback(reinterpret_cast<void*>(buffer_.get()), 55 kAudioFrameBytes, 56 reinterpret_cast<void*>(audio_.get())); 57 // Verify we haven't written beyond the end of the buffer. 58 for (int i = 0; i < kPaddingBytes; i++) 59 ASSERT_EQ(kDefaultBufferData, *(buffer + kAudioFrameBytes + i)); 60 } 61 62 // Check that the first |num_bytes| bytes are filled with audio data and 63 // the rest of the buffer is zero-filled. 64 void CheckAudioFrameBytes(int num_bytes) { 65 uint8* buffer = reinterpret_cast<uint8*>(buffer_.get()); 66 int i = 0; 67 for (; i < num_bytes; i++) { 68 ASSERT_EQ(kDummyAudioData, *(buffer + i)); 69 } 70 // Rest of audio frame must be filled with '0's. 71 for (; i < kAudioFrameBytes; i++) { 72 ASSERT_EQ(0, *(buffer + i)); 73 } 74 } 75 76 int GetNumQueuedSamples() { 77 return audio_->queued_bytes_ / kAudioSampleBytes; 78 } 79 80 int GetNumQueuedPackets() { 81 return static_cast<int>(audio_->queued_packets_.size()); 82 } 83 84 int GetBytesConsumed() { 85 return static_cast<int>(audio_->bytes_consumed_); 86 } 87 88 scoped_ptr<AudioPlayer> audio_; 89 scoped_ptr<char[]> buffer_; 90 }; 91 92 scoped_ptr<AudioPacket> CreatePacketWithSamplingRate( 93 AudioPacket::SamplingRate rate, int samples) { 94 scoped_ptr<AudioPacket> packet(new AudioPacket()); 95 packet->set_encoding(AudioPacket::ENCODING_RAW); 96 packet->set_sampling_rate(rate); 97 packet->set_bytes_per_sample(AudioPacket::BYTES_PER_SAMPLE_2); 98 packet->set_channels(AudioPacket::CHANNELS_STEREO); 99 100 // The data must be a multiple of 4 bytes (channels x bytes_per_sample). 101 std::string data; 102 data.resize(samples * kAudioSampleBytes, kDummyAudioData); 103 packet->add_data(data); 104 105 return packet.Pass(); 106 } 107 108 scoped_ptr<AudioPacket> CreatePacket44100Hz(int samples) { 109 return CreatePacketWithSamplingRate(AudioPacket::SAMPLING_RATE_44100, 110 samples); 111 } 112 113 scoped_ptr<AudioPacket> CreatePacket48000Hz(int samples) { 114 return CreatePacketWithSamplingRate(AudioPacket::SAMPLING_RATE_48000, 115 samples); 116 } 117 118 TEST_F(AudioPlayerTest, Init) { 119 ASSERT_EQ(0, GetNumQueuedPackets()); 120 121 scoped_ptr<AudioPacket> packet(CreatePacket44100Hz(10)); 122 audio_->ProcessAudioPacket(packet.Pass()); 123 ASSERT_EQ(1, GetNumQueuedPackets()); 124 } 125 126 TEST_F(AudioPlayerTest, MultipleSamples) { 127 scoped_ptr<AudioPacket> packet1(CreatePacket44100Hz(10)); 128 audio_->ProcessAudioPacket(packet1.Pass()); 129 ASSERT_EQ(10, GetNumQueuedSamples()); 130 ASSERT_EQ(1, GetNumQueuedPackets()); 131 132 scoped_ptr<AudioPacket> packet2(CreatePacket44100Hz(20)); 133 audio_->ProcessAudioPacket(packet2.Pass()); 134 ASSERT_EQ(30, GetNumQueuedSamples()); 135 ASSERT_EQ(2, GetNumQueuedPackets()); 136 } 137 138 TEST_F(AudioPlayerTest, ChangeSampleRate) { 139 scoped_ptr<AudioPacket> packet1(CreatePacket44100Hz(10)); 140 audio_->ProcessAudioPacket(packet1.Pass()); 141 ASSERT_EQ(10, GetNumQueuedSamples()); 142 ASSERT_EQ(1, GetNumQueuedPackets()); 143 144 // New packet with different sampling rate causes previous samples to 145 // be removed. 146 scoped_ptr<AudioPacket> packet2(CreatePacket48000Hz(20)); 147 audio_->ProcessAudioPacket(packet2.Pass()); 148 ASSERT_EQ(20, GetNumQueuedSamples()); 149 ASSERT_EQ(1, GetNumQueuedPackets()); 150 } 151 152 TEST_F(AudioPlayerTest, ExceedLatency) { 153 // Push about 4 seconds worth of samples. 154 for (int i = 0; i < 100; ++i) { 155 scoped_ptr<AudioPacket> packet1(CreatePacket48000Hz(2000)); 156 audio_->ProcessAudioPacket(packet1.Pass()); 157 } 158 159 // Verify that we don't have more than 0.5s. 160 EXPECT_LT(GetNumQueuedSamples(), 24000); 161 } 162 163 // Incoming packets: 100 164 // Consume: 25 (w/ 75 remaining, offset 25 into packet) 165 TEST_F(AudioPlayerTest, ConsumePartialPacket) { 166 int total_samples = 0; 167 int bytes_consumed = 0; 168 169 // Process 100 samples. 170 int packet1_samples = 100; 171 scoped_ptr<AudioPacket> packet(CreatePacket44100Hz(packet1_samples)); 172 total_samples += packet1_samples; 173 audio_->ProcessAudioPacket(packet.Pass()); 174 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 175 ASSERT_EQ(1, GetNumQueuedPackets()); 176 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 177 178 // Consume one frame (=25) of samples. 179 ConsumeAudioFrame(); 180 total_samples -= kAudioSamplesPerFrame; 181 bytes_consumed += kAudioFrameBytes; 182 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 183 ASSERT_EQ(1, GetNumQueuedPackets()); 184 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 185 CheckAudioFrameBytes(kAudioFrameBytes); 186 187 // Remaining samples. 188 ASSERT_EQ(75, total_samples); 189 ASSERT_EQ(25 * kAudioSampleBytes, bytes_consumed); 190 } 191 192 // Incoming packets: 20, 70 193 // Consume: 25, 25 (w/ 40 remaining, offset 30 into packet) 194 TEST_F(AudioPlayerTest, ConsumeAcrossPackets) { 195 int total_samples = 0; 196 int bytes_consumed = 0; 197 198 // Packet 1. 199 int packet1_samples = 20; 200 scoped_ptr<AudioPacket> packet1(CreatePacket44100Hz(packet1_samples)); 201 total_samples += packet1_samples; 202 audio_->ProcessAudioPacket(packet1.Pass()); 203 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 204 205 // Packet 2. 206 int packet2_samples = 70; 207 scoped_ptr<AudioPacket> packet2(CreatePacket44100Hz(packet2_samples)); 208 total_samples += packet2_samples; 209 audio_->ProcessAudioPacket(packet2.Pass()); 210 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 211 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 212 213 // Consume 1st frame of 25 samples. 214 // This will consume the entire 1st packet. 215 ConsumeAudioFrame(); 216 total_samples -= kAudioSamplesPerFrame; 217 bytes_consumed += kAudioFrameBytes - (packet1_samples * kAudioSampleBytes); 218 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 219 ASSERT_EQ(1, GetNumQueuedPackets()); 220 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 221 CheckAudioFrameBytes(kAudioFrameBytes); 222 223 // Consume 2nd frame of 25 samples. 224 ConsumeAudioFrame(); 225 total_samples -= kAudioSamplesPerFrame; 226 bytes_consumed += kAudioFrameBytes; 227 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 228 ASSERT_EQ(1, GetNumQueuedPackets()); 229 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 230 CheckAudioFrameBytes(kAudioFrameBytes); 231 232 // Remaining samples. 233 ASSERT_EQ(40, total_samples); 234 ASSERT_EQ(30 * kAudioSampleBytes, bytes_consumed); 235 } 236 237 // Incoming packets: 50, 30 238 // Consume: 25, 25, 25 (w/ 5 remaining, offset 25 into packet) 239 TEST_F(AudioPlayerTest, ConsumeEntirePacket) { 240 int total_samples = 0; 241 int bytes_consumed = 0; 242 243 // Packet 1. 244 int packet1_samples = 50; 245 scoped_ptr<AudioPacket> packet1(CreatePacket44100Hz(packet1_samples)); 246 total_samples += packet1_samples; 247 audio_->ProcessAudioPacket(packet1.Pass()); 248 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 249 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 250 251 // Packet 2. 252 int packet2_samples = 30; 253 scoped_ptr<AudioPacket> packet2(CreatePacket44100Hz(packet2_samples)); 254 total_samples += packet2_samples; 255 audio_->ProcessAudioPacket(packet2.Pass()); 256 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 257 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 258 259 // Consume 1st frame of 25 samples. 260 ConsumeAudioFrame(); 261 total_samples -= kAudioSamplesPerFrame; 262 bytes_consumed += kAudioFrameBytes; 263 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 264 ASSERT_EQ(2, GetNumQueuedPackets()); 265 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 266 CheckAudioFrameBytes(kAudioFrameBytes); 267 268 // Consume 2nd frame of 25 samples. 269 // This will consume the entire first packet (exactly), but the entry for 270 // this packet will stick around (empty) until the next audio chunk is 271 // consumed. 272 ConsumeAudioFrame(); 273 total_samples -= kAudioSamplesPerFrame; 274 bytes_consumed += kAudioFrameBytes; 275 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 276 ASSERT_EQ(2, GetNumQueuedPackets()); 277 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 278 CheckAudioFrameBytes(kAudioFrameBytes); 279 280 // Consume 3rd frame of 25 samples. 281 ConsumeAudioFrame(); 282 total_samples -= kAudioSamplesPerFrame; 283 bytes_consumed += kAudioFrameBytes - (packet1_samples * kAudioSampleBytes); 284 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 285 ASSERT_EQ(1, GetNumQueuedPackets()); 286 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 287 CheckAudioFrameBytes(kAudioFrameBytes); 288 289 // Remaining samples. 290 ASSERT_EQ(5, total_samples); 291 ASSERT_EQ(25 * kAudioSampleBytes, bytes_consumed); 292 } 293 294 // Incoming packets: <none> 295 // Consume: 25 296 TEST_F(AudioPlayerTest, NoDataToConsume) { 297 // Attempt to consume a frame of 25 samples. 298 ConsumeAudioFrame(); 299 ASSERT_EQ(0, GetNumQueuedSamples()); 300 ASSERT_EQ(0, GetNumQueuedPackets()); 301 ASSERT_EQ(0, GetBytesConsumed()); 302 CheckAudioFrameBytes(0); 303 } 304 305 // Incoming packets: 10 306 // Consume: 25 307 TEST_F(AudioPlayerTest, NotEnoughDataToConsume) { 308 int total_samples = 0; 309 int bytes_consumed = 0; 310 311 // Packet 1. 312 int packet1_samples = 10; 313 scoped_ptr<AudioPacket> packet1(CreatePacket44100Hz(packet1_samples)); 314 total_samples += packet1_samples; 315 audio_->ProcessAudioPacket(packet1.Pass()); 316 ASSERT_EQ(total_samples, GetNumQueuedSamples()); 317 ASSERT_EQ(bytes_consumed, GetBytesConsumed()); 318 319 // Attempt to consume a frame of 25 samples. 320 ConsumeAudioFrame(); 321 ASSERT_EQ(0, GetNumQueuedSamples()); 322 ASSERT_EQ(0, GetNumQueuedPackets()); 323 ASSERT_EQ(0, GetBytesConsumed()); 324 CheckAudioFrameBytes(packet1_samples * kAudioSampleBytes); 325 } 326 327 } // namespace remoting 328
