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 431 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
442 // The timestamp of this RTCP packet should be estimated as the timestamp of | 442 // The timestamp of this RTCP packet should be estimated as the timestamp of |
443 // the frame being captured at this moment. We are calculating that | 443 // the frame being captured at this moment. We are calculating that |
444 // timestamp as the last frame's timestamp + the time since the last frame | 444 // timestamp as the last frame's timestamp + the time since the last frame |
445 // was captured. | 445 // was captured. |
446 uint32_t rtp_timestamp = | 446 uint32_t rtp_timestamp = |
447 timestamp_offset_ + last_rtp_timestamp_ + | 447 timestamp_offset_ + last_rtp_timestamp_ + |
448 (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) * | 448 (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) * |
449 (ctx.feedback_state_.frequency_hz / 1000); | 449 (ctx.feedback_state_.frequency_hz / 1000); |
450 | 450 |
451 rtcp::SenderReport* report = new rtcp::SenderReport(); | 451 rtcp::SenderReport* report = new rtcp::SenderReport(); |
452 report->SetSenderSsrc(ssrc_); | 452 report->From(ssrc_); |
453 report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); | 453 report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); |
454 report->SetRtpTimestamp(rtp_timestamp); | 454 report->WithRtpTimestamp(rtp_timestamp); |
455 report->SetPacketCount(ctx.feedback_state_.packets_sent); | 455 report->WithPacketCount(ctx.feedback_state_.packets_sent); |
456 report->SetOctetCount(ctx.feedback_state_.media_bytes_sent); | 456 report->WithOctetCount(ctx.feedback_state_.media_bytes_sent); |
457 | 457 |
458 for (auto it : report_blocks_) | 458 for (auto it : report_blocks_) |
459 report->AddReportBlock(it.second); | 459 report->WithReportBlock(it.second); |
460 | 460 |
461 report_blocks_.clear(); | 461 report_blocks_.clear(); |
462 | 462 |
463 return std::unique_ptr<rtcp::RtcpPacket>(report); | 463 return std::unique_ptr<rtcp::RtcpPacket>(report); |
464 } | 464 } |
465 | 465 |
466 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES( | 466 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES( |
467 const RtcpContext& ctx) { | 467 const RtcpContext& ctx) { |
468 size_t length_cname = cname_.length(); | 468 size_t length_cname = cname_.length(); |
469 RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE)); | 469 RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE)); |
470 | 470 |
471 rtcp::Sdes* sdes = new rtcp::Sdes(); | 471 rtcp::Sdes* sdes = new rtcp::Sdes(); |
472 sdes->AddCName(ssrc_, cname_); | 472 sdes->WithCName(ssrc_, cname_); |
473 | 473 |
474 for (const auto it : csrc_cnames_) | 474 for (const auto it : csrc_cnames_) |
475 sdes->AddCName(it.first, it.second); | 475 sdes->WithCName(it.first, it.second); |
476 | 476 |
477 return std::unique_ptr<rtcp::RtcpPacket>(sdes); | 477 return std::unique_ptr<rtcp::RtcpPacket>(sdes); |
478 } | 478 } |
479 | 479 |
480 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) { | 480 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) { |
481 rtcp::ReceiverReport* report = new rtcp::ReceiverReport(); | 481 rtcp::ReceiverReport* report = new rtcp::ReceiverReport(); |
482 report->SetSenderSsrc(ssrc_); | 482 report->From(ssrc_); |
483 for (auto it : report_blocks_) | 483 for (auto it : report_blocks_) |
484 report->AddReportBlock(it.second); | 484 report->WithReportBlock(it.second); |
485 | 485 |
486 report_blocks_.clear(); | 486 report_blocks_.clear(); |
487 return std::unique_ptr<rtcp::RtcpPacket>(report); | 487 return std::unique_ptr<rtcp::RtcpPacket>(report); |
488 } | 488 } |
489 | 489 |
490 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) { | 490 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) { |
491 rtcp::Pli* pli = new rtcp::Pli(); | 491 rtcp::Pli* pli = new rtcp::Pli(); |
492 pli->SetSenderSsrc(ssrc_); | 492 pli->From(ssrc_); |
493 pli->SetMediaSsrc(remote_ssrc_); | 493 pli->To(remote_ssrc_); |
494 | 494 |
495 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 495 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
496 "RTCPSender::PLI"); | 496 "RTCPSender::PLI"); |
497 ++packet_type_counter_.pli_packets; | 497 ++packet_type_counter_.pli_packets; |
498 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount", | 498 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount", |
499 ssrc_, packet_type_counter_.pli_packets); | 499 ssrc_, packet_type_counter_.pli_packets); |
500 | 500 |
501 return std::unique_ptr<rtcp::RtcpPacket>(pli); | 501 return std::unique_ptr<rtcp::RtcpPacket>(pli); |
502 } | 502 } |
503 | 503 |
504 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) { | 504 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) { |
505 if (!ctx.repeat_) | 505 if (!ctx.repeat_) |
506 ++sequence_number_fir_; // Do not increase if repetition. | 506 ++sequence_number_fir_; // Do not increase if repetition. |
507 | 507 |
508 rtcp::Fir* fir = new rtcp::Fir(); | 508 rtcp::Fir* fir = new rtcp::Fir(); |
509 fir->SetSenderSsrc(ssrc_); | 509 fir->From(ssrc_); |
510 fir->AddRequestTo(remote_ssrc_, sequence_number_fir_); | 510 fir->WithRequestTo(remote_ssrc_, sequence_number_fir_); |
511 | 511 |
512 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 512 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
513 "RTCPSender::FIR"); | 513 "RTCPSender::FIR"); |
514 ++packet_type_counter_.fir_packets; | 514 ++packet_type_counter_.fir_packets; |
515 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_FIRCount", | 515 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_FIRCount", |
516 ssrc_, packet_type_counter_.fir_packets); | 516 ssrc_, packet_type_counter_.fir_packets); |
517 | 517 |
518 return std::unique_ptr<rtcp::RtcpPacket>(fir); | 518 return std::unique_ptr<rtcp::RtcpPacket>(fir); |
519 } | 519 } |
520 | 520 |
521 /* | 521 /* |
522 0 1 2 3 | 522 0 1 2 3 |
523 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | 523 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
524 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 524 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
525 | First | Number | PictureID | | 525 | First | Number | PictureID | |
526 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 526 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
527 */ | 527 */ |
528 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) { | 528 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) { |
529 rtcp::Sli* sli = new rtcp::Sli(); | 529 rtcp::Sli* sli = new rtcp::Sli(); |
530 sli->SetSenderSsrc(ssrc_); | 530 sli->From(ssrc_); |
531 sli->SetMediaSsrc(remote_ssrc_); | 531 sli->To(remote_ssrc_); |
532 // Crop picture id to 6 least significant bits. | 532 // Crop picture id to 6 least significant bits. |
533 sli->AddPictureId(ctx.picture_id_ & 0x3F); | 533 sli->WithPictureId(ctx.picture_id_ & 0x3F); |
534 | 534 |
535 return std::unique_ptr<rtcp::RtcpPacket>(sli); | 535 return std::unique_ptr<rtcp::RtcpPacket>(sli); |
536 } | 536 } |
537 | 537 |
538 /* | 538 /* |
539 0 1 2 3 | 539 0 1 2 3 |
540 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | 540 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
541 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 541 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
542 | PB |0| Payload Type| Native RPSI bit string | | 542 | PB |0| Payload Type| Native RPSI bit string | |
543 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 543 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
544 | defined per codec ... | Padding (0) | | 544 | defined per codec ... | Padding (0) | |
545 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 545 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
546 */ | 546 */ |
547 /* | 547 /* |
548 * Note: not generic made for VP8 | 548 * Note: not generic made for VP8 |
549 */ | 549 */ |
550 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI( | 550 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI( |
551 const RtcpContext& ctx) { | 551 const RtcpContext& ctx) { |
552 if (ctx.feedback_state_.send_payload_type == 0xFF) | 552 if (ctx.feedback_state_.send_payload_type == 0xFF) |
553 return nullptr; | 553 return nullptr; |
554 | 554 |
555 rtcp::Rpsi* rpsi = new rtcp::Rpsi(); | 555 rtcp::Rpsi* rpsi = new rtcp::Rpsi(); |
556 rpsi->SetSenderSsrc(ssrc_); | 556 rpsi->From(ssrc_); |
557 rpsi->SetMediaSsrc(remote_ssrc_); | 557 rpsi->To(remote_ssrc_); |
558 rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type); | 558 rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type); |
559 rpsi->SetPictureId(ctx.picture_id_); | 559 rpsi->WithPictureId(ctx.picture_id_); |
560 | 560 |
561 return std::unique_ptr<rtcp::RtcpPacket>(rpsi); | 561 return std::unique_ptr<rtcp::RtcpPacket>(rpsi); |
562 } | 562 } |
563 | 563 |
564 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB( | 564 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB( |
565 const RtcpContext& ctx) { | 565 const RtcpContext& ctx) { |
566 rtcp::Remb* remb = new rtcp::Remb(); | 566 rtcp::Remb* remb = new rtcp::Remb(); |
567 remb->SetSenderSsrc(ssrc_); | 567 remb->From(ssrc_); |
568 remb->SetBitrateBps(remb_bitrate_); | 568 for (uint32_t ssrc : remb_ssrcs_) |
569 remb->SetSsrcs(remb_ssrcs_); | 569 remb->AppliesTo(ssrc); |
| 570 remb->WithBitrateBps(remb_bitrate_); |
570 | 571 |
571 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 572 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
572 "RTCPSender::REMB"); | 573 "RTCPSender::REMB"); |
573 | 574 |
574 return std::unique_ptr<rtcp::RtcpPacket>(remb); | 575 return std::unique_ptr<rtcp::RtcpPacket>(remb); |
575 } | 576 } |
576 | 577 |
577 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) { | 578 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) { |
578 rtc::CritScope lock(&critical_section_rtcp_sender_); | 579 rtc::CritScope lock(&critical_section_rtcp_sender_); |
579 tmmbr_send_bps_ = target_bitrate; | 580 tmmbr_send_bps_ = target_bitrate; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
618 // Did not enter bounding set, no meaning to send this request. | 619 // Did not enter bounding set, no meaning to send this request. |
619 return nullptr; | 620 return nullptr; |
620 } | 621 } |
621 } | 622 } |
622 } | 623 } |
623 | 624 |
624 if (!tmmbr_send_bps_) | 625 if (!tmmbr_send_bps_) |
625 return nullptr; | 626 return nullptr; |
626 | 627 |
627 rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr(); | 628 rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr(); |
628 tmmbr->SetSenderSsrc(ssrc_); | 629 tmmbr->From(ssrc_); |
629 rtcp::TmmbItem request; | 630 rtcp::TmmbItem request; |
630 request.set_ssrc(remote_ssrc_); | 631 request.set_ssrc(remote_ssrc_); |
631 request.set_bitrate_bps(tmmbr_send_bps_); | 632 request.set_bitrate_bps(tmmbr_send_bps_); |
632 request.set_packet_overhead(packet_oh_send_); | 633 request.set_packet_overhead(packet_oh_send_); |
633 tmmbr->AddTmmbr(request); | 634 tmmbr->WithTmmbr(request); |
634 | 635 |
635 return std::unique_ptr<rtcp::RtcpPacket>(tmmbr); | 636 return std::unique_ptr<rtcp::RtcpPacket>(tmmbr); |
636 } | 637 } |
637 | 638 |
638 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN( | 639 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN( |
639 const RtcpContext& ctx) { | 640 const RtcpContext& ctx) { |
640 rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn(); | 641 rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn(); |
641 tmmbn->SetSenderSsrc(ssrc_); | 642 tmmbn->From(ssrc_); |
642 for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { | 643 for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { |
643 if (tmmbr.bitrate_bps() > 0) { | 644 if (tmmbr.bitrate_bps() > 0) { |
644 tmmbn->AddTmmbr(tmmbr); | 645 tmmbn->WithTmmbr(tmmbr); |
645 } | 646 } |
646 } | 647 } |
647 | 648 |
648 return std::unique_ptr<rtcp::RtcpPacket>(tmmbn); | 649 return std::unique_ptr<rtcp::RtcpPacket>(tmmbn); |
649 } | 650 } |
650 | 651 |
651 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) { | 652 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) { |
652 rtcp::App* app = new rtcp::App(); | 653 rtcp::App* app = new rtcp::App(); |
653 app->SetSsrc(ssrc_); | 654 app->From(ssrc_); |
654 app->SetSubType(app_sub_type_); | 655 app->WithSubType(app_sub_type_); |
655 app->SetName(app_name_); | 656 app->WithName(app_name_); |
656 app->SetData(app_data_.get(), app_length_); | 657 app->WithData(app_data_.get(), app_length_); |
657 | 658 |
658 return std::unique_ptr<rtcp::RtcpPacket>(app); | 659 return std::unique_ptr<rtcp::RtcpPacket>(app); |
659 } | 660 } |
660 | 661 |
661 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK( | 662 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK( |
662 const RtcpContext& ctx) { | 663 const RtcpContext& ctx) { |
663 rtcp::Nack* nack = new rtcp::Nack(); | 664 rtcp::Nack* nack = new rtcp::Nack(); |
664 nack->SetSenderSsrc(ssrc_); | 665 nack->From(ssrc_); |
665 nack->SetMediaSsrc(remote_ssrc_); | 666 nack->To(remote_ssrc_); |
666 nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_); | 667 nack->WithList(ctx.nack_list_, ctx.nack_size_); |
667 | 668 |
668 // Report stats. | 669 // Report stats. |
669 NACKStringBuilder stringBuilder; | 670 NACKStringBuilder stringBuilder; |
670 for (int idx = 0; idx < ctx.nack_size_; ++idx) { | 671 for (int idx = 0; idx < ctx.nack_size_; ++idx) { |
671 stringBuilder.PushNACK(ctx.nack_list_[idx]); | 672 stringBuilder.PushNACK(ctx.nack_list_[idx]); |
672 nack_stats_.ReportRequest(ctx.nack_list_[idx]); | 673 nack_stats_.ReportRequest(ctx.nack_list_[idx]); |
673 } | 674 } |
674 packet_type_counter_.nack_requests = nack_stats_.requests(); | 675 packet_type_counter_.nack_requests = nack_stats_.requests(); |
675 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); | 676 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); |
676 | 677 |
677 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 678 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
678 "RTCPSender::NACK", "nacks", | 679 "RTCPSender::NACK", "nacks", |
679 TRACE_STR_COPY(stringBuilder.GetResult().c_str())); | 680 TRACE_STR_COPY(stringBuilder.GetResult().c_str())); |
680 ++packet_type_counter_.nack_packets; | 681 ++packet_type_counter_.nack_packets; |
681 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount", | 682 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount", |
682 ssrc_, packet_type_counter_.nack_packets); | 683 ssrc_, packet_type_counter_.nack_packets); |
683 | 684 |
684 return std::unique_ptr<rtcp::RtcpPacket>(nack); | 685 return std::unique_ptr<rtcp::RtcpPacket>(nack); |
685 } | 686 } |
686 | 687 |
687 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) { | 688 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) { |
688 rtcp::Bye* bye = new rtcp::Bye(); | 689 rtcp::Bye* bye = new rtcp::Bye(); |
689 bye->SetSenderSsrc(ssrc_); | 690 bye->From(ssrc_); |
690 bye->SetCsrcs(csrcs_); | 691 for (uint32_t csrc : csrcs_) |
| 692 bye->WithCsrc(csrc); |
691 | 693 |
692 return std::unique_ptr<rtcp::RtcpPacket>(bye); | 694 return std::unique_ptr<rtcp::RtcpPacket>(bye); |
693 } | 695 } |
694 | 696 |
695 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime( | 697 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime( |
696 const RtcpContext& ctx) { | 698 const RtcpContext& ctx) { |
697 | 699 |
698 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 700 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
699 xr->SetSenderSsrc(ssrc_); | 701 xr->From(ssrc_); |
700 | 702 |
701 rtcp::Rrtr rrtr; | 703 rtcp::Rrtr rrtr; |
702 rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); | 704 rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); |
703 | 705 |
704 xr->AddRrtr(rrtr); | 706 xr->WithRrtr(rrtr); |
705 | 707 |
706 // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP? | 708 // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP? |
707 | 709 |
708 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 710 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
709 } | 711 } |
710 | 712 |
711 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr( | 713 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr( |
712 const RtcpContext& ctx) { | 714 const RtcpContext& ctx) { |
713 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 715 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
714 xr->SetSenderSsrc(ssrc_); | 716 xr->From(ssrc_); |
715 | 717 |
716 rtcp::Dlrr dlrr; | 718 rtcp::Dlrr dlrr; |
717 const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr; | 719 const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr; |
718 dlrr.AddDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); | 720 dlrr.WithDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); |
719 | 721 |
720 xr->AddDlrr(dlrr); | 722 xr->WithDlrr(dlrr); |
721 | 723 |
722 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 724 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
723 } | 725 } |
724 | 726 |
725 // TODO(sprang): Add a unit test for this, or remove if the code isn't used. | 727 // TODO(sprang): Add a unit test for this, or remove if the code isn't used. |
726 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric( | 728 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric( |
727 const RtcpContext& context) { | 729 const RtcpContext& context) { |
728 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 730 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
729 xr->SetSenderSsrc(ssrc_); | 731 xr->From(ssrc_); |
730 | 732 |
731 rtcp::VoipMetric voip; | 733 rtcp::VoipMetric voip; |
732 voip.SetMediaSsrc(remote_ssrc_); | 734 voip.To(remote_ssrc_); |
733 voip.SetVoipMetric(xr_voip_metric_); | 735 voip.WithVoipMetric(xr_voip_metric_); |
734 | 736 |
735 xr->AddVoipMetric(voip); | 737 xr->WithVoipMetric(voip); |
736 | 738 |
737 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 739 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
738 } | 740 } |
739 | 741 |
740 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state, | 742 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state, |
741 RTCPPacketType packetType, | 743 RTCPPacketType packetType, |
742 int32_t nack_size, | 744 int32_t nack_size, |
743 const uint16_t* nack_list, | 745 const uint16_t* nack_list, |
744 bool repeat, | 746 bool repeat, |
745 uint64_t pictureID) { | 747 uint64_t pictureID) { |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
896 RtcpStatistics stats; | 898 RtcpStatistics stats; |
897 if (!statistician->GetStatistics(&stats, true)) | 899 if (!statistician->GetStatistics(&stats, true)) |
898 return false; | 900 return false; |
899 | 901 |
900 if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) { | 902 if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) { |
901 LOG(LS_WARNING) << "Too many report blocks."; | 903 LOG(LS_WARNING) << "Too many report blocks."; |
902 return false; | 904 return false; |
903 } | 905 } |
904 RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end()); | 906 RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end()); |
905 rtcp::ReportBlock* block = &report_blocks_[ssrc]; | 907 rtcp::ReportBlock* block = &report_blocks_[ssrc]; |
906 block->SetMediaSsrc(ssrc); | 908 block->To(ssrc); |
907 block->SetFractionLost(stats.fraction_lost); | 909 block->WithFractionLost(stats.fraction_lost); |
908 if (!block->SetCumulativeLost(stats.cumulative_lost)) { | 910 if (!block->WithCumulativeLost(stats.cumulative_lost)) { |
909 report_blocks_.erase(ssrc); | 911 report_blocks_.erase(ssrc); |
910 LOG(LS_WARNING) << "Cumulative lost is oversized."; | 912 LOG(LS_WARNING) << "Cumulative lost is oversized."; |
911 return false; | 913 return false; |
912 } | 914 } |
913 block->SetExtHighestSeqNum(stats.extended_max_sequence_number); | 915 block->WithExtHighestSeqNum(stats.extended_max_sequence_number); |
914 block->SetJitter(stats.jitter); | 916 block->WithJitter(stats.jitter); |
915 block->SetLastSr(feedback_state.remote_sr); | 917 block->WithLastSr(feedback_state.remote_sr); |
916 | 918 |
917 // TODO(sprang): Do we really need separate time stamps for each report? | 919 // TODO(sprang): Do we really need separate time stamps for each report? |
918 // Get our NTP as late as possible to avoid a race. | 920 // Get our NTP as late as possible to avoid a race. |
919 uint32_t ntp_secs; | 921 uint32_t ntp_secs; |
920 uint32_t ntp_frac; | 922 uint32_t ntp_frac; |
921 clock_->CurrentNtp(ntp_secs, ntp_frac); | 923 clock_->CurrentNtp(ntp_secs, ntp_frac); |
922 | 924 |
923 // Delay since last received report. | 925 // Delay since last received report. |
924 if ((feedback_state.last_rr_ntp_secs != 0) || | 926 if ((feedback_state.last_rr_ntp_secs != 0) || |
925 (feedback_state.last_rr_ntp_frac != 0)) { | 927 (feedback_state.last_rr_ntp_frac != 0)) { |
926 // Get the 16 lowest bits of seconds and the 16 highest bits of fractions. | 928 // Get the 16 lowest bits of seconds and the 16 highest bits of fractions. |
927 uint32_t now = ntp_secs & 0x0000FFFF; | 929 uint32_t now = ntp_secs & 0x0000FFFF; |
928 now <<= 16; | 930 now <<= 16; |
929 now += (ntp_frac & 0xffff0000) >> 16; | 931 now += (ntp_frac & 0xffff0000) >> 16; |
930 | 932 |
931 uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF; | 933 uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF; |
932 receiveTime <<= 16; | 934 receiveTime <<= 16; |
933 receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16; | 935 receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16; |
934 | 936 |
935 block->SetDelayLastSr(now - receiveTime); | 937 block->WithDelayLastSr(now - receiveTime); |
936 } | 938 } |
937 return true; | 939 return true; |
938 } | 940 } |
939 | 941 |
940 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { | 942 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { |
941 RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize)); | 943 RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize)); |
942 rtc::CritScope lock(&critical_section_rtcp_sender_); | 944 rtc::CritScope lock(&critical_section_rtcp_sender_); |
943 csrcs_ = csrcs; | 945 csrcs_ = csrcs; |
944 } | 946 } |
945 | 947 |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1042 // but we can't because of an incorrect warning (C4822) in MVS 2013. | 1044 // but we can't because of an incorrect warning (C4822) in MVS 2013. |
1043 } sender(transport_, event_log_); | 1045 } sender(transport_, event_log_); |
1044 | 1046 |
1045 RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE)); | 1047 RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE)); |
1046 uint8_t buffer[IP_PACKET_SIZE]; | 1048 uint8_t buffer[IP_PACKET_SIZE]; |
1047 return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) && | 1049 return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) && |
1048 !sender.send_failure_; | 1050 !sender.send_failure_; |
1049 } | 1051 } |
1050 | 1052 |
1051 } // namespace webrtc | 1053 } // namespace webrtc |
OLD | NEW |