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->From(ssrc_); | 452 report->SetSenderSsrc(ssrc_); |
453 report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); | 453 report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); |
454 report->WithRtpTimestamp(rtp_timestamp); | 454 report->SetRtpTimestamp(rtp_timestamp); |
455 report->WithPacketCount(ctx.feedback_state_.packets_sent); | 455 report->SetPacketCount(ctx.feedback_state_.packets_sent); |
456 report->WithOctetCount(ctx.feedback_state_.media_bytes_sent); | 456 report->SetOctetCount(ctx.feedback_state_.media_bytes_sent); |
457 | 457 |
458 for (auto it : report_blocks_) | 458 for (auto it : report_blocks_) |
459 report->WithReportBlock(it.second); | 459 report->AddReportBlock(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->WithCName(ssrc_, cname_); | 472 sdes->AddCName(ssrc_, cname_); |
473 | 473 |
474 for (const auto it : csrc_cnames_) | 474 for (const auto it : csrc_cnames_) |
475 sdes->WithCName(it.first, it.second); | 475 sdes->AddCName(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->From(ssrc_); | 482 report->SetSenderSsrc(ssrc_); |
483 for (auto it : report_blocks_) | 483 for (auto it : report_blocks_) |
484 report->WithReportBlock(it.second); | 484 report->AddReportBlock(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->From(ssrc_); | 492 pli->SetSenderSsrc(ssrc_); |
493 pli->To(remote_ssrc_); | 493 pli->SetMediaSsrc(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->From(ssrc_); | 509 fir->SetSenderSsrc(ssrc_); |
510 fir->WithRequestTo(remote_ssrc_, sequence_number_fir_); | 510 fir->AddRequestTo(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->From(ssrc_); | 530 sli->SetSenderSsrc(ssrc_); |
531 sli->To(remote_ssrc_); | 531 sli->SetMediaSsrc(remote_ssrc_); |
532 // Crop picture id to 6 least significant bits. | 532 // Crop picture id to 6 least significant bits. |
533 sli->WithPictureId(ctx.picture_id_ & 0x3F); | 533 sli->AddPictureId(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->From(ssrc_); | 556 rpsi->SetSenderSsrc(ssrc_); |
557 rpsi->To(remote_ssrc_); | 557 rpsi->SetMediaSsrc(remote_ssrc_); |
558 rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type); | 558 rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type); |
559 rpsi->WithPictureId(ctx.picture_id_); | 559 rpsi->SetPictureId(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->From(ssrc_); | 567 remb->SetSenderSsrc(ssrc_); |
568 for (uint32_t ssrc : remb_ssrcs_) | 568 remb->SetBitrateBps(remb_bitrate_); |
569 remb->AppliesTo(ssrc); | 569 remb->SetSsrcs(remb_ssrcs_); |
570 remb->WithBitrateBps(remb_bitrate_); | |
571 | 570 |
572 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 571 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
573 "RTCPSender::REMB"); | 572 "RTCPSender::REMB"); |
574 | 573 |
575 return std::unique_ptr<rtcp::RtcpPacket>(remb); | 574 return std::unique_ptr<rtcp::RtcpPacket>(remb); |
576 } | 575 } |
577 | 576 |
578 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) { | 577 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) { |
579 rtc::CritScope lock(&critical_section_rtcp_sender_); | 578 rtc::CritScope lock(&critical_section_rtcp_sender_); |
580 tmmbr_send_bps_ = target_bitrate; | 579 tmmbr_send_bps_ = target_bitrate; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
619 // Did not enter bounding set, no meaning to send this request. | 618 // Did not enter bounding set, no meaning to send this request. |
620 return nullptr; | 619 return nullptr; |
621 } | 620 } |
622 } | 621 } |
623 } | 622 } |
624 | 623 |
625 if (!tmmbr_send_bps_) | 624 if (!tmmbr_send_bps_) |
626 return nullptr; | 625 return nullptr; |
627 | 626 |
628 rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr(); | 627 rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr(); |
629 tmmbr->From(ssrc_); | 628 tmmbr->SetSenderSsrc(ssrc_); |
630 rtcp::TmmbItem request; | 629 rtcp::TmmbItem request; |
631 request.set_ssrc(remote_ssrc_); | 630 request.set_ssrc(remote_ssrc_); |
632 request.set_bitrate_bps(tmmbr_send_bps_); | 631 request.set_bitrate_bps(tmmbr_send_bps_); |
633 request.set_packet_overhead(packet_oh_send_); | 632 request.set_packet_overhead(packet_oh_send_); |
634 tmmbr->WithTmmbr(request); | 633 tmmbr->AddTmmbr(request); |
635 | 634 |
636 return std::unique_ptr<rtcp::RtcpPacket>(tmmbr); | 635 return std::unique_ptr<rtcp::RtcpPacket>(tmmbr); |
637 } | 636 } |
638 | 637 |
639 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN( | 638 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN( |
640 const RtcpContext& ctx) { | 639 const RtcpContext& ctx) { |
641 rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn(); | 640 rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn(); |
642 tmmbn->From(ssrc_); | 641 tmmbn->SetSenderSsrc(ssrc_); |
643 for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { | 642 for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { |
644 if (tmmbr.bitrate_bps() > 0) { | 643 if (tmmbr.bitrate_bps() > 0) { |
645 tmmbn->WithTmmbr(tmmbr); | 644 tmmbn->AddTmmbr(tmmbr); |
646 } | 645 } |
647 } | 646 } |
648 | 647 |
649 return std::unique_ptr<rtcp::RtcpPacket>(tmmbn); | 648 return std::unique_ptr<rtcp::RtcpPacket>(tmmbn); |
650 } | 649 } |
651 | 650 |
652 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) { | 651 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) { |
653 rtcp::App* app = new rtcp::App(); | 652 rtcp::App* app = new rtcp::App(); |
654 app->From(ssrc_); | 653 app->SetSsrc(ssrc_); |
655 app->WithSubType(app_sub_type_); | 654 app->SetSubType(app_sub_type_); |
656 app->WithName(app_name_); | 655 app->SetName(app_name_); |
657 app->WithData(app_data_.get(), app_length_); | 656 app->SetData(app_data_.get(), app_length_); |
658 | 657 |
659 return std::unique_ptr<rtcp::RtcpPacket>(app); | 658 return std::unique_ptr<rtcp::RtcpPacket>(app); |
660 } | 659 } |
661 | 660 |
662 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK( | 661 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK( |
663 const RtcpContext& ctx) { | 662 const RtcpContext& ctx) { |
664 rtcp::Nack* nack = new rtcp::Nack(); | 663 rtcp::Nack* nack = new rtcp::Nack(); |
665 nack->From(ssrc_); | 664 nack->SetSenderSsrc(ssrc_); |
666 nack->To(remote_ssrc_); | 665 nack->SetMediaSsrc(remote_ssrc_); |
667 nack->WithList(ctx.nack_list_, ctx.nack_size_); | 666 nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_); |
668 | 667 |
669 // Report stats. | 668 // Report stats. |
670 NACKStringBuilder stringBuilder; | 669 NACKStringBuilder stringBuilder; |
671 for (int idx = 0; idx < ctx.nack_size_; ++idx) { | 670 for (int idx = 0; idx < ctx.nack_size_; ++idx) { |
672 stringBuilder.PushNACK(ctx.nack_list_[idx]); | 671 stringBuilder.PushNACK(ctx.nack_list_[idx]); |
673 nack_stats_.ReportRequest(ctx.nack_list_[idx]); | 672 nack_stats_.ReportRequest(ctx.nack_list_[idx]); |
674 } | 673 } |
675 packet_type_counter_.nack_requests = nack_stats_.requests(); | 674 packet_type_counter_.nack_requests = nack_stats_.requests(); |
676 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); | 675 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); |
677 | 676 |
678 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 677 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
679 "RTCPSender::NACK", "nacks", | 678 "RTCPSender::NACK", "nacks", |
680 TRACE_STR_COPY(stringBuilder.GetResult().c_str())); | 679 TRACE_STR_COPY(stringBuilder.GetResult().c_str())); |
681 ++packet_type_counter_.nack_packets; | 680 ++packet_type_counter_.nack_packets; |
682 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount", | 681 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount", |
683 ssrc_, packet_type_counter_.nack_packets); | 682 ssrc_, packet_type_counter_.nack_packets); |
684 | 683 |
685 return std::unique_ptr<rtcp::RtcpPacket>(nack); | 684 return std::unique_ptr<rtcp::RtcpPacket>(nack); |
686 } | 685 } |
687 | 686 |
688 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) { | 687 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) { |
689 rtcp::Bye* bye = new rtcp::Bye(); | 688 rtcp::Bye* bye = new rtcp::Bye(); |
690 bye->From(ssrc_); | 689 bye->SetSenderSsrc(ssrc_); |
691 for (uint32_t csrc : csrcs_) | 690 bye->SetCsrcs(csrcs_); |
692 bye->WithCsrc(csrc); | |
693 | 691 |
694 return std::unique_ptr<rtcp::RtcpPacket>(bye); | 692 return std::unique_ptr<rtcp::RtcpPacket>(bye); |
695 } | 693 } |
696 | 694 |
697 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime( | 695 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime( |
698 const RtcpContext& ctx) { | 696 const RtcpContext& ctx) { |
699 | 697 |
700 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 698 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
701 xr->From(ssrc_); | 699 xr->SetSenderSsrc(ssrc_); |
702 | 700 |
703 rtcp::Rrtr rrtr; | 701 rtcp::Rrtr rrtr; |
704 rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); | 702 rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); |
705 | 703 |
706 xr->WithRrtr(rrtr); | 704 xr->AddRrtr(rrtr); |
707 | 705 |
708 // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP? | 706 // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP? |
709 | 707 |
710 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 708 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
711 } | 709 } |
712 | 710 |
713 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr( | 711 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr( |
714 const RtcpContext& ctx) { | 712 const RtcpContext& ctx) { |
715 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 713 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
716 xr->From(ssrc_); | 714 xr->SetSenderSsrc(ssrc_); |
717 | 715 |
718 rtcp::Dlrr dlrr; | 716 rtcp::Dlrr dlrr; |
719 const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr; | 717 const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr; |
720 dlrr.WithDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); | 718 dlrr.AddDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); |
721 | 719 |
722 xr->WithDlrr(dlrr); | 720 xr->AddDlrr(dlrr); |
723 | 721 |
724 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 722 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
725 } | 723 } |
726 | 724 |
727 // TODO(sprang): Add a unit test for this, or remove if the code isn't used. | 725 // TODO(sprang): Add a unit test for this, or remove if the code isn't used. |
728 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric( | 726 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric( |
729 const RtcpContext& context) { | 727 const RtcpContext& context) { |
730 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); | 728 rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); |
731 xr->From(ssrc_); | 729 xr->SetSenderSsrc(ssrc_); |
732 | 730 |
733 rtcp::VoipMetric voip; | 731 rtcp::VoipMetric voip; |
734 voip.To(remote_ssrc_); | 732 voip.SetMediaSsrc(remote_ssrc_); |
735 voip.WithVoipMetric(xr_voip_metric_); | 733 voip.SetVoipMetric(xr_voip_metric_); |
736 | 734 |
737 xr->WithVoipMetric(voip); | 735 xr->AddVoipMetric(voip); |
738 | 736 |
739 return std::unique_ptr<rtcp::RtcpPacket>(xr); | 737 return std::unique_ptr<rtcp::RtcpPacket>(xr); |
740 } | 738 } |
741 | 739 |
742 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state, | 740 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state, |
743 RTCPPacketType packetType, | 741 RTCPPacketType packetType, |
744 int32_t nack_size, | 742 int32_t nack_size, |
745 const uint16_t* nack_list, | 743 const uint16_t* nack_list, |
746 bool repeat, | 744 bool repeat, |
747 uint64_t pictureID) { | 745 uint64_t pictureID) { |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
898 RtcpStatistics stats; | 896 RtcpStatistics stats; |
899 if (!statistician->GetStatistics(&stats, true)) | 897 if (!statistician->GetStatistics(&stats, true)) |
900 return false; | 898 return false; |
901 | 899 |
902 if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) { | 900 if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) { |
903 LOG(LS_WARNING) << "Too many report blocks."; | 901 LOG(LS_WARNING) << "Too many report blocks."; |
904 return false; | 902 return false; |
905 } | 903 } |
906 RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end()); | 904 RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end()); |
907 rtcp::ReportBlock* block = &report_blocks_[ssrc]; | 905 rtcp::ReportBlock* block = &report_blocks_[ssrc]; |
908 block->To(ssrc); | 906 block->SetMediaSsrc(ssrc); |
909 block->WithFractionLost(stats.fraction_lost); | 907 block->SetFractionLost(stats.fraction_lost); |
910 if (!block->WithCumulativeLost(stats.cumulative_lost)) { | 908 if (!block->SetCumulativeLost(stats.cumulative_lost)) { |
911 report_blocks_.erase(ssrc); | 909 report_blocks_.erase(ssrc); |
912 LOG(LS_WARNING) << "Cumulative lost is oversized."; | 910 LOG(LS_WARNING) << "Cumulative lost is oversized."; |
913 return false; | 911 return false; |
914 } | 912 } |
915 block->WithExtHighestSeqNum(stats.extended_max_sequence_number); | 913 block->SetExtHighestSeqNum(stats.extended_max_sequence_number); |
916 block->WithJitter(stats.jitter); | 914 block->SetJitter(stats.jitter); |
917 block->WithLastSr(feedback_state.remote_sr); | 915 block->SetLastSr(feedback_state.remote_sr); |
918 | 916 |
919 // TODO(sprang): Do we really need separate time stamps for each report? | 917 // TODO(sprang): Do we really need separate time stamps for each report? |
920 // Get our NTP as late as possible to avoid a race. | 918 // Get our NTP as late as possible to avoid a race. |
921 uint32_t ntp_secs; | 919 uint32_t ntp_secs; |
922 uint32_t ntp_frac; | 920 uint32_t ntp_frac; |
923 clock_->CurrentNtp(ntp_secs, ntp_frac); | 921 clock_->CurrentNtp(ntp_secs, ntp_frac); |
924 | 922 |
925 // Delay since last received report. | 923 // Delay since last received report. |
926 if ((feedback_state.last_rr_ntp_secs != 0) || | 924 if ((feedback_state.last_rr_ntp_secs != 0) || |
927 (feedback_state.last_rr_ntp_frac != 0)) { | 925 (feedback_state.last_rr_ntp_frac != 0)) { |
928 // Get the 16 lowest bits of seconds and the 16 highest bits of fractions. | 926 // Get the 16 lowest bits of seconds and the 16 highest bits of fractions. |
929 uint32_t now = ntp_secs & 0x0000FFFF; | 927 uint32_t now = ntp_secs & 0x0000FFFF; |
930 now <<= 16; | 928 now <<= 16; |
931 now += (ntp_frac & 0xffff0000) >> 16; | 929 now += (ntp_frac & 0xffff0000) >> 16; |
932 | 930 |
933 uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF; | 931 uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF; |
934 receiveTime <<= 16; | 932 receiveTime <<= 16; |
935 receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16; | 933 receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16; |
936 | 934 |
937 block->WithDelayLastSr(now - receiveTime); | 935 block->SetDelayLastSr(now - receiveTime); |
938 } | 936 } |
939 return true; | 937 return true; |
940 } | 938 } |
941 | 939 |
942 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { | 940 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { |
943 RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize)); | 941 RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize)); |
944 rtc::CritScope lock(&critical_section_rtcp_sender_); | 942 rtc::CritScope lock(&critical_section_rtcp_sender_); |
945 csrcs_ = csrcs; | 943 csrcs_ = csrcs; |
946 } | 944 } |
947 | 945 |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1044 // but we can't because of an incorrect warning (C4822) in MVS 2013. | 1042 // but we can't because of an incorrect warning (C4822) in MVS 2013. |
1045 } sender(transport_, event_log_); | 1043 } sender(transport_, event_log_); |
1046 | 1044 |
1047 RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE)); | 1045 RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE)); |
1048 uint8_t buffer[IP_PACKET_SIZE]; | 1046 uint8_t buffer[IP_PACKET_SIZE]; |
1049 return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) && | 1047 return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) && |
1050 !sender.send_failure_; | 1048 !sender.send_failure_; |
1051 } | 1049 } |
1052 | 1050 |
1053 } // namespace webrtc | 1051 } // namespace webrtc |
OLD | NEW |