OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/memory/scoped_ptr.h" | 5 #include "base/memory/scoped_ptr.h" |
6 #include "base/test/simple_test_tick_clock.h" | 6 #include "base/test/simple_test_tick_clock.h" |
7 #include "media/cast/cast_defines.h" | 7 #include "media/cast/cast_defines.h" |
8 #include "media/cast/cast_environment.h" | 8 #include "media/cast/cast_environment.h" |
9 #include "media/cast/pacing/paced_sender.h" | 9 #include "media/cast/pacing/paced_sender.h" |
10 #include "media/cast/rtcp/rtcp_sender.h" | 10 #include "media/cast/rtcp/rtcp_sender.h" |
| 11 #include "media/cast/rtcp/rtcp_utility.h" |
11 #include "media/cast/rtcp/test_rtcp_packet_builder.h" | 12 #include "media/cast/rtcp/test_rtcp_packet_builder.h" |
12 #include "media/cast/test/fake_task_runner.h" | 13 #include "media/cast/test/fake_task_runner.h" |
13 #include "testing/gmock/include/gmock/gmock.h" | 14 #include "testing/gmock/include/gmock/gmock.h" |
14 | 15 |
15 namespace media { | 16 namespace media { |
16 namespace cast { | 17 namespace cast { |
17 | 18 |
18 namespace { | 19 namespace { |
19 static const uint32 kSendingSsrc = 0x12345678; | 20 static const uint32 kSendingSsrc = 0x12345678; |
20 static const uint32 kMediaSsrc = 0x87654321; | 21 static const uint32 kMediaSsrc = 0x87654321; |
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
156 | 157 |
157 rtcp_sender_->SendRtcpFromRtpSender( | 158 rtcp_sender_->SendRtcpFromRtpSender( |
158 RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr, | 159 RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr, |
159 &sender_info, | 160 &sender_info, |
160 &dlrr_rb, | 161 &dlrr_rb, |
161 NULL); | 162 NULL); |
162 | 163 |
163 EXPECT_EQ(1, test_transport_.packet_count()); | 164 EXPECT_EQ(1, test_transport_.packet_count()); |
164 } | 165 } |
165 | 166 |
| 167 TEST_F(RtcpSenderTest, RtcpSenderReportWithDlrrAndLog) { |
| 168 RtcpSenderInfo sender_info; |
| 169 sender_info.ntp_seconds = kNtpHigh; |
| 170 sender_info.ntp_fraction = kNtpLow; |
| 171 sender_info.rtp_timestamp = kRtpTimestamp; |
| 172 sender_info.send_packet_count = kSendPacketCount; |
| 173 sender_info.send_octet_count = kSendOctetCount; |
| 174 |
| 175 // Sender report + c_name + dlrr + sender log. |
| 176 TestRtcpPacketBuilder p; |
| 177 p.AddSr(kSendingSsrc, 0); |
| 178 p.AddSdesCname(kSendingSsrc, kCName); |
| 179 p.AddXrHeader(kSendingSsrc); |
| 180 p.AddXrDlrrBlock(kSendingSsrc); |
| 181 p.AddSenderLog(kSendingSsrc); |
| 182 p.AddSenderFrameLog(kRtcpSenderFrameStatusSentToNetwork, kRtpTimestamp); |
| 183 |
| 184 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 185 |
| 186 RtcpDlrrReportBlock dlrr_rb; |
| 187 dlrr_rb.last_rr = kLastRr; |
| 188 dlrr_rb.delay_since_last_rr = kDelayLastRr; |
| 189 |
| 190 RtcpSenderFrameLogMessage sender_frame_log; |
| 191 sender_frame_log.frame_status = kRtcpSenderFrameStatusSentToNetwork; |
| 192 sender_frame_log.rtp_timestamp = kRtpTimestamp; |
| 193 |
| 194 RtcpSenderLogMessage sender_log; |
| 195 sender_log.push_back(sender_frame_log); |
| 196 |
| 197 rtcp_sender_->SendRtcpFromRtpSender( |
| 198 RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr | RtcpSender::kRtcpSenderLog, |
| 199 &sender_info, |
| 200 &dlrr_rb, |
| 201 &sender_log); |
| 202 |
| 203 EXPECT_EQ(1, test_transport_.packet_count()); |
| 204 EXPECT_TRUE(sender_log.empty()); |
| 205 } |
| 206 |
| 207 TEST_F(RtcpSenderTest, RtcpSenderReporWithTooManyLogFrames) { |
| 208 RtcpSenderInfo sender_info; |
| 209 sender_info.ntp_seconds = kNtpHigh; |
| 210 sender_info.ntp_fraction = kNtpLow; |
| 211 sender_info.rtp_timestamp = kRtpTimestamp; |
| 212 sender_info.send_packet_count = kSendPacketCount; |
| 213 sender_info.send_octet_count = kSendOctetCount; |
| 214 |
| 215 // Sender report + c_name + sender log. |
| 216 TestRtcpPacketBuilder p; |
| 217 p.AddSr(kSendingSsrc, 0); |
| 218 p.AddSdesCname(kSendingSsrc, kCName); |
| 219 p.AddSenderLog(kSendingSsrc); |
| 220 |
| 221 for (int i = 0; i < 359; ++i) { |
| 222 p.AddSenderFrameLog(kRtcpSenderFrameStatusSentToNetwork, |
| 223 kRtpTimestamp + i * 90); |
| 224 } |
| 225 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 226 |
| 227 |
| 228 RtcpSenderLogMessage sender_log; |
| 229 for (int j = 0; j < 400; ++j) { |
| 230 RtcpSenderFrameLogMessage sender_frame_log; |
| 231 sender_frame_log.frame_status = kRtcpSenderFrameStatusSentToNetwork; |
| 232 sender_frame_log.rtp_timestamp = kRtpTimestamp + j * 90; |
| 233 sender_log.push_back(sender_frame_log); |
| 234 } |
| 235 |
| 236 rtcp_sender_->SendRtcpFromRtpSender( |
| 237 RtcpSender::kRtcpSr | RtcpSender::kRtcpSenderLog, |
| 238 &sender_info, |
| 239 NULL, |
| 240 &sender_log); |
| 241 |
| 242 EXPECT_EQ(1, test_transport_.packet_count()); |
| 243 EXPECT_EQ(41u, sender_log.size()); |
| 244 } |
| 245 |
166 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) { | 246 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) { |
167 // Receiver report with report block + c_name. | 247 // Receiver report with report block + c_name. |
168 TestRtcpPacketBuilder p; | 248 TestRtcpPacketBuilder p; |
169 p.AddRr(kSendingSsrc, 1); | 249 p.AddRr(kSendingSsrc, 1); |
170 p.AddRb(kMediaSsrc); | 250 p.AddRb(kMediaSsrc); |
171 p.AddSdesCname(kSendingSsrc, kCName); | 251 p.AddSdesCname(kSendingSsrc, kCName); |
172 p.AddXrHeader(kSendingSsrc); | 252 p.AddXrHeader(kSendingSsrc); |
173 p.AddXrRrtrBlock(); | 253 p.AddXrRrtrBlock(); |
174 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); | 254 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
175 | 255 |
176 RtcpReportBlock report_block; | 256 RtcpReportBlock report_block; |
177 // Initialize remote_ssrc to a "clearly illegal" value. | 257 // Initialize remote_ssrc to a "clearly illegal" value. |
178 report_block.remote_ssrc = 0xDEAD; | 258 report_block.remote_ssrc = 0xDEAD; |
179 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. | 259 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. |
180 report_block.fraction_lost = kLoss >> 24; | 260 report_block.fraction_lost = kLoss >> 24; |
181 report_block.cumulative_lost = kLoss; // 24 bits valid. | 261 report_block.cumulative_lost = kLoss; // 24 bits valid. |
182 report_block.extended_high_sequence_number = | 262 report_block.extended_high_sequence_number = kExtendedMax; |
183 kExtendedMax; | |
184 report_block.jitter = kTestJitter; | 263 report_block.jitter = kTestJitter; |
185 report_block.last_sr = kLastSr; | 264 report_block.last_sr = kLastSr; |
186 report_block.delay_since_last_sr = kDelayLastSr; | 265 report_block.delay_since_last_sr = kDelayLastSr; |
187 | 266 |
188 RtcpReceiverReferenceTimeReport rrtr; | 267 RtcpReceiverReferenceTimeReport rrtr; |
189 rrtr.ntp_seconds = kNtpHigh; | 268 rrtr.ntp_seconds = kNtpHigh; |
190 rrtr.ntp_fraction = kNtpLow; | 269 rrtr.ntp_fraction = kNtpLow; |
191 | 270 |
192 rtcp_sender_->SendRtcpFromRtpReceiver( | 271 rtcp_sender_->SendRtcpFromRtpReceiver( |
193 RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr, | 272 RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr, |
(...skipping 21 matching lines...) Expand all Loading... |
215 report_block.fraction_lost = kLoss >> 24; | 294 report_block.fraction_lost = kLoss >> 24; |
216 report_block.cumulative_lost = kLoss; // 24 bits valid. | 295 report_block.cumulative_lost = kLoss; // 24 bits valid. |
217 report_block.extended_high_sequence_number = kExtendedMax; | 296 report_block.extended_high_sequence_number = kExtendedMax; |
218 report_block.jitter = kTestJitter; | 297 report_block.jitter = kTestJitter; |
219 report_block.last_sr = kLastSr; | 298 report_block.last_sr = kLastSr; |
220 report_block.delay_since_last_sr = kDelayLastSr; | 299 report_block.delay_since_last_sr = kDelayLastSr; |
221 | 300 |
222 RtcpCastMessage cast_message(kMediaSsrc); | 301 RtcpCastMessage cast_message(kMediaSsrc); |
223 cast_message.ack_frame_id_ = kAckFrameId; | 302 cast_message.ack_frame_id_ = kAckFrameId; |
224 PacketIdSet missing_packets; | 303 PacketIdSet missing_packets; |
225 cast_message.missing_frames_and_packets_[ | 304 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; |
226 kLostFrameId] = missing_packets; | |
227 | 305 |
228 missing_packets.insert(kLostPacketId1); | 306 missing_packets.insert(kLostPacketId1); |
229 missing_packets.insert(kLostPacketId2); | 307 missing_packets.insert(kLostPacketId2); |
230 missing_packets.insert(kLostPacketId3); | 308 missing_packets.insert(kLostPacketId3); |
231 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = | 309 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = |
232 missing_packets; | 310 missing_packets; |
233 | 311 |
234 rtcp_sender_->SendRtcpFromRtpReceiver( | 312 rtcp_sender_->SendRtcpFromRtpReceiver( |
235 RtcpSender::kRtcpRr | RtcpSender::kRtcpCast, | 313 RtcpSender::kRtcpRr | RtcpSender::kRtcpCast, |
236 &report_block, | 314 &report_block, |
237 NULL, | 315 NULL, |
238 &cast_message, | 316 &cast_message, |
239 NULL); | 317 NULL); |
240 | 318 |
241 EXPECT_EQ(1, test_transport_.packet_count()); | 319 EXPECT_EQ(1, test_transport_.packet_count()); |
242 } | 320 } |
243 | 321 |
| 322 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) { |
| 323 TestRtcpPacketBuilder p; |
| 324 p.AddRr(kSendingSsrc, 1); |
| 325 p.AddRb(kMediaSsrc); |
| 326 p.AddSdesCname(kSendingSsrc, kCName); |
| 327 p.AddXrHeader(kSendingSsrc); |
| 328 p.AddXrRrtrBlock(); |
| 329 p.AddCast(kSendingSsrc, kMediaSsrc); |
| 330 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 331 |
| 332 RtcpReportBlock report_block; |
| 333 // Initialize remote_ssrc to a "clearly illegal" value. |
| 334 report_block.remote_ssrc = 0xDEAD; |
| 335 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. |
| 336 report_block.fraction_lost = kLoss >> 24; |
| 337 report_block.cumulative_lost = kLoss; // 24 bits valid. |
| 338 report_block.extended_high_sequence_number = kExtendedMax; |
| 339 report_block.jitter = kTestJitter; |
| 340 report_block.last_sr = kLastSr; |
| 341 report_block.delay_since_last_sr = kDelayLastSr; |
| 342 |
| 343 RtcpReceiverReferenceTimeReport rrtr; |
| 344 rrtr.ntp_seconds = kNtpHigh; |
| 345 rrtr.ntp_fraction = kNtpLow; |
| 346 |
| 347 RtcpCastMessage cast_message(kMediaSsrc); |
| 348 cast_message.ack_frame_id_ = kAckFrameId; |
| 349 PacketIdSet missing_packets; |
| 350 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; |
| 351 |
| 352 missing_packets.insert(kLostPacketId1); |
| 353 missing_packets.insert(kLostPacketId2); |
| 354 missing_packets.insert(kLostPacketId3); |
| 355 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = |
| 356 missing_packets; |
| 357 |
| 358 rtcp_sender_->SendRtcpFromRtpReceiver( |
| 359 RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast, |
| 360 &report_block, |
| 361 &rrtr, |
| 362 &cast_message, |
| 363 NULL); |
| 364 |
| 365 EXPECT_EQ(1, test_transport_.packet_count()); |
| 366 } |
| 367 |
| 368 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { |
| 369 static const uint32 kTimeBaseMs = 12345678; |
| 370 static const uint32 kTimeDelayMs = 10; |
| 371 static const uint32 kDelayDeltaMs = 123; |
| 372 |
| 373 TestRtcpPacketBuilder p; |
| 374 p.AddRr(kSendingSsrc, 1); |
| 375 p.AddRb(kMediaSsrc); |
| 376 p.AddSdesCname(kSendingSsrc, kCName); |
| 377 p.AddXrHeader(kSendingSsrc); |
| 378 p.AddXrRrtrBlock(); |
| 379 p.AddCast(kSendingSsrc, kMediaSsrc); |
| 380 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 381 |
| 382 RtcpReportBlock report_block; |
| 383 // Initialize remote_ssrc to a "clearly illegal" value. |
| 384 report_block.remote_ssrc = 0xDEAD; |
| 385 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. |
| 386 report_block.fraction_lost = kLoss >> 24; |
| 387 report_block.cumulative_lost = kLoss; // 24 bits valid. |
| 388 report_block.extended_high_sequence_number = kExtendedMax; |
| 389 report_block.jitter = kTestJitter; |
| 390 report_block.last_sr = kLastSr; |
| 391 report_block.delay_since_last_sr = kDelayLastSr; |
| 392 |
| 393 RtcpReceiverReferenceTimeReport rrtr; |
| 394 rrtr.ntp_seconds = kNtpHigh; |
| 395 rrtr.ntp_fraction = kNtpLow; |
| 396 |
| 397 RtcpCastMessage cast_message(kMediaSsrc); |
| 398 cast_message.ack_frame_id_ = kAckFrameId; |
| 399 PacketIdSet missing_packets; |
| 400 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; |
| 401 |
| 402 missing_packets.insert(kLostPacketId1); |
| 403 missing_packets.insert(kLostPacketId2); |
| 404 missing_packets.insert(kLostPacketId3); |
| 405 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = |
| 406 missing_packets; |
| 407 |
| 408 // Test empty Log message. |
| 409 RtcpReceiverLogMessage receiver_log; |
| 410 |
| 411 VLOG(0) << " Test empty Log " ; |
| 412 rtcp_sender_->SendRtcpFromRtpReceiver( |
| 413 RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast | |
| 414 RtcpSender::kRtcpReceiverLog, |
| 415 &report_block, |
| 416 &rrtr, |
| 417 &cast_message, |
| 418 &receiver_log); |
| 419 |
| 420 |
| 421 base::SimpleTestTickClock testing_clock; |
| 422 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
| 423 |
| 424 p.AddReceiverLog(kSendingSsrc); |
| 425 p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs); |
| 426 p.AddReceiverEventLog(kDelayDeltaMs, 1, 0); |
| 427 p.AddReceiverEventLog(kLostPacketId1, 6, kTimeDelayMs); |
| 428 |
| 429 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 430 |
| 431 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); |
| 432 RtcpReceiverEventLogMessage event_log; |
| 433 |
| 434 event_log.type = kAckSent; |
| 435 event_log.event_timestamp = testing_clock.NowTicks(); |
| 436 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); |
| 437 frame_log.event_log_messages_.push_back(event_log); |
| 438 |
| 439 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
| 440 event_log.type = kPacketReceived; |
| 441 event_log.event_timestamp = testing_clock.NowTicks(); |
| 442 event_log.packet_id = kLostPacketId1; |
| 443 frame_log.event_log_messages_.push_back(event_log); |
| 444 |
| 445 receiver_log.push_back(frame_log); |
| 446 |
| 447 VLOG(0) << " Test Log " ; |
| 448 rtcp_sender_->SendRtcpFromRtpReceiver( |
| 449 RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast | |
| 450 RtcpSender::kRtcpReceiverLog, |
| 451 &report_block, |
| 452 &rrtr, |
| 453 &cast_message, |
| 454 &receiver_log); |
| 455 |
| 456 EXPECT_TRUE(receiver_log.empty()); |
| 457 EXPECT_EQ(2, test_transport_.packet_count()); |
| 458 } |
| 459 |
| 460 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) { |
| 461 static const uint32 kTimeBaseMs = 12345678; |
| 462 static const uint32 kTimeDelayMs = 10; |
| 463 static const uint32 kDelayDeltaMs = 123; |
| 464 |
| 465 TestRtcpPacketBuilder p; |
| 466 p.AddRr(kSendingSsrc, 1); |
| 467 p.AddRb(kMediaSsrc); |
| 468 p.AddSdesCname(kSendingSsrc, kCName); |
| 469 |
| 470 RtcpReportBlock report_block; |
| 471 // Initialize remote_ssrc to a "clearly illegal" value. |
| 472 report_block.remote_ssrc = 0xDEAD; |
| 473 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. |
| 474 report_block.fraction_lost = kLoss >> 24; |
| 475 report_block.cumulative_lost = kLoss; // 24 bits valid. |
| 476 report_block.extended_high_sequence_number = kExtendedMax; |
| 477 report_block.jitter = kTestJitter; |
| 478 report_block.last_sr = kLastSr; |
| 479 report_block.delay_since_last_sr = kDelayLastSr; |
| 480 |
| 481 base::SimpleTestTickClock testing_clock; |
| 482 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
| 483 |
| 484 p.AddReceiverLog(kSendingSsrc); |
| 485 |
| 486 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs); |
| 487 p.AddReceiverEventLog(kDelayDeltaMs, 1, 0); |
| 488 p.AddReceiverFrameLog(kRtpTimestamp + 2345, |
| 489 kRtcpMaxReceiverLogMessages, kTimeBaseMs); |
| 490 |
| 491 for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { |
| 492 p.AddReceiverEventLog(kLostPacketId1, 6, kTimeDelayMs * i); |
| 493 } |
| 494 |
| 495 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 496 |
| 497 RtcpReceiverFrameLogMessage frame_1_log(kRtpTimestamp); |
| 498 RtcpReceiverEventLogMessage event_log; |
| 499 |
| 500 event_log.type = kAckSent; |
| 501 event_log.event_timestamp = testing_clock.NowTicks(); |
| 502 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); |
| 503 frame_1_log.event_log_messages_.push_back(event_log); |
| 504 |
| 505 RtcpReceiverLogMessage receiver_log; |
| 506 receiver_log.push_back(frame_1_log); |
| 507 |
| 508 RtcpReceiverFrameLogMessage frame_2_log(kRtpTimestamp + 2345); |
| 509 |
| 510 for (int j = 0; j < 300; ++j) { |
| 511 event_log.type = kPacketReceived; |
| 512 event_log.event_timestamp = testing_clock.NowTicks(); |
| 513 event_log.packet_id = kLostPacketId1; |
| 514 frame_2_log.event_log_messages_.push_back(event_log); |
| 515 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
| 516 } |
| 517 receiver_log.push_back(frame_2_log); |
| 518 |
| 519 rtcp_sender_->SendRtcpFromRtpReceiver( |
| 520 RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog, |
| 521 &report_block, |
| 522 NULL, |
| 523 NULL, |
| 524 &receiver_log); |
| 525 |
| 526 EXPECT_EQ(1, test_transport_.packet_count()); |
| 527 EXPECT_EQ(1u, receiver_log.size()); |
| 528 EXPECT_EQ(300u - kRtcpMaxReceiverLogMessages, |
| 529 receiver_log.front().event_log_messages_.size()); |
| 530 } |
| 531 |
| 532 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) { |
| 533 static const uint32 kTimeBaseMs = 12345678; |
| 534 static const uint32 kTimeDelayMs = 10; |
| 535 static const uint32 kDelayDeltaMs = 123; |
| 536 |
| 537 TestRtcpPacketBuilder p; |
| 538 p.AddRr(kSendingSsrc, 1); |
| 539 p.AddRb(kMediaSsrc); |
| 540 p.AddSdesCname(kSendingSsrc, kCName); |
| 541 |
| 542 RtcpReportBlock report_block; |
| 543 // Initialize remote_ssrc to a "clearly illegal" value. |
| 544 report_block.remote_ssrc = 0xDEAD; |
| 545 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. |
| 546 report_block.fraction_lost = kLoss >> 24; |
| 547 report_block.cumulative_lost = kLoss; // 24 bits valid. |
| 548 report_block.extended_high_sequence_number = kExtendedMax; |
| 549 report_block.jitter = kTestJitter; |
| 550 report_block.last_sr = kLastSr; |
| 551 report_block.delay_since_last_sr = kDelayLastSr; |
| 552 |
| 553 base::SimpleTestTickClock testing_clock; |
| 554 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
| 555 |
| 556 p.AddReceiverLog(kSendingSsrc); |
| 557 |
| 558 for (int i = 0; i < 119; ++i) { |
| 559 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs); |
| 560 p.AddReceiverEventLog(kDelayDeltaMs, 1, 0); |
| 561 } |
| 562 test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length()); |
| 563 |
| 564 RtcpReceiverLogMessage receiver_log; |
| 565 |
| 566 for (int j = 0; j < 200; ++j) { |
| 567 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); |
| 568 RtcpReceiverEventLogMessage event_log; |
| 569 |
| 570 event_log.type = kAckSent; |
| 571 event_log.event_timestamp = testing_clock.NowTicks(); |
| 572 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); |
| 573 frame_log.event_log_messages_.push_back(event_log); |
| 574 receiver_log.push_back(frame_log); |
| 575 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
| 576 } |
| 577 rtcp_sender_->SendRtcpFromRtpReceiver( |
| 578 RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog, |
| 579 &report_block, |
| 580 NULL, |
| 581 NULL, |
| 582 &receiver_log); |
| 583 |
| 584 EXPECT_EQ(1, test_transport_.packet_count()); |
| 585 EXPECT_EQ(81u, receiver_log.size()); |
| 586 } |
| 587 |
244 } // namespace cast | 588 } // namespace cast |
245 } // namespace media | 589 } // namespace media |
OLD | NEW |