OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
207 0x12, 0x34, 0x56, 0x78, | 207 0x12, 0x34, 0x56, 0x78, |
208 0x98, 0x76, 0x54, 0x32}; | 208 0x98, 0x76, 0x54, 0x32}; |
209 // clang-format on | 209 // clang-format on |
210 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, _)).Times(0); | 210 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, _)).Times(0); |
211 InjectRtcpPacket(bad_packet); | 211 InjectRtcpPacket(bad_packet); |
212 } | 212 } |
213 | 213 |
214 TEST_F(RtcpReceiverTest, InjectRpsiPacket) { | 214 TEST_F(RtcpReceiverTest, InjectRpsiPacket) { |
215 const uint64_t kPictureId = 0x123456789; | 215 const uint64_t kPictureId = 0x123456789; |
216 rtcp::Rpsi rpsi; | 216 rtcp::Rpsi rpsi; |
217 rpsi.SetPictureId(kPictureId); | 217 rpsi.WithPictureId(kPictureId); |
218 | 218 |
219 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId)); | 219 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId)); |
220 InjectRtcpPacket(rpsi); | 220 InjectRtcpPacket(rpsi); |
221 } | 221 } |
222 | 222 |
223 TEST_F(RtcpReceiverTest, InjectSrPacket) { | 223 TEST_F(RtcpReceiverTest, InjectSrPacket) { |
224 RTCPSenderInfo info; | 224 RTCPSenderInfo info; |
225 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); | 225 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); |
226 | 226 |
227 int64_t now = system_clock_.TimeInMilliseconds(); | 227 int64_t now = system_clock_.TimeInMilliseconds(); |
228 rtcp::SenderReport sr; | 228 rtcp::SenderReport sr; |
229 sr.SetSenderSsrc(kSenderSsrc); | 229 sr.From(kSenderSsrc); |
230 | 230 |
231 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); | 231 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
232 EXPECT_CALL(bandwidth_observer_, | 232 EXPECT_CALL(bandwidth_observer_, |
233 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); | 233 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
234 InjectRtcpPacket(sr); | 234 InjectRtcpPacket(sr); |
235 | 235 |
236 EXPECT_EQ(0, rtcp_receiver_.SenderInfoReceived(&info)); | 236 EXPECT_EQ(0, rtcp_receiver_.SenderInfoReceived(&info)); |
237 } | 237 } |
238 | 238 |
239 TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { | 239 TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { |
240 int64_t now = system_clock_.TimeInMilliseconds(); | 240 int64_t now = system_clock_.TimeInMilliseconds(); |
241 rtcp::SenderReport sr; | 241 rtcp::SenderReport sr; |
242 sr.SetSenderSsrc(kUnknownSenderSsrc); | 242 sr.From(kUnknownSenderSsrc); |
243 | 243 |
244 // The parser will handle report blocks in Sender Report from other than his | 244 // The parser will handle report blocks in Sender Report from other than his |
245 // expected peer. | 245 // expected peer. |
246 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 246 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
247 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now)); | 247 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now)); |
248 InjectRtcpPacket(sr); | 248 InjectRtcpPacket(sr); |
249 | 249 |
250 // But will not flag that he's gotten sender information. | 250 // But will not flag that he's gotten sender information. |
251 RTCPSenderInfo info; | 251 RTCPSenderInfo info; |
252 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); | 252 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); |
253 } | 253 } |
254 | 254 |
255 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { | 255 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { |
256 Random r(0x0123456789abcdef); | 256 Random r(0x0123456789abcdef); |
257 const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000); | 257 const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000); |
258 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); | 258 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); |
259 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); | 259 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
260 | 260 |
261 int64_t rtt_ms = 0; | 261 int64_t rtt_ms = 0; |
262 EXPECT_EQ( | 262 EXPECT_EQ( |
263 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 263 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
264 | 264 |
265 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); | 265 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); |
266 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 266 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
267 | 267 |
268 rtcp::SenderReport sr; | 268 rtcp::SenderReport sr; |
269 sr.SetSenderSsrc(kSenderSsrc); | 269 sr.From(kSenderSsrc); |
270 rtcp::ReportBlock block; | 270 rtcp::ReportBlock block; |
271 block.SetMediaSsrc(kReceiverMainSsrc); | 271 block.To(kReceiverMainSsrc); |
272 block.SetLastSr(sent_ntp); | 272 block.WithLastSr(sent_ntp); |
273 block.SetDelayLastSr(kDelayNtp); | 273 block.WithDelayLastSr(kDelayNtp); |
274 sr.AddReportBlock(block); | 274 sr.WithReportBlock(block); |
275 | 275 |
276 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 276 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
277 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 277 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
278 InjectRtcpPacket(sr); | 278 InjectRtcpPacket(sr); |
279 | 279 |
280 EXPECT_EQ( | 280 EXPECT_EQ( |
281 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 281 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
282 EXPECT_NEAR(kRttMs, rtt_ms, 1); | 282 EXPECT_NEAR(kRttMs, rtt_ms, 1); |
283 } | 283 } |
284 | 284 |
285 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { | 285 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { |
286 Random r(0x0123456789abcdef); | 286 Random r(0x0123456789abcdef); |
287 const int64_t kRttMs = r.Rand(-3600 * 1000, -1); | 287 const int64_t kRttMs = r.Rand(-3600 * 1000, -1); |
288 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); | 288 const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); |
289 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); | 289 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
290 | 290 |
291 int64_t rtt_ms = 0; | 291 int64_t rtt_ms = 0; |
292 EXPECT_EQ( | 292 EXPECT_EQ( |
293 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 293 -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
294 | 294 |
295 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); | 295 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); |
296 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 296 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
297 | 297 |
298 rtcp::SenderReport sr; | 298 rtcp::SenderReport sr; |
299 sr.SetSenderSsrc(kSenderSsrc); | 299 sr.From(kSenderSsrc); |
300 rtcp::ReportBlock block; | 300 rtcp::ReportBlock block; |
301 block.SetMediaSsrc(kReceiverMainSsrc); | 301 block.To(kReceiverMainSsrc); |
302 block.SetLastSr(sent_ntp); | 302 block.WithLastSr(sent_ntp); |
303 block.SetDelayLastSr(kDelayNtp); | 303 block.WithDelayLastSr(kDelayNtp); |
304 sr.AddReportBlock(block); | 304 sr.WithReportBlock(block); |
305 | 305 |
306 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); | 306 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
307 EXPECT_CALL(bandwidth_observer_, | 307 EXPECT_CALL(bandwidth_observer_, |
308 OnReceivedRtcpReceiverReport(SizeIs(1), _, _)); | 308 OnReceivedRtcpReceiverReport(SizeIs(1), _, _)); |
309 InjectRtcpPacket(sr); | 309 InjectRtcpPacket(sr); |
310 | 310 |
311 EXPECT_EQ( | 311 EXPECT_EQ( |
312 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 312 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
313 EXPECT_EQ(1, rtt_ms); | 313 EXPECT_EQ(1, rtt_ms); |
314 } | 314 } |
315 | 315 |
316 TEST_F(RtcpReceiverTest, InjectRrPacket) { | 316 TEST_F(RtcpReceiverTest, InjectRrPacket) { |
317 int64_t now = system_clock_.TimeInMilliseconds(); | 317 int64_t now = system_clock_.TimeInMilliseconds(); |
318 rtcp::ReceiverReport rr; | 318 rtcp::ReceiverReport rr; |
319 rr.SetSenderSsrc(kSenderSsrc); | 319 rr.From(kSenderSsrc); |
320 | 320 |
321 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); | 321 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
322 EXPECT_CALL(bandwidth_observer_, | 322 EXPECT_CALL(bandwidth_observer_, |
323 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); | 323 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
324 InjectRtcpPacket(rr); | 324 InjectRtcpPacket(rr); |
325 | 325 |
326 RTCPSenderInfo info; | 326 RTCPSenderInfo info; |
327 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); | 327 EXPECT_EQ(-1, rtcp_receiver_.SenderInfoReceived(&info)); |
328 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 328 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
329 std::vector<RTCPReportBlock> report_blocks; | 329 std::vector<RTCPReportBlock> report_blocks; |
330 rtcp_receiver_.StatisticsReceived(&report_blocks); | 330 rtcp_receiver_.StatisticsReceived(&report_blocks); |
331 EXPECT_TRUE(report_blocks.empty()); | 331 EXPECT_TRUE(report_blocks.empty()); |
332 } | 332 } |
333 | 333 |
334 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { | 334 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { |
335 int64_t now = system_clock_.TimeInMilliseconds(); | 335 int64_t now = system_clock_.TimeInMilliseconds(); |
336 rtcp::ReportBlock rb; | 336 rtcp::ReportBlock rb; |
337 rb.SetMediaSsrc(kNotToUsSsrc); | 337 rb.To(kNotToUsSsrc); |
338 rtcp::ReceiverReport rr; | 338 rtcp::ReceiverReport rr; |
339 rr.SetSenderSsrc(kSenderSsrc); | 339 rr.From(kSenderSsrc); |
340 rr.AddReportBlock(rb); | 340 rr.WithReportBlock(rb); |
341 | 341 |
342 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); | 342 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
343 EXPECT_CALL(bandwidth_observer_, | 343 EXPECT_CALL(bandwidth_observer_, |
344 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); | 344 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
345 InjectRtcpPacket(rr); | 345 InjectRtcpPacket(rr); |
346 | 346 |
347 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 347 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
348 std::vector<RTCPReportBlock> received_blocks; | 348 std::vector<RTCPReportBlock> received_blocks; |
349 rtcp_receiver_.StatisticsReceived(&received_blocks); | 349 rtcp_receiver_.StatisticsReceived(&received_blocks); |
350 EXPECT_TRUE(received_blocks.empty()); | 350 EXPECT_TRUE(received_blocks.empty()); |
351 } | 351 } |
352 | 352 |
353 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { | 353 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { |
354 int64_t now = system_clock_.TimeInMilliseconds(); | 354 int64_t now = system_clock_.TimeInMilliseconds(); |
355 | 355 |
356 rtcp::ReportBlock rb; | 356 rtcp::ReportBlock rb; |
357 rb.SetMediaSsrc(kReceiverMainSsrc); | 357 rb.To(kReceiverMainSsrc); |
358 rtcp::ReceiverReport rr; | 358 rtcp::ReceiverReport rr; |
359 rr.SetSenderSsrc(kSenderSsrc); | 359 rr.From(kSenderSsrc); |
360 rr.AddReportBlock(rb); | 360 rr.WithReportBlock(rb); |
361 | 361 |
362 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); | 362 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
363 EXPECT_CALL(bandwidth_observer_, | 363 EXPECT_CALL(bandwidth_observer_, |
364 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); | 364 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
365 InjectRtcpPacket(rr); | 365 InjectRtcpPacket(rr); |
366 | 366 |
367 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 367 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
368 std::vector<RTCPReportBlock> received_blocks; | 368 std::vector<RTCPReportBlock> received_blocks; |
369 rtcp_receiver_.StatisticsReceived(&received_blocks); | 369 rtcp_receiver_.StatisticsReceived(&received_blocks); |
370 EXPECT_EQ(1u, received_blocks.size()); | 370 EXPECT_EQ(1u, received_blocks.size()); |
371 } | 371 } |
372 | 372 |
373 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { | 373 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { |
374 const uint16_t kSequenceNumbers[] = {10, 12423}; | 374 const uint16_t kSequenceNumbers[] = {10, 12423}; |
375 const uint32_t kCumLost[] = {13, 555}; | 375 const uint32_t kCumLost[] = {13, 555}; |
376 const uint8_t kFracLost[] = {20, 11}; | 376 const uint8_t kFracLost[] = {20, 11}; |
377 int64_t now = system_clock_.TimeInMilliseconds(); | 377 int64_t now = system_clock_.TimeInMilliseconds(); |
378 | 378 |
379 rtcp::ReportBlock rb1; | 379 rtcp::ReportBlock rb1; |
380 rb1.SetMediaSsrc(kReceiverMainSsrc); | 380 rb1.To(kReceiverMainSsrc); |
381 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); | 381 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); |
382 rb1.SetFractionLost(10); | 382 rb1.WithFractionLost(10); |
383 | 383 |
384 rtcp::ReportBlock rb2; | 384 rtcp::ReportBlock rb2; |
385 rb2.SetMediaSsrc(kReceiverExtraSsrc); | 385 rb2.To(kReceiverExtraSsrc); |
386 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); | 386 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); |
387 rb2.SetFractionLost(0); | 387 rb2.WithFractionLost(0); |
388 | 388 |
389 rtcp::ReceiverReport rr1; | 389 rtcp::ReceiverReport rr1; |
390 rr1.SetSenderSsrc(kSenderSsrc); | 390 rr1.From(kSenderSsrc); |
391 rr1.AddReportBlock(rb1); | 391 rr1.WithReportBlock(rb1); |
392 rr1.AddReportBlock(rb2); | 392 rr1.WithReportBlock(rb2); |
393 | 393 |
394 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); | 394 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); |
395 EXPECT_CALL(bandwidth_observer_, | 395 EXPECT_CALL(bandwidth_observer_, |
396 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); | 396 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
397 InjectRtcpPacket(rr1); | 397 InjectRtcpPacket(rr1); |
398 | 398 |
399 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 399 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
400 std::vector<RTCPReportBlock> received_blocks; | 400 std::vector<RTCPReportBlock> received_blocks; |
401 rtcp_receiver_.StatisticsReceived(&received_blocks); | 401 rtcp_receiver_.StatisticsReceived(&received_blocks); |
402 EXPECT_THAT(received_blocks, | 402 EXPECT_THAT(received_blocks, |
403 UnorderedElementsAre(Field(&RTCPReportBlock::fractionLost, 0), | 403 UnorderedElementsAre(Field(&RTCPReportBlock::fractionLost, 0), |
404 Field(&RTCPReportBlock::fractionLost, 10))); | 404 Field(&RTCPReportBlock::fractionLost, 10))); |
405 | 405 |
406 // Insert next receiver report with same ssrc but new values. | 406 // Insert next receiver report with same ssrc but new values. |
407 rtcp::ReportBlock rb3; | 407 rtcp::ReportBlock rb3; |
408 rb3.SetMediaSsrc(kReceiverMainSsrc); | 408 rb3.To(kReceiverMainSsrc); |
409 rb3.SetExtHighestSeqNum(kSequenceNumbers[0]); | 409 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); |
410 rb3.SetFractionLost(kFracLost[0]); | 410 rb3.WithFractionLost(kFracLost[0]); |
411 rb3.SetCumulativeLost(kCumLost[0]); | 411 rb3.WithCumulativeLost(kCumLost[0]); |
412 | 412 |
413 rtcp::ReportBlock rb4; | 413 rtcp::ReportBlock rb4; |
414 rb4.SetMediaSsrc(kReceiverExtraSsrc); | 414 rb4.To(kReceiverExtraSsrc); |
415 rb4.SetExtHighestSeqNum(kSequenceNumbers[1]); | 415 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); |
416 rb4.SetFractionLost(kFracLost[1]); | 416 rb4.WithFractionLost(kFracLost[1]); |
417 rb4.SetCumulativeLost(kCumLost[1]); | 417 rb4.WithCumulativeLost(kCumLost[1]); |
418 | 418 |
419 rtcp::ReceiverReport rr2; | 419 rtcp::ReceiverReport rr2; |
420 rr2.SetSenderSsrc(kSenderSsrc); | 420 rr2.From(kSenderSsrc); |
421 rr2.AddReportBlock(rb3); | 421 rr2.WithReportBlock(rb3); |
422 rr2.AddReportBlock(rb4); | 422 rr2.WithReportBlock(rb4); |
423 | 423 |
424 // Advance time to make 1st sent time and 2nd sent time different. | 424 // Advance time to make 1st sent time and 2nd sent time different. |
425 system_clock_.AdvanceTimeMilliseconds(500); | 425 system_clock_.AdvanceTimeMilliseconds(500); |
426 now = system_clock_.TimeInMilliseconds(); | 426 now = system_clock_.TimeInMilliseconds(); |
427 | 427 |
428 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); | 428 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); |
429 EXPECT_CALL(bandwidth_observer_, | 429 EXPECT_CALL(bandwidth_observer_, |
430 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); | 430 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
431 InjectRtcpPacket(rr2); | 431 InjectRtcpPacket(rr2); |
432 | 432 |
(...skipping 14 matching lines...) Expand all Loading... |
447 kSequenceNumbers[1])))); | 447 kSequenceNumbers[1])))); |
448 } | 448 } |
449 | 449 |
450 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { | 450 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { |
451 const uint32_t kSenderSsrc2 = 0x20304; | 451 const uint32_t kSenderSsrc2 = 0x20304; |
452 const uint16_t kSequenceNumbers[] = {10, 12423}; | 452 const uint16_t kSequenceNumbers[] = {10, 12423}; |
453 const uint32_t kCumLost[] = {13, 555}; | 453 const uint32_t kCumLost[] = {13, 555}; |
454 const uint8_t kFracLost[] = {20, 11}; | 454 const uint8_t kFracLost[] = {20, 11}; |
455 | 455 |
456 rtcp::ReportBlock rb1; | 456 rtcp::ReportBlock rb1; |
457 rb1.SetMediaSsrc(kReceiverMainSsrc); | 457 rb1.To(kReceiverMainSsrc); |
458 rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); | 458 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); |
459 rb1.SetFractionLost(kFracLost[0]); | 459 rb1.WithFractionLost(kFracLost[0]); |
460 rb1.SetCumulativeLost(kCumLost[0]); | 460 rb1.WithCumulativeLost(kCumLost[0]); |
461 rtcp::ReceiverReport rr1; | 461 rtcp::ReceiverReport rr1; |
462 rr1.SetSenderSsrc(kSenderSsrc); | 462 rr1.From(kSenderSsrc); |
463 rr1.AddReportBlock(rb1); | 463 rr1.WithReportBlock(rb1); |
464 | 464 |
465 int64_t now = system_clock_.TimeInMilliseconds(); | 465 int64_t now = system_clock_.TimeInMilliseconds(); |
466 | 466 |
467 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); | 467 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
468 EXPECT_CALL(bandwidth_observer_, | 468 EXPECT_CALL(bandwidth_observer_, |
469 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); | 469 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
470 InjectRtcpPacket(rr1); | 470 InjectRtcpPacket(rr1); |
471 | 471 |
472 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 472 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
473 | 473 |
474 std::vector<RTCPReportBlock> received_blocks; | 474 std::vector<RTCPReportBlock> received_blocks; |
475 rtcp_receiver_.StatisticsReceived(&received_blocks); | 475 rtcp_receiver_.StatisticsReceived(&received_blocks); |
476 EXPECT_EQ(1u, received_blocks.size()); | 476 EXPECT_EQ(1u, received_blocks.size()); |
477 EXPECT_EQ(kSenderSsrc, received_blocks[0].remoteSSRC); | 477 EXPECT_EQ(kSenderSsrc, received_blocks[0].remoteSSRC); |
478 EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].sourceSSRC); | 478 EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].sourceSSRC); |
479 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); | 479 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); |
480 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); | 480 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); |
481 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); | 481 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); |
482 | 482 |
483 rtcp::ReportBlock rb2; | 483 rtcp::ReportBlock rb2; |
484 rb2.SetMediaSsrc(kReceiverMainSsrc); | 484 rb2.To(kReceiverMainSsrc); |
485 rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); | 485 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); |
486 rb2.SetFractionLost(kFracLost[1]); | 486 rb2.WithFractionLost(kFracLost[1]); |
487 rb2.SetCumulativeLost(kCumLost[1]); | 487 rb2.WithCumulativeLost(kCumLost[1]); |
488 rtcp::ReceiverReport rr2; | 488 rtcp::ReceiverReport rr2; |
489 rr2.SetSenderSsrc(kSenderSsrc2); | 489 rr2.From(kSenderSsrc2); |
490 rr2.AddReportBlock(rb2); | 490 rr2.WithReportBlock(rb2); |
491 | 491 |
492 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); | 492 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
493 EXPECT_CALL(bandwidth_observer_, | 493 EXPECT_CALL(bandwidth_observer_, |
494 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); | 494 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
495 InjectRtcpPacket(rr2); | 495 InjectRtcpPacket(rr2); |
496 | 496 |
497 received_blocks.clear(); | 497 received_blocks.clear(); |
498 rtcp_receiver_.StatisticsReceived(&received_blocks); | 498 rtcp_receiver_.StatisticsReceived(&received_blocks); |
499 ASSERT_EQ(2u, received_blocks.size()); | 499 ASSERT_EQ(2u, received_blocks.size()); |
500 EXPECT_THAT(received_blocks, | 500 EXPECT_THAT(received_blocks, |
(...skipping 11 matching lines...) Expand all Loading... |
512 Field(&RTCPReportBlock::extendedHighSeqNum, | 512 Field(&RTCPReportBlock::extendedHighSeqNum, |
513 kSequenceNumbers[1])))); | 513 kSequenceNumbers[1])))); |
514 } | 514 } |
515 | 515 |
516 TEST_F(RtcpReceiverTest, GetRtt) { | 516 TEST_F(RtcpReceiverTest, GetRtt) { |
517 // No report block received. | 517 // No report block received. |
518 EXPECT_EQ( | 518 EXPECT_EQ( |
519 -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); | 519 -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
520 | 520 |
521 rtcp::ReportBlock rb; | 521 rtcp::ReportBlock rb; |
522 rb.SetMediaSsrc(kReceiverMainSsrc); | 522 rb.To(kReceiverMainSsrc); |
523 | 523 |
524 rtcp::ReceiverReport rr; | 524 rtcp::ReceiverReport rr; |
525 rr.SetSenderSsrc(kSenderSsrc); | 525 rr.From(kSenderSsrc); |
526 rr.AddReportBlock(rb); | 526 rr.WithReportBlock(rb); |
527 int64_t now = system_clock_.TimeInMilliseconds(); | 527 int64_t now = system_clock_.TimeInMilliseconds(); |
528 | 528 |
529 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 529 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
530 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 530 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
531 InjectRtcpPacket(rr); | 531 InjectRtcpPacket(rr); |
532 | 532 |
533 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); | 533 EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
534 EXPECT_EQ( | 534 EXPECT_EQ( |
535 0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); | 535 0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
536 } | 536 } |
537 | 537 |
538 // Ij packets are ignored. | 538 // Ij packets are ignored. |
539 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { | 539 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { |
540 rtcp::ExtendedJitterReport ij; | 540 rtcp::ExtendedJitterReport ij; |
541 InjectRtcpPacket(ij); | 541 InjectRtcpPacket(ij); |
542 } | 542 } |
543 | 543 |
544 // App packets are ignored. | 544 // App packets are ignored. |
545 TEST_F(RtcpReceiverTest, InjectApp) { | 545 TEST_F(RtcpReceiverTest, InjectApp) { |
546 rtcp::App app; | 546 rtcp::App app; |
547 app.SetSubType(30); | 547 app.WithSubType(30); |
548 app.SetName(0x17a177e); | 548 app.WithName(0x17a177e); |
549 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; | 549 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; |
550 app.SetData(kData, sizeof(kData)); | 550 app.WithData(kData, sizeof(kData)); |
551 | 551 |
552 InjectRtcpPacket(app); | 552 InjectRtcpPacket(app); |
553 } | 553 } |
554 | 554 |
555 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { | 555 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { |
556 const char kCname[] = "alice@host"; | 556 const char kCname[] = "alice@host"; |
557 MockRtcpCallbackImpl callback; | 557 MockRtcpCallbackImpl callback; |
558 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); | 558 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); |
559 rtcp::Sdes sdes; | 559 rtcp::Sdes sdes; |
560 sdes.AddCName(kSenderSsrc, kCname); | 560 sdes.WithCName(kSenderSsrc, kCname); |
561 | 561 |
562 EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc)); | 562 EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc)); |
563 InjectRtcpPacket(sdes); | 563 InjectRtcpPacket(sdes); |
564 | 564 |
565 char cName[RTCP_CNAME_SIZE]; | 565 char cName[RTCP_CNAME_SIZE]; |
566 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); | 566 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
567 EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE)); | 567 EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE)); |
568 } | 568 } |
569 | 569 |
570 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { | 570 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { |
571 const char kCname[] = "alice@host"; | 571 const char kCname[] = "alice@host"; |
572 rtcp::Sdes sdes; | 572 rtcp::Sdes sdes; |
573 sdes.AddCName(kSenderSsrc, kCname); | 573 sdes.WithCName(kSenderSsrc, kCname); |
574 | 574 |
575 InjectRtcpPacket(sdes); | 575 InjectRtcpPacket(sdes); |
576 | 576 |
577 char cName[RTCP_CNAME_SIZE]; | 577 char cName[RTCP_CNAME_SIZE]; |
578 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); | 578 EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
579 | 579 |
580 // Verify that BYE removes the CNAME. | 580 // Verify that BYE removes the CNAME. |
581 rtcp::Bye bye; | 581 rtcp::Bye bye; |
582 bye.SetSenderSsrc(kSenderSsrc); | 582 bye.From(kSenderSsrc); |
583 | 583 |
584 InjectRtcpPacket(bye); | 584 InjectRtcpPacket(bye); |
585 | 585 |
586 EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName)); | 586 EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
587 } | 587 } |
588 | 588 |
589 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { | 589 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { |
590 rtcp::ReportBlock rb1; | 590 rtcp::ReportBlock rb1; |
591 rb1.SetMediaSsrc(kReceiverMainSsrc); | 591 rb1.To(kReceiverMainSsrc); |
592 rtcp::ReportBlock rb2; | 592 rtcp::ReportBlock rb2; |
593 rb2.SetMediaSsrc(kReceiverExtraSsrc); | 593 rb2.To(kReceiverExtraSsrc); |
594 rtcp::ReceiverReport rr; | 594 rtcp::ReceiverReport rr; |
595 rr.SetSenderSsrc(kSenderSsrc); | 595 rr.From(kSenderSsrc); |
596 rr.AddReportBlock(rb1); | 596 rr.WithReportBlock(rb1); |
597 rr.AddReportBlock(rb2); | 597 rr.WithReportBlock(rb2); |
598 | 598 |
599 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 599 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
600 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 600 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
601 InjectRtcpPacket(rr); | 601 InjectRtcpPacket(rr); |
602 | 602 |
603 std::vector<RTCPReportBlock> received_blocks; | 603 std::vector<RTCPReportBlock> received_blocks; |
604 rtcp_receiver_.StatisticsReceived(&received_blocks); | 604 rtcp_receiver_.StatisticsReceived(&received_blocks); |
605 EXPECT_EQ(2u, received_blocks.size()); | 605 EXPECT_EQ(2u, received_blocks.size()); |
606 | 606 |
607 // Verify that BYE removes the report blocks. | 607 // Verify that BYE removes the report blocks. |
608 rtcp::Bye bye; | 608 rtcp::Bye bye; |
609 bye.SetSenderSsrc(kSenderSsrc); | 609 bye.From(kSenderSsrc); |
610 | 610 |
611 InjectRtcpPacket(bye); | 611 InjectRtcpPacket(bye); |
612 | 612 |
613 received_blocks.clear(); | 613 received_blocks.clear(); |
614 rtcp_receiver_.StatisticsReceived(&received_blocks); | 614 rtcp_receiver_.StatisticsReceived(&received_blocks); |
615 EXPECT_TRUE(received_blocks.empty()); | 615 EXPECT_TRUE(received_blocks.empty()); |
616 | 616 |
617 // Inject packet again. | 617 // Inject packet again. |
618 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 618 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
619 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 619 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
620 InjectRtcpPacket(rr); | 620 InjectRtcpPacket(rr); |
621 | 621 |
622 received_blocks.clear(); | 622 received_blocks.clear(); |
623 rtcp_receiver_.StatisticsReceived(&received_blocks); | 623 rtcp_receiver_.StatisticsReceived(&received_blocks); |
624 EXPECT_EQ(2u, received_blocks.size()); | 624 EXPECT_EQ(2u, received_blocks.size()); |
625 } | 625 } |
626 | 626 |
627 TEST_F(RtcpReceiverTest, InjectPliPacket) { | 627 TEST_F(RtcpReceiverTest, InjectPliPacket) { |
628 rtcp::Pli pli; | 628 rtcp::Pli pli; |
629 pli.SetMediaSsrc(kReceiverMainSsrc); | 629 pli.To(kReceiverMainSsrc); |
630 | 630 |
631 EXPECT_CALL( | 631 EXPECT_CALL( |
632 packet_type_counter_observer_, | 632 packet_type_counter_observer_, |
633 RtcpPacketTypesCounterUpdated( | 633 RtcpPacketTypesCounterUpdated( |
634 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1))); | 634 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1))); |
635 EXPECT_CALL(intra_frame_observer_, | 635 EXPECT_CALL(intra_frame_observer_, |
636 OnReceivedIntraFrameRequest(kReceiverMainSsrc)); | 636 OnReceivedIntraFrameRequest(kReceiverMainSsrc)); |
637 InjectRtcpPacket(pli); | 637 InjectRtcpPacket(pli); |
638 } | 638 } |
639 | 639 |
640 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { | 640 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { |
641 rtcp::Pli pli; | 641 rtcp::Pli pli; |
642 pli.SetMediaSsrc(kNotToUsSsrc); | 642 pli.To(kNotToUsSsrc); |
643 | 643 |
644 EXPECT_CALL( | 644 EXPECT_CALL( |
645 packet_type_counter_observer_, | 645 packet_type_counter_observer_, |
646 RtcpPacketTypesCounterUpdated( | 646 RtcpPacketTypesCounterUpdated( |
647 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0))); | 647 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0))); |
648 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); | 648 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); |
649 InjectRtcpPacket(pli); | 649 InjectRtcpPacket(pli); |
650 } | 650 } |
651 | 651 |
652 TEST_F(RtcpReceiverTest, InjectFirPacket) { | 652 TEST_F(RtcpReceiverTest, InjectFirPacket) { |
653 rtcp::Fir fir; | 653 rtcp::Fir fir; |
654 fir.AddRequestTo(kReceiverMainSsrc, 13); | 654 fir.WithRequestTo(kReceiverMainSsrc, 13); |
655 | 655 |
656 EXPECT_CALL( | 656 EXPECT_CALL( |
657 packet_type_counter_observer_, | 657 packet_type_counter_observer_, |
658 RtcpPacketTypesCounterUpdated( | 658 RtcpPacketTypesCounterUpdated( |
659 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1))); | 659 kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1))); |
660 EXPECT_CALL(intra_frame_observer_, | 660 EXPECT_CALL(intra_frame_observer_, |
661 OnReceivedIntraFrameRequest(kReceiverMainSsrc)); | 661 OnReceivedIntraFrameRequest(kReceiverMainSsrc)); |
662 InjectRtcpPacket(fir); | 662 InjectRtcpPacket(fir); |
663 } | 663 } |
664 | 664 |
665 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { | 665 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { |
666 rtcp::Fir fir; | 666 rtcp::Fir fir; |
667 fir.AddRequestTo(kNotToUsSsrc, 13); | 667 fir.WithRequestTo(kNotToUsSsrc, 13); |
668 | 668 |
669 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); | 669 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); |
670 InjectRtcpPacket(fir); | 670 InjectRtcpPacket(fir); |
671 } | 671 } |
672 | 672 |
673 TEST_F(RtcpReceiverTest, InjectSliPacket) { | 673 TEST_F(RtcpReceiverTest, InjectSliPacket) { |
674 const uint8_t kPictureId = 40; | 674 const uint8_t kPictureId = 40; |
675 rtcp::Sli sli; | 675 rtcp::Sli sli; |
676 sli.AddPictureId(kPictureId); | 676 sli.WithPictureId(kPictureId); |
677 | 677 |
678 EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, kPictureId)); | 678 EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, kPictureId)); |
679 InjectRtcpPacket(sli); | 679 InjectRtcpPacket(sli); |
680 } | 680 } |
681 | 681 |
682 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { | 682 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { |
683 rtcp::ExtendedReports xr; | 683 rtcp::ExtendedReports xr; |
684 xr.SetSenderSsrc(kSenderSsrc); | 684 xr.From(kSenderSsrc); |
685 | 685 |
686 InjectRtcpPacket(xr); | 686 InjectRtcpPacket(xr); |
687 } | 687 } |
688 | 688 |
689 // VOiP reports are ignored. | 689 // VOiP reports are ignored. |
690 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { | 690 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { |
691 const uint8_t kLossRate = 123; | 691 const uint8_t kLossRate = 123; |
692 rtcp::VoipMetric voip_metric; | 692 rtcp::VoipMetric voip_metric; |
693 voip_metric.SetMediaSsrc(kReceiverMainSsrc); | 693 voip_metric.To(kReceiverMainSsrc); |
694 RTCPVoIPMetric metric; | 694 RTCPVoIPMetric metric; |
695 metric.lossRate = kLossRate; | 695 metric.lossRate = kLossRate; |
696 voip_metric.SetVoipMetric(metric); | 696 voip_metric.WithVoipMetric(metric); |
697 rtcp::ExtendedReports xr; | 697 rtcp::ExtendedReports xr; |
698 xr.SetSenderSsrc(kSenderSsrc); | 698 xr.From(kSenderSsrc); |
699 xr.AddVoipMetric(voip_metric); | 699 xr.WithVoipMetric(voip_metric); |
700 | 700 |
701 InjectRtcpPacket(xr); | 701 InjectRtcpPacket(xr); |
702 } | 702 } |
703 | 703 |
704 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { | 704 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { |
705 rtcp::VoipMetric voip_metric; | 705 rtcp::VoipMetric voip_metric; |
706 voip_metric.SetMediaSsrc(kNotToUsSsrc); | 706 voip_metric.To(kNotToUsSsrc); |
707 rtcp::ExtendedReports xr; | 707 rtcp::ExtendedReports xr; |
708 xr.SetSenderSsrc(kSenderSsrc); | 708 xr.From(kSenderSsrc); |
709 xr.AddVoipMetric(voip_metric); | 709 xr.WithVoipMetric(voip_metric); |
710 | 710 |
711 InjectRtcpPacket(xr); | 711 InjectRtcpPacket(xr); |
712 } | 712 } |
713 | 713 |
714 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { | 714 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { |
715 const NtpTime kNtp(0x10203, 0x40506); | 715 const NtpTime kNtp(0x10203, 0x40506); |
716 rtcp::Rrtr rrtr; | 716 rtcp::Rrtr rrtr; |
717 rrtr.SetNtp(kNtp); | 717 rrtr.WithNtp(kNtp); |
718 rtcp::ExtendedReports xr; | 718 rtcp::ExtendedReports xr; |
719 xr.SetSenderSsrc(kSenderSsrc); | 719 xr.From(kSenderSsrc); |
720 xr.AddRrtr(rrtr); | 720 xr.WithRrtr(rrtr); |
721 | 721 |
722 RtcpReceiveTimeInfo rrtime; | 722 RtcpReceiveTimeInfo rrtime; |
723 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); | 723 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
724 | 724 |
725 InjectRtcpPacket(xr); | 725 InjectRtcpPacket(xr); |
726 | 726 |
727 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); | 727 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
728 EXPECT_EQ(rrtime.sourceSSRC, kSenderSsrc); | 728 EXPECT_EQ(rrtime.sourceSSRC, kSenderSsrc); |
729 EXPECT_EQ(rrtime.lastRR, CompactNtp(kNtp)); | 729 EXPECT_EQ(rrtime.lastRR, CompactNtp(kNtp)); |
730 EXPECT_EQ(0u, rrtime.delaySinceLastRR); | 730 EXPECT_EQ(0u, rrtime.delaySinceLastRR); |
731 | 731 |
732 system_clock_.AdvanceTimeMilliseconds(1500); | 732 system_clock_.AdvanceTimeMilliseconds(1500); |
733 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); | 733 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
734 EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delaySinceLastRR), 1); | 734 EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delaySinceLastRR), 1); |
735 } | 735 } |
736 | 736 |
737 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { | 737 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { |
738 // Allow calculate rtt using dlrr/rrtr, simulating media receiver side. | 738 // Allow calculate rtt using dlrr/rrtr, simulating media receiver side. |
739 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 739 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
740 | 740 |
741 rtcp::Dlrr dlrr; | 741 rtcp::Dlrr dlrr; |
742 dlrr.AddDlrrItem(kNotToUsSsrc, 0x12345, 0x67890); | 742 dlrr.WithDlrrItem(kNotToUsSsrc, 0x12345, 0x67890); |
743 rtcp::ExtendedReports xr; | 743 rtcp::ExtendedReports xr; |
744 xr.SetSenderSsrc(kSenderSsrc); | 744 xr.From(kSenderSsrc); |
745 xr.AddDlrr(dlrr); | 745 xr.WithDlrr(dlrr); |
746 | 746 |
747 InjectRtcpPacket(xr); | 747 InjectRtcpPacket(xr); |
748 | 748 |
749 int64_t rtt_ms = 0; | 749 int64_t rtt_ms = 0; |
750 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 750 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
751 } | 751 } |
752 | 752 |
753 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { | 753 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { |
754 const uint32_t kLastRR = 0x12345; | 754 const uint32_t kLastRR = 0x12345; |
755 const uint32_t kDelay = 0x23456; | 755 const uint32_t kDelay = 0x23456; |
756 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 756 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
757 int64_t rtt_ms = 0; | 757 int64_t rtt_ms = 0; |
758 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 758 EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
759 | 759 |
760 rtcp::Dlrr dlrr; | 760 rtcp::Dlrr dlrr; |
761 dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); | 761 dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); |
762 rtcp::ExtendedReports xr; | 762 rtcp::ExtendedReports xr; |
763 xr.SetSenderSsrc(kSenderSsrc); | 763 xr.From(kSenderSsrc); |
764 xr.AddDlrr(dlrr); | 764 xr.WithDlrr(dlrr); |
765 | 765 |
766 InjectRtcpPacket(xr); | 766 InjectRtcpPacket(xr); |
767 | 767 |
768 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); | 768 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); |
769 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 769 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
770 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; | 770 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
771 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); | 771 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); |
772 } | 772 } |
773 | 773 |
774 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { | 774 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { |
775 const uint32_t kLastRR = 0x12345; | 775 const uint32_t kLastRR = 0x12345; |
776 const uint32_t kDelay = 0x56789; | 776 const uint32_t kDelay = 0x56789; |
777 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 777 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
778 | 778 |
779 rtcp::ExtendedReports xr; | 779 rtcp::ExtendedReports xr; |
780 xr.SetSenderSsrc(kSenderSsrc); | 780 xr.From(kSenderSsrc); |
781 rtcp::Dlrr dlrr; | 781 rtcp::Dlrr dlrr; |
782 dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); | 782 dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); |
783 dlrr.AddDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890); | 783 dlrr.WithDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890); |
784 dlrr.AddDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890); | 784 dlrr.WithDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890); |
785 xr.AddDlrr(dlrr); | 785 xr.WithDlrr(dlrr); |
786 | 786 |
787 InjectRtcpPacket(xr); | 787 InjectRtcpPacket(xr); |
788 | 788 |
789 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); | 789 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); |
790 int64_t rtt_ms = 0; | 790 int64_t rtt_ms = 0; |
791 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 791 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
792 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; | 792 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
793 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); | 793 EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); |
794 } | 794 } |
795 | 795 |
796 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { | 796 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { |
797 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 797 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
798 | 798 |
799 rtcp::Rrtr rrtr; | 799 rtcp::Rrtr rrtr; |
800 rtcp::Dlrr dlrr; | 800 rtcp::Dlrr dlrr; |
801 dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); | 801 dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); |
802 rtcp::VoipMetric metric; | 802 rtcp::VoipMetric metric; |
803 metric.SetMediaSsrc(kReceiverMainSsrc); | 803 metric.To(kReceiverMainSsrc); |
804 rtcp::ExtendedReports xr; | 804 rtcp::ExtendedReports xr; |
805 xr.SetSenderSsrc(kSenderSsrc); | 805 xr.From(kSenderSsrc); |
806 xr.AddRrtr(rrtr); | 806 xr.WithRrtr(rrtr); |
807 xr.AddDlrr(dlrr); | 807 xr.WithDlrr(dlrr); |
808 xr.AddVoipMetric(metric); | 808 xr.WithVoipMetric(metric); |
809 | 809 |
810 InjectRtcpPacket(xr); | 810 InjectRtcpPacket(xr); |
811 | 811 |
812 RtcpReceiveTimeInfo rrtime; | 812 RtcpReceiveTimeInfo rrtime; |
813 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); | 813 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
814 int64_t rtt_ms = 0; | 814 int64_t rtt_ms = 0; |
815 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 815 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
816 } | 816 } |
817 | 817 |
818 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { | 818 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { |
819 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 819 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
820 | 820 |
821 rtcp::Rrtr rrtr; | 821 rtcp::Rrtr rrtr; |
822 rtcp::Dlrr dlrr; | 822 rtcp::Dlrr dlrr; |
823 dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); | 823 dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); |
824 rtcp::VoipMetric metric; | 824 rtcp::VoipMetric metric; |
825 metric.SetMediaSsrc(kReceiverMainSsrc); | 825 metric.To(kReceiverMainSsrc); |
826 rtcp::ExtendedReports xr; | 826 rtcp::ExtendedReports xr; |
827 xr.SetSenderSsrc(kSenderSsrc); | 827 xr.From(kSenderSsrc); |
828 xr.AddRrtr(rrtr); | 828 xr.WithRrtr(rrtr); |
829 xr.AddDlrr(dlrr); | 829 xr.WithDlrr(dlrr); |
830 xr.AddVoipMetric(metric); | 830 xr.WithVoipMetric(metric); |
831 | 831 |
832 rtc::Buffer packet = xr.Build(); | 832 rtc::Buffer packet = xr.Build(); |
833 // Modify the DLRR block to have an unsupported block type, from 5 to 6. | 833 // Modify the DLRR block to have an unsupported block type, from 5 to 6. |
834 ASSERT_EQ(5, packet.data()[20]); | 834 ASSERT_EQ(5, packet.data()[20]); |
835 packet.data()[20] = 6; | 835 packet.data()[20] = 6; |
836 InjectRtcpPacket(packet); | 836 InjectRtcpPacket(packet); |
837 | 837 |
838 // Validate Rrtr was received and processed. | 838 // Validate Rrtr was received and processed. |
839 RtcpReceiveTimeInfo rrtime; | 839 RtcpReceiveTimeInfo rrtime; |
840 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); | 840 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
(...skipping 13 matching lines...) Expand all Loading... |
854 Random rand(0x0123456789abcdef); | 854 Random rand(0x0123456789abcdef); |
855 const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000); | 855 const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000); |
856 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); | 856 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); |
857 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); | 857 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
858 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 858 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
859 NtpTime now(system_clock_); | 859 NtpTime now(system_clock_); |
860 uint32_t sent_ntp = CompactNtp(now); | 860 uint32_t sent_ntp = CompactNtp(now); |
861 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 861 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
862 | 862 |
863 rtcp::Dlrr dlrr; | 863 rtcp::Dlrr dlrr; |
864 dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); | 864 dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); |
865 rtcp::ExtendedReports xr; | 865 rtcp::ExtendedReports xr; |
866 xr.SetSenderSsrc(kSenderSsrc); | 866 xr.From(kSenderSsrc); |
867 xr.AddDlrr(dlrr); | 867 xr.WithDlrr(dlrr); |
868 | 868 |
869 InjectRtcpPacket(xr); | 869 InjectRtcpPacket(xr); |
870 | 870 |
871 int64_t rtt_ms = 0; | 871 int64_t rtt_ms = 0; |
872 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 872 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
873 EXPECT_NEAR(kRttMs, rtt_ms, 1); | 873 EXPECT_NEAR(kRttMs, rtt_ms, 1); |
874 } | 874 } |
875 | 875 |
876 TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { | 876 TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { |
877 Random rand(0x0123456789abcdef); | 877 Random rand(0x0123456789abcdef); |
878 const int64_t kRttMs = rand.Rand(-3600 * 1000, -1); | 878 const int64_t kRttMs = rand.Rand(-3600 * 1000, -1); |
879 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); | 879 const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); |
880 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); | 880 const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
881 NtpTime now(system_clock_); | 881 NtpTime now(system_clock_); |
882 uint32_t sent_ntp = CompactNtp(now); | 882 uint32_t sent_ntp = CompactNtp(now); |
883 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 883 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
884 rtcp_receiver_.SetRtcpXrRrtrStatus(true); | 884 rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
885 | 885 |
886 rtcp::Dlrr dlrr; | 886 rtcp::Dlrr dlrr; |
887 dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); | 887 dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); |
888 rtcp::ExtendedReports xr; | 888 rtcp::ExtendedReports xr; |
889 xr.SetSenderSsrc(kSenderSsrc); | 889 xr.From(kSenderSsrc); |
890 xr.AddDlrr(dlrr); | 890 xr.WithDlrr(dlrr); |
891 | 891 |
892 InjectRtcpPacket(xr); | 892 InjectRtcpPacket(xr); |
893 | 893 |
894 int64_t rtt_ms = 0; | 894 int64_t rtt_ms = 0; |
895 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); | 895 EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
896 EXPECT_EQ(1, rtt_ms); | 896 EXPECT_EQ(1, rtt_ms); |
897 } | 897 } |
898 | 898 |
899 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { | 899 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { |
900 RtcpReceiveTimeInfo info; | 900 RtcpReceiveTimeInfo info; |
901 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); | 901 EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
902 } | 902 } |
903 | 903 |
904 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { | 904 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { |
905 const NtpTime kNtp(0x10203, 0x40506); | 905 const NtpTime kNtp(0x10203, 0x40506); |
906 const uint32_t kNtpMid = CompactNtp(kNtp); | 906 const uint32_t kNtpMid = CompactNtp(kNtp); |
907 | 907 |
908 rtcp::Rrtr rrtr; | 908 rtcp::Rrtr rrtr; |
909 rrtr.SetNtp(kNtp); | 909 rrtr.WithNtp(kNtp); |
910 rtcp::ExtendedReports xr; | 910 rtcp::ExtendedReports xr; |
911 xr.SetSenderSsrc(kSenderSsrc); | 911 xr.From(kSenderSsrc); |
912 xr.AddRrtr(rrtr); | 912 xr.WithRrtr(rrtr); |
913 | 913 |
914 InjectRtcpPacket(xr); | 914 InjectRtcpPacket(xr); |
915 | 915 |
916 RtcpReceiveTimeInfo info; | 916 RtcpReceiveTimeInfo info; |
917 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); | 917 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
918 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); | 918 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); |
919 EXPECT_EQ(kNtpMid, info.lastRR); | 919 EXPECT_EQ(kNtpMid, info.lastRR); |
920 EXPECT_EQ(0U, info.delaySinceLastRR); | 920 EXPECT_EQ(0U, info.delaySinceLastRR); |
921 | 921 |
922 system_clock_.AdvanceTimeMilliseconds(1000); | 922 system_clock_.AdvanceTimeMilliseconds(1000); |
923 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); | 923 EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
924 EXPECT_EQ(65536U, info.delaySinceLastRR); | 924 EXPECT_EQ(65536U, info.delaySinceLastRR); |
925 } | 925 } |
926 | 926 |
927 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { | 927 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { |
928 const int64_t kRtcpIntervalMs = 1000; | 928 const int64_t kRtcpIntervalMs = 1000; |
929 const uint16_t kSequenceNumber = 1234; | 929 const uint16_t kSequenceNumber = 1234; |
930 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); | 930 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
931 | 931 |
932 // No RR received, shouldn't trigger a timeout. | 932 // No RR received, shouldn't trigger a timeout. |
933 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 933 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
934 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 934 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
935 | 935 |
936 // Add a RR and advance the clock just enough to not trigger a timeout. | 936 // Add a RR and advance the clock just enough to not trigger a timeout. |
937 rtcp::ReportBlock rb1; | 937 rtcp::ReportBlock rb1; |
938 rb1.SetMediaSsrc(kReceiverMainSsrc); | 938 rb1.To(kReceiverMainSsrc); |
939 rb1.SetExtHighestSeqNum(kSequenceNumber); | 939 rb1.WithExtHighestSeqNum(kSequenceNumber); |
940 rtcp::ReceiverReport rr1; | 940 rtcp::ReceiverReport rr1; |
941 rr1.SetSenderSsrc(kSenderSsrc); | 941 rr1.From(kSenderSsrc); |
942 rr1.AddReportBlock(rb1); | 942 rr1.WithReportBlock(rb1); |
943 | 943 |
944 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 944 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
945 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 945 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
946 InjectRtcpPacket(rr1); | 946 InjectRtcpPacket(rr1); |
947 | 947 |
948 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); | 948 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); |
949 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 949 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
950 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 950 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
951 | 951 |
952 // Add a RR with the same extended max as the previous RR to trigger a | 952 // Add a RR with the same extended max as the previous RR to trigger a |
(...skipping 10 matching lines...) Expand all Loading... |
963 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); | 963 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
964 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 964 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
965 | 965 |
966 // We should only get one timeout even though we still haven't received a new | 966 // We should only get one timeout even though we still haven't received a new |
967 // RR. | 967 // RR. |
968 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 968 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
969 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 969 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
970 | 970 |
971 // Add a new RR with increase sequence number to reset timers. | 971 // Add a new RR with increase sequence number to reset timers. |
972 rtcp::ReportBlock rb2; | 972 rtcp::ReportBlock rb2; |
973 rb2.SetMediaSsrc(kReceiverMainSsrc); | 973 rb2.To(kReceiverMainSsrc); |
974 rb2.SetExtHighestSeqNum(kSequenceNumber + 1); | 974 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); |
975 rtcp::ReceiverReport rr2; | 975 rtcp::ReceiverReport rr2; |
976 rr2.SetSenderSsrc(kSenderSsrc); | 976 rr2.From(kSenderSsrc); |
977 rr2.AddReportBlock(rb2); | 977 rr2.WithReportBlock(rb2); |
978 | 978 |
979 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 979 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
980 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 980 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
981 InjectRtcpPacket(rr2); | 981 InjectRtcpPacket(rr2); |
982 | 982 |
983 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 983 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
984 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 984 EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
985 | 985 |
986 // Verify we can get a timeout again once we've received new RR. | 986 // Verify we can get a timeout again once we've received new RR. |
987 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); | 987 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
988 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 988 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
989 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 989 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
990 InjectRtcpPacket(rr2); | 990 InjectRtcpPacket(rr2); |
991 | 991 |
992 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); | 992 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); |
993 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 993 EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
994 EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 994 EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
995 | 995 |
996 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); | 996 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
997 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); | 997 EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
998 } | 998 } |
999 | 999 |
1000 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { | 1000 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { |
1001 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); | 1001 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
1002 } | 1002 } |
1003 | 1003 |
1004 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { | 1004 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { |
1005 const uint32_t kBitrateBps = 30000; | 1005 const uint32_t kBitrateBps = 30000; |
1006 rtcp::Tmmbr tmmbr; | 1006 rtcp::Tmmbr tmmbr; |
1007 tmmbr.SetSenderSsrc(kSenderSsrc); | 1007 tmmbr.From(kSenderSsrc); |
1008 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0)); | 1008 tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0)); |
1009 rtcp::SenderReport sr; | 1009 rtcp::SenderReport sr; |
1010 sr.SetSenderSsrc(kSenderSsrc); | 1010 sr.From(kSenderSsrc); |
1011 rtcp::CompoundPacket compound; | 1011 rtcp::CompoundPacket compound; |
1012 compound.Append(&sr); | 1012 compound.Append(&sr); |
1013 compound.Append(&tmmbr); | 1013 compound.Append(&tmmbr); |
1014 | 1014 |
1015 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1015 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1016 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1))); | 1016 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1))); |
1017 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1017 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1018 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); | 1018 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
1019 InjectRtcpPacket(compound); | 1019 InjectRtcpPacket(compound); |
1020 | 1020 |
1021 std::vector<rtcp::TmmbItem> tmmbr_received = rtcp_receiver_.TmmbrReceived(); | 1021 std::vector<rtcp::TmmbItem> tmmbr_received = rtcp_receiver_.TmmbrReceived(); |
1022 ASSERT_EQ(1u, tmmbr_received.size()); | 1022 ASSERT_EQ(1u, tmmbr_received.size()); |
1023 EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps()); | 1023 EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps()); |
1024 EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc()); | 1024 EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc()); |
1025 } | 1025 } |
1026 | 1026 |
1027 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { | 1027 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { |
1028 const uint32_t kBitrateBps = 30000; | 1028 const uint32_t kBitrateBps = 30000; |
1029 rtcp::Tmmbr tmmbr; | 1029 rtcp::Tmmbr tmmbr; |
1030 tmmbr.SetSenderSsrc(kSenderSsrc); | 1030 tmmbr.From(kSenderSsrc); |
1031 tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0)); | 1031 tmmbr.WithTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0)); |
1032 | 1032 |
1033 rtcp::SenderReport sr; | 1033 rtcp::SenderReport sr; |
1034 sr.SetSenderSsrc(kSenderSsrc); | 1034 sr.From(kSenderSsrc); |
1035 rtcp::CompoundPacket compound; | 1035 rtcp::CompoundPacket compound; |
1036 compound.Append(&sr); | 1036 compound.Append(&sr); |
1037 compound.Append(&tmmbr); | 1037 compound.Append(&tmmbr); |
1038 | 1038 |
1039 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1039 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1040 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1040 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1041 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); | 1041 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
1042 InjectRtcpPacket(compound); | 1042 InjectRtcpPacket(compound); |
1043 | 1043 |
1044 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); | 1044 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
1045 } | 1045 } |
1046 | 1046 |
1047 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { | 1047 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { |
1048 rtcp::Tmmbr tmmbr; | 1048 rtcp::Tmmbr tmmbr; |
1049 tmmbr.SetSenderSsrc(kSenderSsrc); | 1049 tmmbr.From(kSenderSsrc); |
1050 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); | 1050 tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); |
1051 rtcp::SenderReport sr; | 1051 rtcp::SenderReport sr; |
1052 sr.SetSenderSsrc(kSenderSsrc); | 1052 sr.From(kSenderSsrc); |
1053 rtcp::CompoundPacket compound; | 1053 rtcp::CompoundPacket compound; |
1054 compound.Append(&sr); | 1054 compound.Append(&sr); |
1055 compound.Append(&tmmbr); | 1055 compound.Append(&tmmbr); |
1056 | 1056 |
1057 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1057 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1058 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1058 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1059 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); | 1059 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
1060 InjectRtcpPacket(compound); | 1060 InjectRtcpPacket(compound); |
1061 | 1061 |
1062 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); | 1062 EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
1063 } | 1063 } |
1064 | 1064 |
1065 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { | 1065 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { |
1066 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. | 1066 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. |
1067 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. | 1067 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. |
1068 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { | 1068 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { |
1069 rtcp::Tmmbr tmmbr; | 1069 rtcp::Tmmbr tmmbr; |
1070 tmmbr.SetSenderSsrc(ssrc); | 1070 tmmbr.From(ssrc); |
1071 tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0)); | 1071 tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0)); |
1072 rtcp::SenderReport sr; | 1072 rtcp::SenderReport sr; |
1073 sr.SetSenderSsrc(ssrc); | 1073 sr.From(ssrc); |
1074 rtcp::CompoundPacket compound; | 1074 rtcp::CompoundPacket compound; |
1075 compound.Append(&sr); | 1075 compound.Append(&sr); |
1076 compound.Append(&tmmbr); | 1076 compound.Append(&tmmbr); |
1077 | 1077 |
1078 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1078 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1079 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_)); | 1079 EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_)); |
1080 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1080 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1081 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)); | 1081 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)); |
1082 InjectRtcpPacket(compound); | 1082 InjectRtcpPacket(compound); |
1083 | 1083 |
(...skipping 17 matching lines...) Expand all Loading... |
1101 MockRtcpCallbackImpl callback; | 1101 MockRtcpCallbackImpl callback; |
1102 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); | 1102 rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); |
1103 | 1103 |
1104 const uint8_t kFractionLoss = 3; | 1104 const uint8_t kFractionLoss = 3; |
1105 const uint32_t kCumulativeLoss = 7; | 1105 const uint32_t kCumulativeLoss = 7; |
1106 const uint32_t kJitter = 9; | 1106 const uint32_t kJitter = 9; |
1107 const uint16_t kSequenceNumber = 1234; | 1107 const uint16_t kSequenceNumber = 1234; |
1108 | 1108 |
1109 // First packet, all numbers should just propagate. | 1109 // First packet, all numbers should just propagate. |
1110 rtcp::ReportBlock rb1; | 1110 rtcp::ReportBlock rb1; |
1111 rb1.SetMediaSsrc(kReceiverMainSsrc); | 1111 rb1.To(kReceiverMainSsrc); |
1112 rb1.SetExtHighestSeqNum(kSequenceNumber); | 1112 rb1.WithExtHighestSeqNum(kSequenceNumber); |
1113 rb1.SetFractionLost(kFractionLoss); | 1113 rb1.WithFractionLost(kFractionLoss); |
1114 rb1.SetCumulativeLost(kCumulativeLoss); | 1114 rb1.WithCumulativeLost(kCumulativeLoss); |
1115 rb1.SetJitter(kJitter); | 1115 rb1.WithJitter(kJitter); |
1116 | 1116 |
1117 rtcp::ReceiverReport rr1; | 1117 rtcp::ReceiverReport rr1; |
1118 rr1.SetSenderSsrc(kSenderSsrc); | 1118 rr1.From(kSenderSsrc); |
1119 rr1.AddReportBlock(rb1); | 1119 rr1.WithReportBlock(rb1); |
1120 EXPECT_CALL( | 1120 EXPECT_CALL( |
1121 callback, | 1121 callback, |
1122 StatisticsUpdated( | 1122 StatisticsUpdated( |
1123 AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss), | 1123 AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss), |
1124 Field(&RtcpStatistics::cumulative_lost, kCumulativeLoss), | 1124 Field(&RtcpStatistics::cumulative_lost, kCumulativeLoss), |
1125 Field(&RtcpStatistics::extended_max_sequence_number, | 1125 Field(&RtcpStatistics::extended_max_sequence_number, |
1126 kSequenceNumber), | 1126 kSequenceNumber), |
1127 Field(&RtcpStatistics::jitter, kJitter)), | 1127 Field(&RtcpStatistics::jitter, kJitter)), |
1128 kReceiverMainSsrc)); | 1128 kReceiverMainSsrc)); |
1129 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1129 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1130 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1130 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1131 InjectRtcpPacket(rr1); | 1131 InjectRtcpPacket(rr1); |
1132 | 1132 |
1133 rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr); | 1133 rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr); |
1134 | 1134 |
1135 // Add arbitrary numbers, callback should not be called. | 1135 // Add arbitrary numbers, callback should not be called. |
1136 rtcp::ReportBlock rb2; | 1136 rtcp::ReportBlock rb2; |
1137 rb2.SetMediaSsrc(kReceiverMainSsrc); | 1137 rb2.To(kReceiverMainSsrc); |
1138 rb2.SetExtHighestSeqNum(kSequenceNumber + 1); | 1138 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); |
1139 rb2.SetFractionLost(42); | 1139 rb2.WithFractionLost(42); |
1140 rb2.SetCumulativeLost(137); | 1140 rb2.WithCumulativeLost(137); |
1141 rb2.SetJitter(4711); | 1141 rb2.WithJitter(4711); |
1142 | 1142 |
1143 rtcp::ReceiverReport rr2; | 1143 rtcp::ReceiverReport rr2; |
1144 rr2.SetSenderSsrc(kSenderSsrc); | 1144 rr2.From(kSenderSsrc); |
1145 rr2.AddReportBlock(rb2); | 1145 rr2.WithReportBlock(rb2); |
1146 | 1146 |
1147 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); | 1147 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
1148 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); | 1148 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1149 EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0); | 1149 EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0); |
1150 InjectRtcpPacket(rr2); | 1150 InjectRtcpPacket(rr2); |
1151 } | 1151 } |
1152 | 1152 |
1153 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { | 1153 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { |
1154 rtcp::TransportFeedback packet; | 1154 rtcp::TransportFeedback packet; |
1155 packet.SetMediaSsrc(kReceiverMainSsrc); | 1155 packet.To(kReceiverMainSsrc); |
1156 packet.SetSenderSsrc(kSenderSsrc); | 1156 packet.From(kSenderSsrc); |
1157 packet.SetBase(1, 1000); | 1157 packet.WithBase(1, 1000); |
1158 packet.AddReceivedPacket(1, 1000); | 1158 packet.WithReceivedPacket(1, 1000); |
1159 | 1159 |
1160 EXPECT_CALL( | 1160 EXPECT_CALL( |
1161 transport_feedback_observer_, | 1161 transport_feedback_observer_, |
1162 OnTransportFeedback(AllOf( | 1162 OnTransportFeedback(AllOf( |
1163 Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc), | 1163 Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc), |
1164 Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc)))); | 1164 Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc)))); |
1165 InjectRtcpPacket(packet); | 1165 InjectRtcpPacket(packet); |
1166 } | 1166 } |
1167 | 1167 |
1168 TEST_F(RtcpReceiverTest, ReceivesRemb) { | 1168 TEST_F(RtcpReceiverTest, ReceivesRemb) { |
1169 const uint32_t kBitrateBps = 500000; | 1169 const uint32_t kBitrateBps = 500000; |
1170 rtcp::Remb remb; | 1170 rtcp::Remb remb; |
1171 remb.SetSenderSsrc(kSenderSsrc); | 1171 remb.From(kSenderSsrc); |
1172 remb.SetBitrateBps(kBitrateBps); | 1172 remb.WithBitrateBps(kBitrateBps); |
1173 | 1173 |
1174 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); | 1174 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
1175 InjectRtcpPacket(remb); | 1175 InjectRtcpPacket(remb); |
1176 } | 1176 } |
1177 | 1177 |
1178 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { | 1178 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { |
1179 // Send a compound packet with a TransportFeedback followed by something else. | 1179 // Send a compound packet with a TransportFeedback followed by something else. |
1180 rtcp::TransportFeedback packet; | 1180 rtcp::TransportFeedback packet; |
1181 packet.SetMediaSsrc(kReceiverMainSsrc); | 1181 packet.To(kReceiverMainSsrc); |
1182 packet.SetSenderSsrc(kSenderSsrc); | 1182 packet.From(kSenderSsrc); |
1183 packet.SetBase(1, 1000); | 1183 packet.WithBase(1, 1000); |
1184 packet.AddReceivedPacket(1, 1000); | 1184 packet.WithReceivedPacket(1, 1000); |
1185 | 1185 |
1186 static uint32_t kBitrateBps = 50000; | 1186 static uint32_t kBitrateBps = 50000; |
1187 rtcp::Remb remb; | 1187 rtcp::Remb remb; |
1188 remb.SetSenderSsrc(kSenderSsrc); | 1188 remb.From(kSenderSsrc); |
1189 remb.SetBitrateBps(kBitrateBps); | 1189 remb.WithBitrateBps(kBitrateBps); |
1190 rtcp::CompoundPacket compound; | 1190 rtcp::CompoundPacket compound; |
1191 compound.Append(&packet); | 1191 compound.Append(&packet); |
1192 compound.Append(&remb); | 1192 compound.Append(&remb); |
1193 rtc::Buffer built_packet = compound.Build(); | 1193 rtc::Buffer built_packet = compound.Build(); |
1194 | 1194 |
1195 // Modify the TransportFeedback packet so that it is invalid. | 1195 // Modify the TransportFeedback packet so that it is invalid. |
1196 const size_t kStatusCountOffset = 14; | 1196 const size_t kStatusCountOffset = 14; |
1197 ByteWriter<uint16_t>::WriteBigEndian( | 1197 ByteWriter<uint16_t>::WriteBigEndian( |
1198 &built_packet.data()[kStatusCountOffset], 42); | 1198 &built_packet.data()[kStatusCountOffset], 42); |
1199 | 1199 |
1200 // Stress no transport feedback is expected. | 1200 // Stress no transport feedback is expected. |
1201 EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0); | 1201 EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0); |
1202 // But remb should be processed and cause a callback | 1202 // But remb should be processed and cause a callback |
1203 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); | 1203 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
1204 InjectRtcpPacket(built_packet); | 1204 InjectRtcpPacket(built_packet); |
1205 } | 1205 } |
1206 | 1206 |
1207 TEST_F(RtcpReceiverTest, Nack) { | 1207 TEST_F(RtcpReceiverTest, Nack) { |
1208 const uint16_t kNackList1[] = {1, 2, 3, 5}; | 1208 const uint16_t kNackList1[] = {1, 2, 3, 5}; |
1209 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); | 1209 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); |
1210 const uint16_t kNackList2[] = {5, 7, 30, 40}; | 1210 const uint16_t kNackList2[] = {5, 7, 30, 40}; |
1211 const size_t kNackListLength2 = std::end(kNackList2) - std::begin(kNackList2); | 1211 const size_t kNackListLength2 = std::end(kNackList2) - std::begin(kNackList2); |
1212 std::set<uint16_t> nack_set; | 1212 std::set<uint16_t> nack_set; |
1213 nack_set.insert(std::begin(kNackList1), std::end(kNackList1)); | 1213 nack_set.insert(std::begin(kNackList1), std::end(kNackList1)); |
1214 nack_set.insert(std::begin(kNackList2), std::end(kNackList2)); | 1214 nack_set.insert(std::begin(kNackList2), std::end(kNackList2)); |
1215 | 1215 |
1216 rtcp::Nack nack; | 1216 rtcp::Nack nack; |
1217 nack.SetSenderSsrc(kSenderSsrc); | 1217 nack.From(kSenderSsrc); |
1218 nack.SetMediaSsrc(kReceiverMainSsrc); | 1218 nack.To(kReceiverMainSsrc); |
1219 nack.SetPacketIds(kNackList1, kNackListLength1); | 1219 nack.WithList(kNackList1, kNackListLength1); |
1220 | 1220 |
1221 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1))); | 1221 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1))); |
1222 EXPECT_CALL( | 1222 EXPECT_CALL( |
1223 packet_type_counter_observer_, | 1223 packet_type_counter_observer_, |
1224 RtcpPacketTypesCounterUpdated( | 1224 RtcpPacketTypesCounterUpdated( |
1225 kReceiverMainSsrc, | 1225 kReceiverMainSsrc, |
1226 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, kNackListLength1), | 1226 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, kNackListLength1), |
1227 Field(&RtcpPacketTypeCounter::unique_nack_requests, | 1227 Field(&RtcpPacketTypeCounter::unique_nack_requests, |
1228 kNackListLength1)))); | 1228 kNackListLength1)))); |
1229 InjectRtcpPacket(nack); | 1229 InjectRtcpPacket(nack); |
1230 | 1230 |
1231 rtcp::Nack nack2; | 1231 rtcp::Nack nack2; |
1232 nack2.SetSenderSsrc(kSenderSsrc); | 1232 nack2.From(kSenderSsrc); |
1233 nack2.SetMediaSsrc(kReceiverMainSsrc); | 1233 nack2.To(kReceiverMainSsrc); |
1234 nack2.SetPacketIds(kNackList2, kNackListLength2); | 1234 nack2.WithList(kNackList2, kNackListLength2); |
1235 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList2))); | 1235 EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList2))); |
1236 EXPECT_CALL(packet_type_counter_observer_, | 1236 EXPECT_CALL(packet_type_counter_observer_, |
1237 RtcpPacketTypesCounterUpdated( | 1237 RtcpPacketTypesCounterUpdated( |
1238 kReceiverMainSsrc, | 1238 kReceiverMainSsrc, |
1239 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, | 1239 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, |
1240 kNackListLength1 + kNackListLength2), | 1240 kNackListLength1 + kNackListLength2), |
1241 Field(&RtcpPacketTypeCounter::unique_nack_requests, | 1241 Field(&RtcpPacketTypeCounter::unique_nack_requests, |
1242 nack_set.size())))); | 1242 nack_set.size())))); |
1243 InjectRtcpPacket(nack2); | 1243 InjectRtcpPacket(nack2); |
1244 } | 1244 } |
1245 | 1245 |
1246 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { | 1246 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { |
1247 const uint16_t kNackList1[] = {1, 2, 3, 5}; | 1247 const uint16_t kNackList1[] = {1, 2, 3, 5}; |
1248 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); | 1248 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); |
1249 | 1249 |
1250 rtcp::Nack nack; | 1250 rtcp::Nack nack; |
1251 nack.SetSenderSsrc(kSenderSsrc); | 1251 nack.From(kSenderSsrc); |
1252 nack.SetMediaSsrc(kNotToUsSsrc); | 1252 nack.To(kNotToUsSsrc); |
1253 nack.SetPacketIds(kNackList1, kNackListLength1); | 1253 nack.WithList(kNackList1, kNackListLength1); |
1254 | 1254 |
1255 EXPECT_CALL(packet_type_counter_observer_, | 1255 EXPECT_CALL(packet_type_counter_observer_, |
1256 RtcpPacketTypesCounterUpdated( | 1256 RtcpPacketTypesCounterUpdated( |
1257 _, Field(&RtcpPacketTypeCounter::nack_requests, 0))); | 1257 _, Field(&RtcpPacketTypeCounter::nack_requests, 0))); |
1258 InjectRtcpPacket(nack); | 1258 InjectRtcpPacket(nack); |
1259 } | 1259 } |
1260 | 1260 |
1261 TEST_F(RtcpReceiverTest, ForceSenderReport) { | 1261 TEST_F(RtcpReceiverTest, ForceSenderReport) { |
1262 rtcp::RapidResyncRequest rr; | 1262 rtcp::RapidResyncRequest rr; |
1263 rr.SetSenderSsrc(kSenderSsrc); | 1263 rr.From(kSenderSsrc); |
1264 rr.SetMediaSsrc(kReceiverMainSsrc); | 1264 rr.To(kReceiverMainSsrc); |
1265 | 1265 |
1266 EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport()); | 1266 EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport()); |
1267 InjectRtcpPacket(rr); | 1267 InjectRtcpPacket(rr); |
1268 } | 1268 } |
1269 | 1269 |
1270 } // namespace webrtc | 1270 } // namespace webrtc |
OLD | NEW |