1 // Copyright 2014 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 <stdint.h> 6 7 #include "base/big_endian.h" 8 #include "base/test/simple_test_tick_clock.h" 9 #include "media/cast/logging/logging_impl.h" 10 #include "media/cast/logging/simple_event_subscriber.h" 11 #include "media/cast/net/pacing/paced_sender.h" 12 #include "media/cast/test/fake_single_thread_task_runner.h" 13 #include "testing/gmock/include/gmock/gmock.h" 14 15 using testing::_; 16 17 namespace media { 18 namespace cast { 19 namespace { 20 21 static const uint8 kValue = 123; 22 static const size_t kSize1 = 101; 23 static const size_t kSize2 = 102; 24 static const size_t kSize3 = 103; 25 static const size_t kSize4 = 104; 26 static const size_t kNackSize = 105; 27 static const int64 kStartMillisecond = INT64_C(12345678900000); 28 static const uint32 kVideoSsrc = 0x1234; 29 static const uint32 kAudioSsrc = 0x5678; 30 31 class TestPacketSender : public PacketSender { 32 public: 33 TestPacketSender() : bytes_sent_(0) {} 34 35 virtual bool SendPacket(PacketRef packet, const base::Closure& cb) OVERRIDE { 36 EXPECT_FALSE(expected_packet_size_.empty()); 37 size_t expected_packet_size = expected_packet_size_.front(); 38 expected_packet_size_.pop_front(); 39 EXPECT_EQ(expected_packet_size, packet->data.size()); 40 bytes_sent_ += packet->data.size(); 41 return true; 42 } 43 44 virtual int64 GetBytesSent() OVERRIDE { 45 return bytes_sent_; 46 } 47 48 void AddExpectedSize(int expected_packet_size, int repeat_count) { 49 for (int i = 0; i < repeat_count; ++i) { 50 expected_packet_size_.push_back(expected_packet_size); 51 } 52 } 53 54 public: 55 std::list<int> expected_packet_size_; 56 int64 bytes_sent_; 57 58 DISALLOW_COPY_AND_ASSIGN(TestPacketSender); 59 }; 60 61 class PacedSenderTest : public ::testing::Test { 62 protected: 63 PacedSenderTest() { 64 logging_.AddRawEventSubscriber(&subscriber_); 65 testing_clock_.Advance( 66 base::TimeDelta::FromMilliseconds(kStartMillisecond)); 67 task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_); 68 paced_sender_.reset(new PacedSender(kTargetBurstSize, 69 kMaxBurstSize, 70 &testing_clock_, 71 &logging_, 72 &mock_transport_, 73 task_runner_)); 74 paced_sender_->RegisterAudioSsrc(kAudioSsrc); 75 paced_sender_->RegisterVideoSsrc(kVideoSsrc); 76 } 77 78 virtual ~PacedSenderTest() { 79 logging_.RemoveRawEventSubscriber(&subscriber_); 80 } 81 82 static void UpdateCastTransportStatus(CastTransportStatus status) { 83 NOTREACHED(); 84 } 85 86 SendPacketVector CreateSendPacketVector(size_t packet_size, 87 int num_of_packets_in_frame, 88 bool audio) { 89 DCHECK_GE(packet_size, 12u); 90 SendPacketVector packets; 91 base::TimeTicks frame_tick = testing_clock_.NowTicks(); 92 // Advance the clock so that we don't get the same frame_tick 93 // next time this function is called. 94 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(1)); 95 for (int i = 0; i < num_of_packets_in_frame; ++i) { 96 PacketKey key = PacedPacketSender::MakePacketKey( 97 frame_tick, 98 audio ? kAudioSsrc : kVideoSsrc, // ssrc 99 i); 100 101 PacketRef packet(new base::RefCountedData<Packet>); 102 packet->data.resize(packet_size, kValue); 103 // Write ssrc to packet so that it can be recognized as a 104 // "video frame" for logging purposes. 105 base::BigEndianWriter writer( 106 reinterpret_cast<char*>(&packet->data[8]), 4); 107 bool success = writer.WriteU32(audio ? kAudioSsrc : kVideoSsrc); 108 DCHECK(success); 109 packets.push_back(std::make_pair(key, packet)); 110 } 111 return packets; 112 } 113 114 // Use this function to drain the packet list in PacedSender without having 115 // to test the pacing implementation details. 116 bool RunUntilEmpty(int max_tries) { 117 for (int i = 0; i < max_tries; i++) { 118 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); 119 task_runner_->RunTasks(); 120 if (mock_transport_.expected_packet_size_.empty()) 121 return true; 122 i++; 123 } 124 125 return mock_transport_.expected_packet_size_.empty(); 126 } 127 128 LoggingImpl logging_; 129 SimpleEventSubscriber subscriber_; 130 base::SimpleTestTickClock testing_clock_; 131 TestPacketSender mock_transport_; 132 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 133 scoped_ptr<PacedSender> paced_sender_; 134 135 DISALLOW_COPY_AND_ASSIGN(PacedSenderTest); 136 }; 137 138 } // namespace 139 140 TEST_F(PacedSenderTest, PassThroughRtcp) { 141 mock_transport_.AddExpectedSize(kSize1, 2); 142 SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true); 143 144 EXPECT_TRUE(paced_sender_->SendPackets(packets)); 145 EXPECT_TRUE(paced_sender_->ResendPackets(packets, DedupInfo())); 146 147 mock_transport_.AddExpectedSize(kSize2, 1); 148 Packet tmp(kSize2, kValue); 149 EXPECT_TRUE(paced_sender_->SendRtcpPacket( 150 1, 151 new base::RefCountedData<Packet>(tmp))); 152 } 153 154 TEST_F(PacedSenderTest, BasicPace) { 155 int num_of_packets = 27; 156 SendPacketVector packets = CreateSendPacketVector(kSize1, 157 num_of_packets, 158 false); 159 160 mock_transport_.AddExpectedSize(kSize1, 10); 161 EXPECT_TRUE(paced_sender_->SendPackets(packets)); 162 163 // Check that we get the next burst. 164 mock_transport_.AddExpectedSize(kSize1, 10); 165 166 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); 167 testing_clock_.Advance(timeout); 168 task_runner_->RunTasks(); 169 170 // If we call process too early make sure we don't send any packets. 171 timeout = base::TimeDelta::FromMilliseconds(5); 172 testing_clock_.Advance(timeout); 173 task_runner_->RunTasks(); 174 175 // Check that we get the next burst. 176 mock_transport_.AddExpectedSize(kSize1, 7); 177 testing_clock_.Advance(timeout); 178 task_runner_->RunTasks(); 179 180 // Check that we don't get any more packets. 181 EXPECT_TRUE(RunUntilEmpty(3)); 182 183 std::vector<PacketEvent> packet_events; 184 subscriber_.GetPacketEventsAndReset(&packet_events); 185 EXPECT_EQ(num_of_packets, static_cast<int>(packet_events.size())); 186 int sent_to_network_event_count = 0; 187 for (std::vector<PacketEvent>::iterator it = packet_events.begin(); 188 it != packet_events.end(); 189 ++it) { 190 if (it->type == PACKET_SENT_TO_NETWORK) 191 sent_to_network_event_count++; 192 else 193 FAIL() << "Got unexpected event type " << CastLoggingToString(it->type); 194 } 195 EXPECT_EQ(num_of_packets, sent_to_network_event_count); 196 } 197 198 TEST_F(PacedSenderTest, PaceWithNack) { 199 // Testing what happen when we get multiple NACK requests for a fully lost 200 // frames just as we sent the first packets in a frame. 201 int num_of_packets_in_frame = 12; 202 int num_of_packets_in_nack = 12; 203 204 SendPacketVector nack_packets = 205 CreateSendPacketVector(kNackSize, num_of_packets_in_nack, false); 206 207 SendPacketVector first_frame_packets = 208 CreateSendPacketVector(kSize1, num_of_packets_in_frame, false); 209 210 SendPacketVector second_frame_packets = 211 CreateSendPacketVector(kSize2, num_of_packets_in_frame, true); 212 213 // Check that the first burst of the frame go out on the wire. 214 mock_transport_.AddExpectedSize(kSize1, 10); 215 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets)); 216 217 // Add first NACK request. 218 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets, DedupInfo())); 219 220 // Check that we get the first NACK burst. 221 mock_transport_.AddExpectedSize(kNackSize, 10); 222 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); 223 testing_clock_.Advance(timeout); 224 task_runner_->RunTasks(); 225 226 // Add second NACK request. 227 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets, DedupInfo())); 228 229 // Check that we get the next NACK burst. 230 mock_transport_.AddExpectedSize(kNackSize, 10); 231 testing_clock_.Advance(timeout); 232 task_runner_->RunTasks(); 233 234 // End of NACK plus two packets from the oldest frame. 235 // Note that two of the NACKs have been de-duped. 236 mock_transport_.AddExpectedSize(kNackSize, 2); 237 mock_transport_.AddExpectedSize(kSize1, 2); 238 testing_clock_.Advance(timeout); 239 task_runner_->RunTasks(); 240 241 // Add second frame. 242 // Make sure we don't delay the second frame due to the previous packets. 243 mock_transport_.AddExpectedSize(kSize2, 10); 244 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets)); 245 246 // Last packets of frame 2. 247 mock_transport_.AddExpectedSize(kSize2, 2); 248 testing_clock_.Advance(timeout); 249 task_runner_->RunTasks(); 250 251 // No more packets. 252 EXPECT_TRUE(RunUntilEmpty(5)); 253 254 std::vector<PacketEvent> packet_events; 255 subscriber_.GetPacketEventsAndReset(&packet_events); 256 int expected_video_network_event_count = num_of_packets_in_frame; 257 int expected_video_retransmitted_event_count = 2 * num_of_packets_in_nack; 258 expected_video_retransmitted_event_count -= 2; // 2 packets deduped 259 int expected_audio_network_event_count = num_of_packets_in_frame; 260 EXPECT_EQ(expected_video_network_event_count + 261 expected_video_retransmitted_event_count + 262 expected_audio_network_event_count, 263 static_cast<int>(packet_events.size())); 264 int audio_network_event_count = 0; 265 int video_network_event_count = 0; 266 int video_retransmitted_event_count = 0; 267 for (std::vector<PacketEvent>::iterator it = packet_events.begin(); 268 it != packet_events.end(); 269 ++it) { 270 if (it->type == PACKET_SENT_TO_NETWORK) { 271 if (it->media_type == VIDEO_EVENT) 272 video_network_event_count++; 273 else 274 audio_network_event_count++; 275 } else if (it->type == PACKET_RETRANSMITTED) { 276 if (it->media_type == VIDEO_EVENT) 277 video_retransmitted_event_count++; 278 } else { 279 FAIL() << "Got unexpected event type " << CastLoggingToString(it->type); 280 } 281 } 282 EXPECT_EQ(expected_audio_network_event_count, audio_network_event_count); 283 EXPECT_EQ(expected_video_network_event_count, video_network_event_count); 284 EXPECT_EQ(expected_video_retransmitted_event_count, 285 video_retransmitted_event_count); 286 } 287 288 TEST_F(PacedSenderTest, PaceWith60fps) { 289 // Testing what happen when we get multiple NACK requests for a fully lost 290 // frames just as we sent the first packets in a frame. 291 int num_of_packets_in_frame = 17; 292 293 SendPacketVector first_frame_packets = 294 CreateSendPacketVector(kSize1, num_of_packets_in_frame, false); 295 296 SendPacketVector second_frame_packets = 297 CreateSendPacketVector(kSize2, num_of_packets_in_frame, false); 298 299 SendPacketVector third_frame_packets = 300 CreateSendPacketVector(kSize3, num_of_packets_in_frame, false); 301 302 SendPacketVector fourth_frame_packets = 303 CreateSendPacketVector(kSize4, num_of_packets_in_frame, false); 304 305 base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10); 306 307 // Check that the first burst of the frame go out on the wire. 308 mock_transport_.AddExpectedSize(kSize1, 10); 309 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets)); 310 311 mock_transport_.AddExpectedSize(kSize1, 7); 312 testing_clock_.Advance(timeout_10ms); 313 task_runner_->RunTasks(); 314 315 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6)); 316 317 // Add second frame, after 16 ms. 318 mock_transport_.AddExpectedSize(kSize2, 3); 319 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets)); 320 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4)); 321 322 mock_transport_.AddExpectedSize(kSize2, 10); 323 testing_clock_.Advance(timeout_10ms); 324 task_runner_->RunTasks(); 325 326 mock_transport_.AddExpectedSize(kSize2, 4); 327 testing_clock_.Advance(timeout_10ms); 328 task_runner_->RunTasks(); 329 330 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3)); 331 332 // Add third frame, after 33 ms. 333 mock_transport_.AddExpectedSize(kSize3, 6); 334 EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets)); 335 336 mock_transport_.AddExpectedSize(kSize3, 10); 337 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7)); 338 task_runner_->RunTasks(); 339 340 // Add fourth frame, after 50 ms. 341 EXPECT_TRUE(paced_sender_->SendPackets(fourth_frame_packets)); 342 343 mock_transport_.AddExpectedSize(kSize3, 1); 344 mock_transport_.AddExpectedSize(kSize4, 9); 345 testing_clock_.Advance(timeout_10ms); 346 task_runner_->RunTasks(); 347 348 mock_transport_.AddExpectedSize(kSize4, 8); 349 testing_clock_.Advance(timeout_10ms); 350 task_runner_->RunTasks(); 351 352 testing_clock_.Advance(timeout_10ms); 353 task_runner_->RunTasks(); 354 355 testing_clock_.Advance(timeout_10ms); 356 task_runner_->RunTasks(); 357 358 // No more packets. 359 EXPECT_TRUE(RunUntilEmpty(5)); 360 } 361 362 TEST_F(PacedSenderTest, SendPriority) { 363 // Actual order to the network is: 364 // 1. Video packets x 10. 365 // 2. RTCP packet x 1. 366 // 3. Audio packet x 1. 367 // 4. Video retransmission packet x 10. 368 // 5. Video packet x 10. 369 mock_transport_.AddExpectedSize(kSize2, 10); // Normal video packets. 370 mock_transport_.AddExpectedSize(kSize3, 1); // RTCP packet. 371 mock_transport_.AddExpectedSize(kSize1, 1); // Audio packet. 372 mock_transport_.AddExpectedSize(kSize4, 10); // Resend video packets. 373 mock_transport_.AddExpectedSize(kSize2, 10); // Normal video packets. 374 375 paced_sender_->RegisterPrioritySsrc(kAudioSsrc); 376 377 // Retransmission packets with the earlier timestamp. 378 SendPacketVector resend_packets = 379 CreateSendPacketVector(kSize4, 10, false); 380 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); 381 382 // Send 20 normal video packets. Only 10 will be sent in this 383 // call, the rest will be sitting in the queue waiting for pacing. 384 EXPECT_TRUE(paced_sender_->SendPackets( 385 CreateSendPacketVector(kSize2, 20, false))); 386 387 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); 388 389 // Send normal audio packet. This is queued and will be sent 390 // earlier than video packets. 391 EXPECT_TRUE(paced_sender_->SendPackets( 392 CreateSendPacketVector(kSize1, 1, true))); 393 394 // Send RTCP packet. This is queued and will be sent first. 395 EXPECT_TRUE(paced_sender_->SendRtcpPacket( 396 kVideoSsrc, 397 new base::RefCountedData<Packet>(Packet(kSize3, kValue)))); 398 399 // Resend video packets. This is queued and will be sent 400 // earlier than normal video packets. 401 EXPECT_TRUE(paced_sender_->ResendPackets(resend_packets, DedupInfo())); 402 403 // Roll the clock. Queued packets will be sent in this order: 404 // 1. RTCP packet x 1. 405 // 2. Audio packet x 1. 406 // 3. Video retransmission packet x 10. 407 // 4. Video packet x 10. 408 task_runner_->RunTasks(); 409 EXPECT_TRUE(RunUntilEmpty(4)); 410 } 411 412 TEST_F(PacedSenderTest, GetLastByteSent) { 413 mock_transport_.AddExpectedSize(kSize1, 4); 414 415 SendPacketVector packets1 = CreateSendPacketVector(kSize1, 1, true); 416 SendPacketVector packets2 = CreateSendPacketVector(kSize1, 1, false); 417 418 EXPECT_TRUE(paced_sender_->SendPackets(packets1)); 419 EXPECT_EQ(static_cast<int64>(kSize1), 420 paced_sender_->GetLastByteSentForPacket(packets1[0].first)); 421 EXPECT_EQ(static_cast<int64>(kSize1), 422 paced_sender_->GetLastByteSentForSsrc(kAudioSsrc)); 423 EXPECT_EQ(0, paced_sender_->GetLastByteSentForSsrc(kVideoSsrc)); 424 425 EXPECT_TRUE(paced_sender_->SendPackets(packets2)); 426 EXPECT_EQ(static_cast<int64>(2 * kSize1), 427 paced_sender_->GetLastByteSentForPacket(packets2[0].first)); 428 EXPECT_EQ(static_cast<int64>(kSize1), 429 paced_sender_->GetLastByteSentForSsrc(kAudioSsrc)); 430 EXPECT_EQ(static_cast<int64>(2 * kSize1), 431 paced_sender_->GetLastByteSentForSsrc(kVideoSsrc)); 432 433 EXPECT_TRUE(paced_sender_->ResendPackets(packets1, DedupInfo())); 434 EXPECT_EQ(static_cast<int64>(3 * kSize1), 435 paced_sender_->GetLastByteSentForPacket(packets1[0].first)); 436 EXPECT_EQ(static_cast<int64>(3 * kSize1), 437 paced_sender_->GetLastByteSentForSsrc(kAudioSsrc)); 438 EXPECT_EQ(static_cast<int64>(2 * kSize1), 439 paced_sender_->GetLastByteSentForSsrc(kVideoSsrc)); 440 441 EXPECT_TRUE(paced_sender_->ResendPackets(packets2, DedupInfo())); 442 EXPECT_EQ(static_cast<int64>(4 * kSize1), 443 paced_sender_->GetLastByteSentForPacket(packets2[0].first)); 444 EXPECT_EQ(static_cast<int64>(3 * kSize1), 445 paced_sender_->GetLastByteSentForSsrc(kAudioSsrc)); 446 EXPECT_EQ(static_cast<int64>(4 * kSize1), 447 paced_sender_->GetLastByteSentForSsrc(kVideoSsrc)); 448 } 449 450 TEST_F(PacedSenderTest, DedupWithResendInterval) { 451 mock_transport_.AddExpectedSize(kSize1, 2); 452 453 SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true); 454 EXPECT_TRUE(paced_sender_->SendPackets(packets)); 455 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10)); 456 457 DedupInfo dedup_info; 458 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(20); 459 460 // This packet will not be sent. 461 EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info)); 462 EXPECT_EQ(static_cast<int64>(kSize1), mock_transport_.GetBytesSent()); 463 464 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5); 465 EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info)); 466 EXPECT_EQ(static_cast<int64>(2 * kSize1), mock_transport_.GetBytesSent()); 467 } 468 469 } // namespace cast 470 } // namespace media 471
