| OLD | NEW |
|---|
| (Empty) |
| 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 "base/memory/scoped_ptr.h" | |
| 6 #include "base/test/simple_test_tick_clock.h" | |
| 7 #include "media/cast/cast_defines.h" | |
| 8 #include "media/cast/cast_environment.h" | |
| 9 #include "media/cast/net/cast_transport_defines.h" | |
| 10 #include "media/cast/net/pacing/paced_sender.h" | |
| 11 #include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h" | |
| 12 #include "media/cast/net/rtcp/rtcp_sender.h" | |
| 13 #include "media/cast/net/rtcp/rtcp_utility.h" | |
| 14 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" | |
| 15 #include "media/cast/test/fake_single_thread_task_runner.h" | |
| 16 #include "testing/gmock/include/gmock/gmock.h" | |
| 17 | |
| 18 namespace media { | |
| 19 namespace cast { | |
| 20 | |
| 21 namespace { | |
| 22 static const uint32 kSendingSsrc = 0x12345678; | |
| 23 static const uint32 kMediaSsrc = 0x87654321; | |
| 24 static const base::TimeDelta kDefaultDelay = | |
| 25 base::TimeDelta::FromMilliseconds(100); | |
| 26 | |
| 27 RtcpReportBlock GetReportBlock() { | |
| 28 RtcpReportBlock report_block; | |
| 29 // Initialize remote_ssrc to a "clearly illegal" value. | |
| 30 report_block.remote_ssrc = 0xDEAD; | |
| 31 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. | |
| 32 report_block.fraction_lost = kLoss >> 24; | |
| 33 report_block.cumulative_lost = kLoss; // 24 bits valid. | |
| 34 report_block.extended_high_sequence_number = kExtendedMax; | |
| 35 report_block.jitter = kTestJitter; | |
| 36 report_block.last_sr = kLastSr; | |
| 37 report_block.delay_since_last_sr = kDelayLastSr; | |
| 38 return report_block; | |
| 39 } | |
| 40 | |
| 41 } // namespace | |
| 42 | |
| 43 class TestRtcpTransport : public PacedPacketSender { | |
| 44 public: | |
| 45 TestRtcpTransport() : packet_count_(0) {} | |
| 46 | |
| 47 virtual bool SendRtcpPacket(uint32 ssrc, | |
| 48 PacketRef packet) OVERRIDE { | |
| 49 EXPECT_EQ(expected_packet_.size(), packet->data.size()); | |
| 50 if (expected_packet_.size() != packet->data.size()) | |
| 51 return false; | |
| 52 EXPECT_EQ(0, memcmp(&expected_packet_[0], | |
| 53 &packet->data[0], | |
| 54 packet->data.size())); | |
| 55 packet_count_++; | |
| 56 return true; | |
| 57 } | |
| 58 | |
| 59 virtual bool SendPackets( | |
| 60 const SendPacketVector& packets) OVERRIDE { | |
| 61 return false; | |
| 62 } | |
| 63 virtual bool ResendPackets( | |
| 64 const SendPacketVector& packets, | |
| 65 const DedupInfo& dedup_info) OVERRIDE { | |
| 66 return false; | |
| 67 } | |
| 68 | |
| 69 virtual void CancelSendingPacket( | |
| 70 const PacketKey& packet_key) OVERRIDE { | |
| 71 } | |
| 72 | |
| 73 void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) { | |
| 74 expected_packet_.swap(*packet); | |
| 75 } | |
| 76 | |
| 77 int packet_count() const { return packet_count_; } | |
| 78 | |
| 79 private: | |
| 80 Packet expected_packet_; | |
| 81 int packet_count_; | |
| 82 | |
| 83 DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport); | |
| 84 }; | |
| 85 | |
| 86 class RtcpSenderTest : public ::testing::Test { | |
| 87 protected: | |
| 88 RtcpSenderTest() | |
| 89 : testing_clock_(new base::SimpleTestTickClock()), | |
| 90 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | |
| 91 cast_environment_(new CastEnvironment( | |
| 92 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
| 93 task_runner_, | |
| 94 task_runner_, | |
| 95 task_runner_)), | |
| 96 rtcp_sender_(new RtcpSender(&test_transport_, kSendingSsrc)) {} | |
| 97 | |
| 98 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | |
| 99 TestRtcpTransport test_transport_; | |
| 100 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | |
| 101 scoped_refptr<CastEnvironment> cast_environment_; | |
| 102 scoped_ptr<RtcpSender> rtcp_sender_; | |
| 103 | |
| 104 DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest); | |
| 105 }; | |
| 106 | |
| 107 TEST_F(RtcpSenderTest, RtcpReceiverReport) { | |
| 108 // Receiver report with report block. | |
| 109 TestRtcpPacketBuilder p2; | |
| 110 p2.AddRr(kSendingSsrc, 1); | |
| 111 p2.AddRb(kMediaSsrc); | |
| 112 test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass()); | |
| 113 | |
| 114 RtcpReportBlock report_block = GetReportBlock(); | |
| 115 | |
| 116 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 117 &report_block, NULL, NULL, NULL, kDefaultDelay); | |
| 118 | |
| 119 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 120 } | |
| 121 | |
| 122 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) { | |
| 123 // Receiver report with report block. | |
| 124 TestRtcpPacketBuilder p; | |
| 125 p.AddRr(kSendingSsrc, 1); | |
| 126 p.AddRb(kMediaSsrc); | |
| 127 p.AddXrHeader(kSendingSsrc); | |
| 128 p.AddXrRrtrBlock(); | |
| 129 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 130 | |
| 131 RtcpReportBlock report_block = GetReportBlock(); | |
| 132 | |
| 133 RtcpReceiverReferenceTimeReport rrtr; | |
| 134 rrtr.ntp_seconds = kNtpHigh; | |
| 135 rrtr.ntp_fraction = kNtpLow; | |
| 136 | |
| 137 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 138 &report_block, | |
| 139 &rrtr, | |
| 140 NULL, | |
| 141 NULL, | |
| 142 kDefaultDelay); | |
| 143 | |
| 144 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 145 } | |
| 146 | |
| 147 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) { | |
| 148 // Receiver report with report block. | |
| 149 TestRtcpPacketBuilder p; | |
| 150 p.AddRr(kSendingSsrc, 1); | |
| 151 p.AddRb(kMediaSsrc); | |
| 152 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); | |
| 153 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 154 | |
| 155 RtcpReportBlock report_block = GetReportBlock(); | |
| 156 | |
| 157 RtcpCastMessage cast_message(kMediaSsrc); | |
| 158 cast_message.ack_frame_id = kAckFrameId; | |
| 159 PacketIdSet missing_packets; | |
| 160 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; | |
| 161 | |
| 162 missing_packets.insert(kLostPacketId1); | |
| 163 missing_packets.insert(kLostPacketId2); | |
| 164 missing_packets.insert(kLostPacketId3); | |
| 165 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | |
| 166 missing_packets; | |
| 167 | |
| 168 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 169 &report_block, | |
| 170 NULL, | |
| 171 &cast_message, | |
| 172 NULL, | |
| 173 kDefaultDelay); | |
| 174 | |
| 175 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 176 } | |
| 177 | |
| 178 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) { | |
| 179 TestRtcpPacketBuilder p; | |
| 180 p.AddRr(kSendingSsrc, 1); | |
| 181 p.AddRb(kMediaSsrc); | |
| 182 p.AddXrHeader(kSendingSsrc); | |
| 183 p.AddXrRrtrBlock(); | |
| 184 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); | |
| 185 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 186 | |
| 187 RtcpReportBlock report_block = GetReportBlock(); | |
| 188 | |
| 189 RtcpReceiverReferenceTimeReport rrtr; | |
| 190 rrtr.ntp_seconds = kNtpHigh; | |
| 191 rrtr.ntp_fraction = kNtpLow; | |
| 192 | |
| 193 RtcpCastMessage cast_message(kMediaSsrc); | |
| 194 cast_message.ack_frame_id = kAckFrameId; | |
| 195 PacketIdSet missing_packets; | |
| 196 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; | |
| 197 | |
| 198 missing_packets.insert(kLostPacketId1); | |
| 199 missing_packets.insert(kLostPacketId2); | |
| 200 missing_packets.insert(kLostPacketId3); | |
| 201 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | |
| 202 missing_packets; | |
| 203 | |
| 204 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 205 &report_block, | |
| 206 &rrtr, | |
| 207 &cast_message, | |
| 208 NULL, | |
| 209 kDefaultDelay); | |
| 210 | |
| 211 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 212 } | |
| 213 | |
| 214 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { | |
| 215 static const uint32 kTimeBaseMs = 12345678; | |
| 216 static const uint32 kTimeDelayMs = 10; | |
| 217 | |
| 218 TestRtcpPacketBuilder p; | |
| 219 p.AddRr(kSendingSsrc, 1); | |
| 220 p.AddRb(kMediaSsrc); | |
| 221 p.AddXrHeader(kSendingSsrc); | |
| 222 p.AddXrRrtrBlock(); | |
| 223 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); | |
| 224 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 225 | |
| 226 RtcpReportBlock report_block = GetReportBlock(); | |
| 227 | |
| 228 RtcpReceiverReferenceTimeReport rrtr; | |
| 229 rrtr.ntp_seconds = kNtpHigh; | |
| 230 rrtr.ntp_fraction = kNtpLow; | |
| 231 | |
| 232 RtcpCastMessage cast_message(kMediaSsrc); | |
| 233 cast_message.ack_frame_id = kAckFrameId; | |
| 234 PacketIdSet missing_packets; | |
| 235 cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets; | |
| 236 | |
| 237 missing_packets.insert(kLostPacketId1); | |
| 238 missing_packets.insert(kLostPacketId2); | |
| 239 missing_packets.insert(kLostPacketId3); | |
| 240 cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] = | |
| 241 missing_packets; | |
| 242 | |
| 243 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | |
| 244 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; | |
| 245 | |
| 246 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 247 &report_block, | |
| 248 &rrtr, | |
| 249 &cast_message, | |
| 250 &rtcp_events, | |
| 251 kDefaultDelay); | |
| 252 | |
| 253 base::SimpleTestTickClock testing_clock; | |
| 254 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | |
| 255 | |
| 256 p.AddReceiverLog(kSendingSsrc); | |
| 257 p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs); | |
| 258 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | |
| 259 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); | |
| 260 | |
| 261 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 262 | |
| 263 FrameEvent frame_event; | |
| 264 frame_event.rtp_timestamp = kRtpTimestamp; | |
| 265 frame_event.type = FRAME_ACK_SENT; | |
| 266 frame_event.media_type = VIDEO_EVENT; | |
| 267 frame_event.timestamp = testing_clock.NowTicks(); | |
| 268 event_subscriber.OnReceiveFrameEvent(frame_event); | |
| 269 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | |
| 270 | |
| 271 PacketEvent packet_event; | |
| 272 packet_event.rtp_timestamp = kRtpTimestamp; | |
| 273 packet_event.type = PACKET_RECEIVED; | |
| 274 packet_event.media_type = VIDEO_EVENT; | |
| 275 packet_event.timestamp = testing_clock.NowTicks(); | |
| 276 packet_event.packet_id = kLostPacketId1; | |
| 277 event_subscriber.OnReceivePacketEvent(packet_event); | |
| 278 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); | |
| 279 EXPECT_EQ(2u, rtcp_events.size()); | |
| 280 | |
| 281 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 282 &report_block, | |
| 283 &rrtr, | |
| 284 &cast_message, | |
| 285 &rtcp_events, | |
| 286 kDefaultDelay); | |
| 287 | |
| 288 EXPECT_EQ(2, test_transport_.packet_count()); | |
| 289 } | |
| 290 | |
| 291 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) { | |
| 292 static const uint32 kTimeBaseMs = 12345678; | |
| 293 static const uint32 kTimeDelayMs = 10; | |
| 294 | |
| 295 TestRtcpPacketBuilder p; | |
| 296 p.AddRr(kSendingSsrc, 1); | |
| 297 p.AddRb(kMediaSsrc); | |
| 298 | |
| 299 RtcpReportBlock report_block = GetReportBlock(); | |
| 300 | |
| 301 base::SimpleTestTickClock testing_clock; | |
| 302 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | |
| 303 | |
| 304 p.AddReceiverLog(kSendingSsrc); | |
| 305 | |
| 306 int remaining_bytes = kMaxReceiverLogBytes; | |
| 307 remaining_bytes -= kRtcpCastLogHeaderSize; | |
| 308 | |
| 309 remaining_bytes -= kRtcpReceiverFrameLogSize; | |
| 310 int num_events = remaining_bytes / kRtcpReceiverEventLogSize; | |
| 311 EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages)); | |
| 312 // Only the last |num_events| events are sent due to receiver log size cap. | |
| 313 p.AddReceiverFrameLog( | |
| 314 kRtpTimestamp + 2345, | |
| 315 num_events, | |
| 316 kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs); | |
| 317 for (int i = 0; i < num_events; i++) { | |
| 318 p.AddReceiverEventLog( | |
| 319 kLostPacketId1, PACKET_RECEIVED, | |
| 320 static_cast<uint16>(kTimeDelayMs * i)); | |
| 321 } | |
| 322 | |
| 323 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 324 | |
| 325 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | |
| 326 FrameEvent frame_event; | |
| 327 frame_event.rtp_timestamp = kRtpTimestamp; | |
| 328 frame_event.type = FRAME_ACK_SENT; | |
| 329 frame_event.media_type = VIDEO_EVENT; | |
| 330 frame_event.timestamp = testing_clock.NowTicks(); | |
| 331 event_subscriber.OnReceiveFrameEvent(frame_event); | |
| 332 | |
| 333 for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { | |
| 334 PacketEvent packet_event; | |
| 335 packet_event.rtp_timestamp = kRtpTimestamp + 2345; | |
| 336 packet_event.type = PACKET_RECEIVED; | |
| 337 packet_event.media_type = VIDEO_EVENT; | |
| 338 packet_event.timestamp = testing_clock.NowTicks(); | |
| 339 packet_event.packet_id = kLostPacketId1; | |
| 340 event_subscriber.OnReceivePacketEvent(packet_event); | |
| 341 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | |
| 342 } | |
| 343 | |
| 344 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; | |
| 345 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); | |
| 346 | |
| 347 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 348 &report_block, | |
| 349 NULL, | |
| 350 NULL, | |
| 351 &rtcp_events, | |
| 352 kDefaultDelay); | |
| 353 | |
| 354 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 355 } | |
| 356 | |
| 357 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) { | |
| 358 static const uint32 kTimeBaseMs = 12345678; | |
| 359 static const uint32 kTimeDelayMs = 10; | |
| 360 | |
| 361 TestRtcpPacketBuilder p; | |
| 362 p.AddRr(kSendingSsrc, 1); | |
| 363 p.AddRb(kMediaSsrc); | |
| 364 | |
| 365 RtcpReportBlock report_block = GetReportBlock(); | |
| 366 | |
| 367 base::SimpleTestTickClock testing_clock; | |
| 368 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | |
| 369 | |
| 370 p.AddReceiverLog(kSendingSsrc); | |
| 371 | |
| 372 int remaining_bytes = kMaxReceiverLogBytes; | |
| 373 remaining_bytes -= kRtcpCastLogHeaderSize; | |
| 374 | |
| 375 int num_events = | |
| 376 remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize); | |
| 377 | |
| 378 // The last |num_events| events are sent due to receiver log size cap. | |
| 379 for (size_t i = kRtcpMaxReceiverLogMessages - num_events; | |
| 380 i < kRtcpMaxReceiverLogMessages; | |
| 381 ++i) { | |
| 382 p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs); | |
| 383 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | |
| 384 } | |
| 385 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 386 | |
| 387 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | |
| 388 | |
| 389 for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { | |
| 390 FrameEvent frame_event; | |
| 391 frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i); | |
| 392 frame_event.type = FRAME_ACK_SENT; | |
| 393 frame_event.media_type = VIDEO_EVENT; | |
| 394 frame_event.timestamp = testing_clock.NowTicks(); | |
| 395 event_subscriber.OnReceiveFrameEvent(frame_event); | |
| 396 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | |
| 397 } | |
| 398 | |
| 399 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; | |
| 400 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); | |
| 401 | |
| 402 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 403 &report_block, | |
| 404 NULL, | |
| 405 NULL, | |
| 406 &rtcp_events, | |
| 407 kDefaultDelay); | |
| 408 | |
| 409 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 410 } | |
| 411 | |
| 412 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) { | |
| 413 static const uint32 kTimeBaseMs = 12345678; | |
| 414 | |
| 415 TestRtcpPacketBuilder p; | |
| 416 p.AddRr(kSendingSsrc, 1); | |
| 417 p.AddRb(kMediaSsrc); | |
| 418 | |
| 419 RtcpReportBlock report_block = GetReportBlock(); | |
| 420 | |
| 421 base::SimpleTestTickClock testing_clock; | |
| 422 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | |
| 423 | |
| 424 p.AddReceiverLog(kSendingSsrc); | |
| 425 | |
| 426 // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart. | |
| 427 // Only last 10 events will be sent because the first event is more than | |
| 428 // 4095 milliseconds away from latest event. | |
| 429 const int kTimeBetweenEventsMs = 410; | |
| 430 p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs); | |
| 431 for (int i = 0; i < 10; ++i) { | |
| 432 p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs); | |
| 433 } | |
| 434 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 435 | |
| 436 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | |
| 437 for (int i = 0; i < 11; ++i) { | |
| 438 FrameEvent frame_event; | |
| 439 frame_event.rtp_timestamp = kRtpTimestamp; | |
| 440 frame_event.type = FRAME_ACK_SENT; | |
| 441 frame_event.media_type = VIDEO_EVENT; | |
| 442 frame_event.timestamp = testing_clock.NowTicks(); | |
| 443 event_subscriber.OnReceiveFrameEvent(frame_event); | |
| 444 testing_clock.Advance( | |
| 445 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); | |
| 446 } | |
| 447 | |
| 448 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; | |
| 449 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); | |
| 450 | |
| 451 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 452 &report_block, | |
| 453 NULL, | |
| 454 NULL, | |
| 455 &rtcp_events, | |
| 456 kDefaultDelay); | |
| 457 | |
| 458 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 459 } | |
| 460 | |
| 461 TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) { | |
| 462 uint32 time_base_ms = 12345678; | |
| 463 int kTimeBetweenEventsMs = 10; | |
| 464 | |
| 465 RtcpReportBlock report_block = GetReportBlock(); | |
| 466 | |
| 467 base::SimpleTestTickClock testing_clock; | |
| 468 testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); | |
| 469 | |
| 470 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); | |
| 471 size_t packet_count = kReceiveLogMessageHistorySize + 10; | |
| 472 for (size_t i = 0; i < packet_count; i++) { | |
| 473 TestRtcpPacketBuilder p; | |
| 474 p.AddRr(kSendingSsrc, 1); | |
| 475 p.AddRb(kMediaSsrc); | |
| 476 | |
| 477 p.AddReceiverLog(kSendingSsrc); | |
| 478 | |
| 479 if (i >= kSecondRedundancyOffset) { | |
| 480 p.AddReceiverFrameLog( | |
| 481 kRtpTimestamp, | |
| 482 1, | |
| 483 time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs); | |
| 484 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | |
| 485 } | |
| 486 if (i >= kFirstRedundancyOffset) { | |
| 487 p.AddReceiverFrameLog( | |
| 488 kRtpTimestamp, | |
| 489 1, | |
| 490 time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs); | |
| 491 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | |
| 492 } | |
| 493 p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms); | |
| 494 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); | |
| 495 | |
| 496 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 497 | |
| 498 FrameEvent frame_event; | |
| 499 frame_event.rtp_timestamp = kRtpTimestamp; | |
| 500 frame_event.type = FRAME_ACK_SENT; | |
| 501 frame_event.media_type = VIDEO_EVENT; | |
| 502 frame_event.timestamp = testing_clock.NowTicks(); | |
| 503 event_subscriber.OnReceiveFrameEvent(frame_event); | |
| 504 | |
| 505 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; | |
| 506 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); | |
| 507 | |
| 508 rtcp_sender_->SendRtcpFromRtpReceiver( | |
| 509 &report_block, | |
| 510 NULL, | |
| 511 NULL, | |
| 512 &rtcp_events, | |
| 513 kDefaultDelay); | |
| 514 | |
| 515 testing_clock.Advance( | |
| 516 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); | |
| 517 time_base_ms += kTimeBetweenEventsMs; | |
| 518 } | |
| 519 | |
| 520 EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count()); | |
| 521 } | |
| 522 | |
| 523 TEST_F(RtcpSenderTest, RtcpSenderReport) { | |
| 524 RtcpSenderInfo sender_info; | |
| 525 sender_info.ntp_seconds = kNtpHigh; | |
| 526 sender_info.ntp_fraction = kNtpLow; | |
| 527 sender_info.rtp_timestamp = kRtpTimestamp; | |
| 528 sender_info.send_packet_count = kSendPacketCount; | |
| 529 sender_info.send_octet_count = kSendOctetCount; | |
| 530 | |
| 531 // Sender report. | |
| 532 TestRtcpPacketBuilder p; | |
| 533 p.AddSr(kSendingSsrc, 0); | |
| 534 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); | |
| 535 | |
| 536 rtcp_sender_->SendRtcpFromRtpSender(sender_info); | |
| 537 | |
| 538 EXPECT_EQ(1, test_transport_.packet_count()); | |
| 539 } | |
| 540 | |
| 541 } // namespace cast | |
| 542 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 513313004:
Cast: Re-factor rtcp_sender.cc into rtcp_builder.cc and do some cleanup (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master