From 20e77c7b8a9f19942ef3c3c4f1fa3888b2cd54ea Mon Sep 17 00:00:00 2001 From: danilchap Date: Tue, 27 Sep 2016 01:37:42 -0700 Subject: [PATCH] Unify rtcp packet setters Renamed setters in rtcp classes from WithField to SetField from WithItem to AddItem or SetItems from From to SetSenderSsrc from To to SetMediaSsrc Some redundant or unsued setters removed. Pass-by-const& replaced with pass-by-value when appropriate. BUG=webrtc:5260 Review-Url: https://codereview.webrtc.org/2348623003 Cr-Commit-Position: refs/heads/master@{#14393} --- webrtc/call/rtc_event_log_unittest.cc | 13 +- webrtc/modules/pacing/packet_router.cc | 2 +- .../remote_estimator_proxy.cc | 10 +- .../remote_estimator_proxy_unittest.cc | 18 +- .../transport_feedback_adapter_unittest.cc | 50 +-- webrtc/modules/rtp_rtcp/source/rtcp_packet.h | 12 +- .../rtp_rtcp/source/rtcp_packet/app.cc | 4 +- .../modules/rtp_rtcp/source/rtcp_packet/app.h | 8 +- .../source/rtcp_packet/app_unittest.cc | 14 +- .../rtp_rtcp/source/rtcp_packet/bye.cc | 14 +- .../modules/rtp_rtcp/source/rtcp_packet/bye.h | 6 +- .../source/rtcp_packet/bye_unittest.cc | 36 +- .../rtcp_packet/compound_packet_unittest.cc | 22 +- .../rtp_rtcp/source/rtcp_packet/dlrr.cc | 10 +- .../rtp_rtcp/source/rtcp_packet/dlrr.h | 4 +- .../source/rtcp_packet/dlrr_unittest.cc | 8 +- .../rtcp_packet/extended_jitter_report.cc | 10 +- .../rtcp_packet/extended_jitter_report.h | 8 +- .../extended_jitter_report_unittest.cc | 22 +- .../source/rtcp_packet/extended_reports.cc | 6 +- .../source/rtcp_packet/extended_reports.h | 8 +- .../rtcp_packet/extended_reports_unittest.cc | 76 ++-- .../modules/rtp_rtcp/source/rtcp_packet/fir.h | 6 +- .../source/rtcp_packet/fir_unittest.cc | 10 +- .../rtp_rtcp/source/rtcp_packet/nack.cc | 2 +- .../rtp_rtcp/source/rtcp_packet/nack.h | 4 +- .../source/rtcp_packet/nack_unittest.cc | 30 +- .../source/rtcp_packet/pli_unittest.cc | 4 +- .../rtp_rtcp/source/rtcp_packet/psfb.h | 4 +- .../rapid_resync_request_unittest.cc | 4 +- .../source/rtcp_packet/receiver_report.cc | 2 +- .../source/rtcp_packet/receiver_report.h | 4 +- .../rtcp_packet/receiver_report_unittest.cc | 40 +- .../rtp_rtcp/source/rtcp_packet/remb.cc | 18 +- .../rtp_rtcp/source/rtcp_packet/remb.h | 9 +- .../source/rtcp_packet/remb_unittest.cc | 39 +- .../source/rtcp_packet/report_block.cc | 2 +- .../source/rtcp_packet/report_block.h | 14 +- .../rtcp_packet/report_block_unittest.cc | 18 +- .../rtp_rtcp/source/rtcp_packet/rpsi.cc | 4 +- .../rtp_rtcp/source/rtcp_packet/rpsi.h | 4 +- .../source/rtcp_packet/rpsi_unittest.cc | 34 +- .../rtp_rtcp/source/rtcp_packet/rrtr.h | 2 +- .../source/rtcp_packet/rrtr_unittest.cc | 2 +- .../rtp_rtcp/source/rtcp_packet/rtpfb.h | 4 +- .../rtp_rtcp/source/rtcp_packet/sdes.cc | 6 +- .../rtp_rtcp/source/rtcp_packet/sdes.h | 2 +- .../source/rtcp_packet/sdes_unittest.cc | 24 +- .../source/rtcp_packet/sender_report.cc | 2 +- .../source/rtcp_packet/sender_report.h | 12 +- .../rtcp_packet/sender_report_unittest.cc | 36 +- .../modules/rtp_rtcp/source/rtcp_packet/sli.h | 12 +- .../source/rtcp_packet/sli_unittest.cc | 12 +- .../rtp_rtcp/source/rtcp_packet/tmmbn.cc | 2 +- .../rtp_rtcp/source/rtcp_packet/tmmbn.h | 7 +- .../source/rtcp_packet/tmmbn_unittest.cc | 12 +- .../rtp_rtcp/source/rtcp_packet/tmmbr.cc | 2 +- .../rtp_rtcp/source/rtcp_packet/tmmbr.h | 4 +- .../source/rtcp_packet/tmmbr_unittest.cc | 10 +- .../source/rtcp_packet/transport_feedback.cc | 10 +- .../source/rtcp_packet/transport_feedback.h | 31 +- .../transport_feedback_unittest.cc | 60 +-- .../rtp_rtcp/source/rtcp_packet/voip_metric.h | 4 +- .../rtcp_packet/voip_metric_unittest.cc | 4 +- .../rtp_rtcp/source/rtcp_packet_unittest.cc | 4 +- .../rtp_rtcp/source/rtcp_receiver_unittest.cc | 344 +++++++++--------- webrtc/modules/rtp_rtcp/source/rtcp_sender.cc | 110 +++--- .../rtp_rtcp/source/rtp_rtcp_impl_unittest.cc | 6 +- webrtc/video/end_to_end_tests.cc | 6 +- 69 files changed, 664 insertions(+), 679 deletions(-) diff --git a/webrtc/call/rtc_event_log_unittest.cc b/webrtc/call/rtc_event_log_unittest.cc index 34e993cf5c..8e92c7e37d 100644 --- a/webrtc/call/rtc_event_log_unittest.cc +++ b/webrtc/call/rtc_event_log_unittest.cc @@ -139,15 +139,14 @@ RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions, rtc::Buffer GenerateRtcpPacket(Random* prng) { rtcp::ReportBlock report_block; - report_block.To(prng->Rand()); // Remote SSRC. - report_block.WithFractionLost(prng->Rand(50)); + report_block.SetMediaSsrc(prng->Rand()); // Remote SSRC. + report_block.SetFractionLost(prng->Rand(50)); rtcp::SenderReport sender_report; - sender_report.From(prng->Rand()); // Sender SSRC. - sender_report.WithNtp( - NtpTime(prng->Rand(), prng->Rand())); - sender_report.WithPacketCount(prng->Rand()); - sender_report.WithReportBlock(report_block); + sender_report.SetSenderSsrc(prng->Rand()); + sender_report.SetNtp(NtpTime(prng->Rand(), prng->Rand())); + sender_report.SetPacketCount(prng->Rand()); + sender_report.AddReportBlock(report_block); return sender_report.Build(); } diff --git a/webrtc/modules/pacing/packet_router.cc b/webrtc/modules/pacing/packet_router.cc index be45615ca5..de8c2cee5a 100644 --- a/webrtc/modules/pacing/packet_router.cc +++ b/webrtc/modules/pacing/packet_router.cc @@ -99,7 +99,7 @@ uint16_t PacketRouter::AllocateSequenceNumber() { bool PacketRouter::SendFeedback(rtcp::TransportFeedback* packet) { rtc::CritScope cs(&modules_crit_); for (auto* rtp_module : rtp_modules_) { - packet->WithPacketSenderSsrc(rtp_module->SSRC()); + packet->SetSenderSsrc(rtp_module->SSRC()); if (rtp_module->SendFeedbackPacket(*packet)) return true; } diff --git a/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc b/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc index ec37c88050..b08b30a8ce 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc +++ b/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc @@ -152,15 +152,15 @@ bool RemoteEstimatorProxy::BuildFeedbackPacket( // TODO(sprang): Measure receive times in microseconds and remove the // conversions below. const int64_t first_sequence = it->first; - feedback_packet->WithMediaSourceSsrc(media_ssrc_); + feedback_packet->SetMediaSsrc(media_ssrc_); // Base sequence is the expected next (window_start_seq_). This is known, but // we might not have actually received it, so the base time shall be the time // of the first received packet in the feedback. - feedback_packet->WithBase(static_cast(window_start_seq_ & 0xFFFF), - it->second * 1000); - feedback_packet->WithFeedbackSequenceNumber(feedback_sequence_++); + feedback_packet->SetBase(static_cast(window_start_seq_ & 0xFFFF), + it->second * 1000); + feedback_packet->SetFeedbackSequenceNumber(feedback_sequence_++); for (; it != packet_arrival_times_.end(); ++it) { - if (!feedback_packet->WithReceivedPacket( + if (!feedback_packet->AddReceivedPacket( static_cast(it->first & 0xFFFF), it->second * 1000)) { // If we can't even add the first seq to the feedback packet, we won't be // able to build it at all. diff --git a/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc b/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc index d999525be0..8b8bab48a7 100644 --- a/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc @@ -67,7 +67,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -92,7 +92,7 @@ TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -123,7 +123,7 @@ TEST_F(RemoteEstimatorProxyTest, FeedbackWithMissingStart) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -152,7 +152,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -188,7 +188,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) { .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -207,7 +207,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) { .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector status_vec = packet->GetStatusVector(); @@ -236,7 +236,7 @@ TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector delta_vec = packet->GetReceiveDeltasUs(); EXPECT_EQ(1u, delta_vec.size()); @@ -256,7 +256,7 @@ TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector delta_vec = packet->GetReceiveDeltasUs(); EXPECT_EQ(2u, delta_vec.size()); @@ -274,7 +274,7 @@ TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { packet->Build(); EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); - EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); + EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); std::vector delta_vec = packet->GetReceiveDeltasUs(); EXPECT_EQ(2u, delta_vec.size()); diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc index 2a60da7669..e2755b3994 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc @@ -125,12 +125,12 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { OnSentPacket(packet); rtcp::TransportFeedback feedback; - feedback.WithBase(packets[0].sequence_number, - packets[0].arrival_time_ms * 1000); + feedback.SetBase(packets[0].sequence_number, + packets[0].arrival_time_ms * 1000); for (const PacketInfo& packet : packets) { - EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, - packet.arrival_time_ms * 1000)); + EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, + packet.arrival_time_ms * 1000)); } feedback.Build(); @@ -161,13 +161,13 @@ TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { } rtcp::TransportFeedback feedback; - feedback.WithBase(packets[0].sequence_number, - packets[0].arrival_time_ms * 1000); + feedback.SetBase(packets[0].sequence_number, + packets[0].arrival_time_ms * 1000); for (const PacketInfo& packet : packets) { if (packet.sequence_number <= kReceiveSideDropAfter) { - EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, - packet.arrival_time_ms * 1000)); + EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, + packet.arrival_time_ms * 1000)); } } @@ -204,11 +204,11 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { for (size_t i = 0; i < packets.size(); ++i) { std::unique_ptr feedback( new rtcp::TransportFeedback()); - feedback->WithBase(packets[i].sequence_number, - packets[i].arrival_time_ms * 1000); + feedback->SetBase(packets[i].sequence_number, + packets[i].arrival_time_ms * 1000); - EXPECT_TRUE(feedback->WithReceivedPacket( - packets[i].sequence_number, packets[i].arrival_time_ms * 1000)); + EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number, + packets[i].arrival_time_ms * 1000)); rtc::Buffer raw_packet = feedback->Build(); feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), @@ -241,12 +241,12 @@ TEST_F(TransportFeedbackAdapterTest, HandlesReordering) { OnSentPacket(packet); rtcp::TransportFeedback feedback; - feedback.WithBase(packets[0].sequence_number, - packets[0].arrival_time_ms * 1000); + feedback.SetBase(packets[0].sequence_number, + packets[0].arrival_time_ms * 1000); for (const PacketInfo& packet : packets) { - EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, - packet.arrival_time_ms * 1000)); + EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, + packet.arrival_time_ms * 1000)); } feedback.Build(); @@ -310,15 +310,15 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { // Create expected feedback and send into adapter. std::unique_ptr feedback( new rtcp::TransportFeedback()); - feedback->WithBase(sent_packets[0].sequence_number, - sent_packets[0].arrival_time_ms * 1000); + feedback->SetBase(sent_packets[0].sequence_number, + sent_packets[0].arrival_time_ms * 1000); for (const PacketInfo& packet : sent_packets) { - EXPECT_TRUE(feedback->WithReceivedPacket(packet.sequence_number, - packet.arrival_time_ms * 1000)); + EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number, + packet.arrival_time_ms * 1000)); } - EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number, - info.arrival_time_ms * 1000)); + EXPECT_FALSE(feedback->AddReceivedPacket(info.sequence_number, + info.arrival_time_ms * 1000)); rtc::Buffer raw_packet = feedback->Build(); feedback = @@ -338,9 +338,9 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { // Create a new feedback message and add the trailing item. feedback.reset(new rtcp::TransportFeedback()); - feedback->WithBase(info.sequence_number, info.arrival_time_ms * 1000); - EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number, - info.arrival_time_ms * 1000)); + feedback->SetBase(info.sequence_number, info.arrival_time_ms * 1000); + EXPECT_TRUE(feedback->AddReceivedPacket(info.sequence_number, + info.arrival_time_ms * 1000)); raw_packet = feedback->Build(); feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h index 27ec57aaa9..9443b6d3cb 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h @@ -21,16 +21,16 @@ namespace rtcp { // // Example: // ReportBlock report_block; -// report_block.To(234); -// report_block.WithFractionLost(10); +// report_block.SetMediaSsrc(234); +// report_block.SetFractionLost(10); // // ReceiverReport rr; -// rr.From(123); -// rr.WithReportBlock(report_block); +// rr.SetSenderSsrc(123); +// rr.AddReportBlock(report_block); // // Fir fir; -// fir.From(123); -// fir.WithRequestTo(234, 56); +// fir.SetSenderSsrc(123); +// fir.AddRequestTo(234, 56); // // size_t length = 0; // Builds an intra frame request // uint8_t packet[kPacketSize]; // with sequence number 56. diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc index 205fdbb092..a2d37a4dfc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc @@ -51,12 +51,12 @@ bool App::Parse(const CommonHeader& packet) { return true; } -void App::WithSubType(uint8_t subtype) { +void App::SetSubType(uint8_t subtype) { RTC_DCHECK_LE(subtype, 0x1f); sub_type_ = subtype; } -void App::WithData(const uint8_t* data, size_t data_length) { +void App::SetData(const uint8_t* data, size_t data_length) { RTC_DCHECK(data); RTC_DCHECK_EQ(data_length % 4, 0u) << "Data must be 32 bits aligned."; RTC_DCHECK_LE(data_length, kMaxDataSize) << "App data size " << data_length diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h index fea55e4b65..0b233b3118 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h @@ -28,10 +28,10 @@ class App : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void From(uint32_t ssrc) { ssrc_ = ssrc; } - void WithSubType(uint8_t subtype); - void WithName(uint32_t name) { name_ = name; } - void WithData(const uint8_t* data, size_t data_length); + void SetSsrc(uint32_t ssrc) { ssrc_ = ssrc; } + void SetSubType(uint8_t subtype); + void SetName(uint32_t name) { name_ = name; } + void SetData(const uint8_t* data, size_t data_length); uint8_t sub_type() const { return sub_type_; } uint32_t ssrc() const { return ssrc_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc index abc8f04f00..6015ab8744 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc @@ -53,9 +53,9 @@ constexpr uint8_t kPacketWithUnalignedPayload[] = { TEST(RtcpPacketAppTest, CreateWithoutData) { App app; - app.From(kSenderSsrc); - app.WithSubType(kSubtype); - app.WithName(kName); + app.SetSsrc(kSenderSsrc); + app.SetSubType(kSubtype); + app.SetName(kName); rtc::Buffer raw = app.Build(); @@ -75,10 +75,10 @@ TEST(RtcpPacketAppTest, ParseWithoutData) { TEST(RtcpPacketAppTest, CreateWithData) { App app; - app.From(kSenderSsrc); - app.WithSubType(kSubtype); - app.WithName(kName); - app.WithData(kData, sizeof(kData)); + app.SetSsrc(kSenderSsrc); + app.SetSubType(kSubtype); + app.SetName(kName); + app.SetData(kData, sizeof(kData)); rtc::Buffer raw = app.Build(); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc index 7b688ab9a4..610dfe36ff 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc @@ -10,6 +10,8 @@ #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" +#include + #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" @@ -109,18 +111,18 @@ bool Bye::Create(uint8_t* packet, return true; } -bool Bye::WithCsrc(uint32_t csrc) { - if (csrcs_.size() >= kMaxNumberOfCsrcs) { - LOG(LS_WARNING) << "Max CSRC size reached."; +bool Bye::SetCsrcs(std::vector csrcs) { + if (csrcs.size() > kMaxNumberOfCsrcs) { + LOG(LS_WARNING) << "Too many CSRCs for Bye packet."; return false; } - csrcs_.push_back(csrc); + csrcs_ = std::move(csrcs); return true; } -void Bye::WithReason(const std::string& reason) { +void Bye::SetReason(std::string reason) { RTC_DCHECK_LE(reason.size(), 0xffu); - reason_ = reason; + reason_ = std::move(reason); } size_t Bye::BlockLength() const { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h index ad28cb39e7..c1db9e8d4d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h @@ -32,9 +32,9 @@ class Bye : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } - bool WithCsrc(uint32_t csrc); - void WithReason(const std::string& reason); + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + bool SetCsrcs(std::vector csrcs); + void SetReason(std::string reason); uint32_t sender_ssrc() const { return sender_ssrc_; } const std::vector& csrcs() const { return csrcs_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc index fbea60a737..c90566b98d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc @@ -26,7 +26,7 @@ const uint32_t kCsrc2 = 0x33343536; TEST(RtcpPacketByeTest, CreateAndParseWithoutReason) { Bye bye; - bye.From(kSenderSsrc); + bye.SetSenderSsrc(kSenderSsrc); rtc::Buffer raw = bye.Build(); Bye parsed_bye; @@ -39,9 +39,8 @@ TEST(RtcpPacketByeTest, CreateAndParseWithoutReason) { TEST(RtcpPacketByeTest, CreateAndParseWithCsrcs) { Bye bye; - bye.From(kSenderSsrc); - EXPECT_TRUE(bye.WithCsrc(kCsrc1)); - EXPECT_TRUE(bye.WithCsrc(kCsrc2)); + bye.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2})); EXPECT_TRUE(bye.reason().empty()); rtc::Buffer raw = bye.Build(); @@ -57,10 +56,9 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) { Bye bye; const std::string kReason = "Some Reason"; - bye.From(kSenderSsrc); - EXPECT_TRUE(bye.WithCsrc(kCsrc1)); - EXPECT_TRUE(bye.WithCsrc(kCsrc2)); - bye.WithReason(kReason); + bye.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2})); + bye.SetReason(kReason); rtc::Buffer raw = bye.Build(); Bye parsed_bye; @@ -73,20 +71,18 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) { TEST(RtcpPacketByeTest, CreateWithTooManyCsrcs) { Bye bye; - bye.From(kSenderSsrc); + bye.SetSenderSsrc(kSenderSsrc); const int kMaxCsrcs = (1 << 5) - 2; // 5 bit len, first item is sender SSRC. - for (int i = 0; i < kMaxCsrcs; ++i) { - EXPECT_TRUE(bye.WithCsrc(i)); - } - EXPECT_FALSE(bye.WithCsrc(kMaxCsrcs)); + EXPECT_TRUE(bye.SetCsrcs(std::vector(kMaxCsrcs, kCsrc1))); + EXPECT_FALSE(bye.SetCsrcs(std::vector(kMaxCsrcs + 1, kCsrc1))); } TEST(RtcpPacketByeTest, CreateAndParseWithAReason) { Bye bye; const std::string kReason = "Some Random Reason"; - bye.From(kSenderSsrc); - bye.WithReason(kReason); + bye.SetSenderSsrc(kSenderSsrc); + bye.SetReason(kReason); rtc::Buffer raw = bye.Build(); Bye parsed_bye; @@ -103,8 +99,8 @@ TEST(RtcpPacketByeTest, CreateAndParseWithReasons) { for (size_t reminder = 0; reminder < 4; ++reminder) { const std::string kReason(4 + reminder, 'a' + reminder); Bye bye; - bye.From(kSenderSsrc); - bye.WithReason(kReason); + bye.SetSenderSsrc(kSenderSsrc); + bye.SetReason(kReason); rtc::Buffer raw = bye.Build(); Bye parsed_bye; @@ -125,7 +121,7 @@ TEST(RtcpPacketByeTest, ParseEmptyPacket) { TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) { Bye bye; - bye.From(kSenderSsrc); + bye.SetSenderSsrc(kSenderSsrc); rtc::Buffer raw = bye.Build(); raw[0]++; // Damage the packet: increase ssrc count by one. @@ -136,8 +132,8 @@ TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) { TEST(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) { Bye bye; - bye.From(kSenderSsrc); - bye.WithReason("18 characters long"); + bye.SetSenderSsrc(kSenderSsrc); + bye.SetReason("18 characters long"); rtc::Buffer raw = bye.Build(); // Damage the packet: decrease payload size by 4 bytes diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc index 94686fb275..5e2c7df77d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc @@ -35,11 +35,11 @@ const uint8_t kSeqNo = 13; TEST(RtcpCompoundPacketTest, AppendPacket) { CompoundPacket compound; Fir fir; - fir.WithRequestTo(kRemoteSsrc, kSeqNo); + fir.AddRequestTo(kRemoteSsrc, kSeqNo); ReportBlock rb; ReceiverReport rr; - rr.From(kSenderSsrc); - EXPECT_TRUE(rr.WithReportBlock(rb)); + rr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(rr.AddReportBlock(rb)); compound.Append(&rr); compound.Append(&fir); @@ -56,12 +56,12 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) { CompoundPacket root; CompoundPacket leaf; Fir fir; - fir.WithRequestTo(kRemoteSsrc, kSeqNo); + fir.AddRequestTo(kRemoteSsrc, kSeqNo); Bye bye; ReportBlock rb; ReceiverReport rr; - EXPECT_TRUE(rr.WithReportBlock(rb)); + EXPECT_TRUE(rr.AddReportBlock(rb)); leaf.Append(&rr); leaf.Append(&fir); @@ -83,11 +83,11 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) { TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) { CompoundPacket compound; Fir fir; - fir.WithRequestTo(kRemoteSsrc, kSeqNo); + fir.AddRequestTo(kRemoteSsrc, kSeqNo); ReportBlock rb; ReceiverReport rr; - rr.From(kSenderSsrc); - EXPECT_TRUE(rr.WithReportBlock(rb)); + rr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(rr.AddReportBlock(rb)); compound.Append(&rr); compound.Append(&fir); @@ -117,11 +117,11 @@ TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) { TEST(RtcpCompoundPacketTest, BuildWithTooSmallBuffer_FragmentedSend) { CompoundPacket compound; Fir fir; - fir.WithRequestTo(kRemoteSsrc, kSeqNo); + fir.AddRequestTo(kRemoteSsrc, kSeqNo); ReportBlock rb; ReceiverReport rr; - rr.From(kSenderSsrc); - EXPECT_TRUE(rr.WithReportBlock(rb)); + rr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(rr.AddReportBlock(rb)); compound.Append(&rr); compound.Append(&fir); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc index 45c4b6357f..97516f1468 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc @@ -81,7 +81,7 @@ void Dlrr::Create(uint8_t* buffer) const { RTC_DCHECK_EQ(buffer + BlockLength(), write_at); } -bool Dlrr::WithDlrrItem(const ReceiveTimeInfo& block) { +bool Dlrr::AddDlrrItem(const ReceiveTimeInfo& block) { if (sub_blocks_.size() >= kMaxNumberOfDlrrItems) { LOG(LS_WARNING) << "Max DLRR items reached."; return false; @@ -90,14 +90,14 @@ bool Dlrr::WithDlrrItem(const ReceiveTimeInfo& block) { return true; } -bool Dlrr::WithDlrrItem(uint32_t ssrc, - uint32_t last_rr, - uint32_t delay_last_rr) { +bool Dlrr::AddDlrrItem(uint32_t ssrc, + uint32_t last_rr, + uint32_t delay_last_rr) { ReceiveTimeInfo block; block.ssrc = ssrc; block.last_rr = last_rr; block.delay_since_last_rr = delay_last_rr; - return WithDlrrItem(block); + return AddDlrrItem(block); } } // namespace rtcp } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h index a48c3394ae..c2a4b8fffc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h @@ -50,8 +50,8 @@ class Dlrr { void Create(uint8_t* buffer) const; // Max 100 DLRR Items can be added per DLRR report block. - bool WithDlrrItem(const ReceiveTimeInfo& time_info); - bool WithDlrrItem(uint32_t ssrc, uint32_t last_rr, uint32_t delay_last_rr); + bool AddDlrrItem(const ReceiveTimeInfo& time_info); + bool AddDlrrItem(uint32_t ssrc, uint32_t last_rr, uint32_t delay_last_rr); const std::vector& sub_blocks() const { return sub_blocks_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc index 1bf0cc4bb6..469a4669bb 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc @@ -35,7 +35,7 @@ TEST(RtcpPacketDlrrTest, Empty) { TEST(RtcpPacketDlrrTest, Create) { Dlrr dlrr; - EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc, kLastRR, kDelay)); + EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc, kLastRR, kDelay)); ASSERT_EQ(kBlockSizeBytes, dlrr.BlockLength()); uint8_t buffer[kBlockSizeBytes]; @@ -73,9 +73,9 @@ TEST(RtcpPacketDlrrTest, ParseFailsOnBadSize) { TEST(RtcpPacketDlrrTest, FailsOnTooManySubBlocks) { Dlrr dlrr; for (size_t i = 1; i <= Dlrr::kMaxNumberOfDlrrItems; ++i) { - EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc + i, kLastRR + i, kDelay + i)); + EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i)); } - EXPECT_FALSE(dlrr.WithDlrrItem(kSsrc, kLastRR, kDelay)); + EXPECT_FALSE(dlrr.AddDlrrItem(kSsrc, kLastRR, kDelay)); } TEST(RtcpPacketDlrrTest, CreateAndParseMaxSubBlocks) { @@ -85,7 +85,7 @@ TEST(RtcpPacketDlrrTest, CreateAndParseMaxSubBlocks) { // Create. Dlrr dlrr; for (size_t i = 1; i <= Dlrr::kMaxNumberOfDlrrItems; ++i) { - EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc + i, kLastRR + i, kDelay + i)); + EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i)); } size_t used_buffer_size = dlrr.BlockLength(); ASSERT_LE(used_buffer_size, kBufferSize); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc index fc3a810aac..c296dbcac9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc @@ -10,6 +10,8 @@ #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" +#include + #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" @@ -56,12 +58,12 @@ bool ExtendedJitterReport::Parse(const CommonHeader& packet) { return true; } -bool ExtendedJitterReport::WithJitter(uint32_t jitter) { - if (inter_arrival_jitters_.size() >= kMaxNumberOfJitters) { - LOG(LS_WARNING) << "Max inter-arrival jitter items reached."; +bool ExtendedJitterReport::SetJitterValues(std::vector values) { + if (values.size() > kMaxNumberOfJitterValues) { + LOG(LS_WARNING) << "Too many inter-arrival jitter items."; return false; } - inter_arrival_jitters_.push_back(jitter); + inter_arrival_jitters_ = std::move(values); return true; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h index 7731988df4..b26dc46b2c 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h @@ -23,6 +23,7 @@ class CommonHeader; class ExtendedJitterReport : public RtcpPacket { public: static constexpr uint8_t kPacketType = 195; + static constexpr size_t kMaxNumberOfJitterValues = 0x1f; ExtendedJitterReport() {} ~ExtendedJitterReport() override {} @@ -30,9 +31,11 @@ class ExtendedJitterReport : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - bool WithJitter(uint32_t jitter); + bool SetJitterValues(std::vector jitter_values); - const std::vector& jitters() { return inter_arrival_jitters_; } + const std::vector& jitter_values() { + return inter_arrival_jitters_; + } protected: bool Create(uint8_t* packet, @@ -41,7 +44,6 @@ class ExtendedJitterReport : public RtcpPacket { RtcpPacket::PacketReadyCallback* callback) const override; private: - static constexpr size_t kMaxNumberOfJitters = 0x1f; static constexpr size_t kJitterSizeBytes = 4; size_t BlockLength() const override { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc index c9e01aadd0..f1ce6a9153 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc @@ -31,44 +31,42 @@ TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithoutItems) { ExtendedJitterReport parsed; EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); - EXPECT_THAT(parsed.jitters(), IsEmpty()); + EXPECT_THAT(parsed.jitter_values(), IsEmpty()); } TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithOneItem) { ExtendedJitterReport ij; - EXPECT_TRUE(ij.WithJitter(kJitter1)); + EXPECT_TRUE(ij.SetJitterValues({kJitter1})); rtc::Buffer raw = ij.Build(); ExtendedJitterReport parsed; EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); - EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1)); + EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1)); } TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithTwoItems) { ExtendedJitterReport ij; - EXPECT_TRUE(ij.WithJitter(kJitter1)); - EXPECT_TRUE(ij.WithJitter(kJitter2)); + EXPECT_TRUE(ij.SetJitterValues({kJitter1, kJitter2})); rtc::Buffer raw = ij.Build(); ExtendedJitterReport parsed; EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); - EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1, kJitter2)); + EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1, kJitter2)); } TEST(RtcpPacketExtendedJitterReportTest, CreateWithTooManyItems) { ExtendedJitterReport ij; - const int kMaxIjItems = (1 << 5) - 1; - for (int i = 0; i < kMaxIjItems; ++i) { - EXPECT_TRUE(ij.WithJitter(i)); - } - EXPECT_FALSE(ij.WithJitter(kMaxIjItems)); + const int kMaxItems = ExtendedJitterReport::kMaxNumberOfJitterValues; + EXPECT_FALSE( + ij.SetJitterValues(std::vector(kMaxItems + 1, kJitter1))); + EXPECT_TRUE(ij.SetJitterValues(std::vector(kMaxItems, kJitter1))); } TEST(RtcpPacketExtendedJitterReportTest, ParseFailsWithTooManyItems) { ExtendedJitterReport ij; - ij.WithJitter(kJitter1); + ij.SetJitterValues({kJitter1}); rtc::Buffer raw = ij.Build(); raw[0]++; // Damage packet: increase jitter count by 1. ExtendedJitterReport parsed; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc index 9e704b12da..0199b5276a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc @@ -91,7 +91,7 @@ bool ExtendedReports::Parse(const CommonHeader& packet) { return true; } -bool ExtendedReports::WithRrtr(const Rrtr& rrtr) { +bool ExtendedReports::AddRrtr(const Rrtr& rrtr) { if (rrtr_blocks_.size() >= kMaxNumberOfRrtrBlocks) { LOG(LS_WARNING) << "Max RRTR blocks reached."; return false; @@ -100,7 +100,7 @@ bool ExtendedReports::WithRrtr(const Rrtr& rrtr) { return true; } -bool ExtendedReports::WithDlrr(const Dlrr& dlrr) { +bool ExtendedReports::AddDlrr(const Dlrr& dlrr) { if (dlrr_blocks_.size() >= kMaxNumberOfDlrrBlocks) { LOG(LS_WARNING) << "Max DLRR blocks reached."; return false; @@ -109,7 +109,7 @@ bool ExtendedReports::WithDlrr(const Dlrr& dlrr) { return true; } -bool ExtendedReports::WithVoipMetric(const VoipMetric& voip_metric) { +bool ExtendedReports::AddVoipMetric(const VoipMetric& voip_metric) { if (voip_metric_blocks_.size() >= kMaxNumberOfVoipMetricBlocks) { LOG(LS_WARNING) << "Max Voip Metric blocks reached."; return false; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h index b15d416583..7b6c54452f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h @@ -34,12 +34,12 @@ class ExtendedReports : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } // Max 50 items of each of {Rrtr, Dlrr, VoipMetric} allowed per Xr. - bool WithRrtr(const Rrtr& rrtr); - bool WithDlrr(const Dlrr& dlrr); - bool WithVoipMetric(const VoipMetric& voip_metric); + bool AddRrtr(const Rrtr& rrtr); + bool AddDlrr(const Dlrr& dlrr); + bool AddVoipMetric(const VoipMetric& voip_metric); uint32_t sender_ssrc() const { return sender_ssrc_; } const std::vector& rrtrs() const { return rrtr_blocks_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc index 133e840144..8cb144d844 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc @@ -110,7 +110,7 @@ NtpTime RtcpPacketExtendedReportsTest::Rand() { template <> Rrtr RtcpPacketExtendedReportsTest::Rand() { Rrtr rrtr; - rrtr.WithNtp(Rand()); + rrtr.SetNtp(Rand()); return rrtr; } @@ -143,14 +143,14 @@ RTCPVoIPMetric RtcpPacketExtendedReportsTest::Rand() { template <> VoipMetric RtcpPacketExtendedReportsTest::Rand() { VoipMetric voip_metric; - voip_metric.To(Rand()); - voip_metric.WithVoipMetric(Rand()); + voip_metric.SetMediaSsrc(Rand()); + voip_metric.SetVoipMetric(Rand()); return voip_metric; } TEST_F(RtcpPacketExtendedReportsTest, CreateWithoutReportBlocks) { ExtendedReports xr; - xr.From(kSenderSsrc); + xr.SetSenderSsrc(kSenderSsrc); rtc::Buffer packet = xr.Build(); @@ -170,8 +170,8 @@ TEST_F(RtcpPacketExtendedReportsTest, ParseWithoutReportBlocks) { TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithOneRrtrBlock) { Rrtr rrtr = Rand(); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithRrtr(rrtr)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddRrtr(rrtr)); rtc::Buffer packet = xr.Build(); ExtendedReports mparsed; @@ -186,9 +186,9 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) { Rrtr rrtr1 = Rand(); Rrtr rrtr2 = Rand(); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithRrtr(rrtr1)); - EXPECT_TRUE(xr.WithRrtr(rrtr2)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddRrtr(rrtr1)); + EXPECT_TRUE(xr.AddRrtr(rrtr2)); rtc::Buffer packet = xr.Build(); @@ -202,10 +202,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) { TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) { Dlrr dlrr; - EXPECT_TRUE(dlrr.WithDlrrItem(Rand())); + EXPECT_TRUE(dlrr.AddDlrrItem(Rand())); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithDlrr(dlrr)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddDlrr(dlrr)); rtc::Buffer packet = xr.Build(); @@ -219,11 +219,11 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) { TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) { Dlrr dlrr; - EXPECT_TRUE(dlrr.WithDlrrItem(Rand())); - EXPECT_TRUE(dlrr.WithDlrrItem(Rand())); + EXPECT_TRUE(dlrr.AddDlrrItem(Rand())); + EXPECT_TRUE(dlrr.AddDlrrItem(Rand())); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithDlrr(dlrr)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddDlrr(dlrr)); rtc::Buffer packet = xr.Build(); @@ -237,13 +237,13 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) { TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoDlrrBlocks) { Dlrr dlrr1; - EXPECT_TRUE(dlrr1.WithDlrrItem(Rand())); + EXPECT_TRUE(dlrr1.AddDlrrItem(Rand())); Dlrr dlrr2; - EXPECT_TRUE(dlrr2.WithDlrrItem(Rand())); + EXPECT_TRUE(dlrr2.AddDlrrItem(Rand())); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithDlrr(dlrr1)); - EXPECT_TRUE(xr.WithDlrr(dlrr2)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddDlrr(dlrr1)); + EXPECT_TRUE(xr.AddDlrr(dlrr2)); rtc::Buffer packet = xr.Build(); @@ -259,8 +259,8 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) { VoipMetric voip_metric = Rand(); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithVoipMetric(voip_metric)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddVoipMetric(voip_metric)); rtc::Buffer packet = xr.Build(); @@ -275,13 +275,13 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) { TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithMultipleReportBlocks) { Rrtr rrtr = Rand(); Dlrr dlrr; - EXPECT_TRUE(dlrr.WithDlrrItem(Rand())); + EXPECT_TRUE(dlrr.AddDlrrItem(Rand())); VoipMetric metric = Rand(); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithRrtr(rrtr)); - EXPECT_TRUE(xr.WithDlrr(dlrr)); - EXPECT_TRUE(xr.WithVoipMetric(metric)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddRrtr(rrtr)); + EXPECT_TRUE(xr.AddDlrr(dlrr)); + EXPECT_TRUE(xr.AddVoipMetric(metric)); rtc::Buffer packet = xr.Build(); @@ -300,10 +300,10 @@ TEST_F(RtcpPacketExtendedReportsTest, DlrrWithoutItemNotIncludedInPacket) { Dlrr dlrr; VoipMetric metric = Rand(); ExtendedReports xr; - xr.From(kSenderSsrc); - EXPECT_TRUE(xr.WithRrtr(rrtr)); - EXPECT_TRUE(xr.WithDlrr(dlrr)); - EXPECT_TRUE(xr.WithVoipMetric(metric)); + xr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(xr.AddRrtr(rrtr)); + EXPECT_TRUE(xr.AddDlrr(dlrr)); + EXPECT_TRUE(xr.AddVoipMetric(metric)); rtc::Buffer packet = xr.Build(); @@ -322,17 +322,17 @@ TEST_F(RtcpPacketExtendedReportsTest, WithTooManyBlocks) { Rrtr rrtr = Rand(); for (size_t i = 0; i < kMaxBlocks; ++i) - EXPECT_TRUE(xr.WithRrtr(rrtr)); - EXPECT_FALSE(xr.WithRrtr(rrtr)); + EXPECT_TRUE(xr.AddRrtr(rrtr)); + EXPECT_FALSE(xr.AddRrtr(rrtr)); Dlrr dlrr; for (size_t i = 0; i < kMaxBlocks; ++i) - EXPECT_TRUE(xr.WithDlrr(dlrr)); - EXPECT_FALSE(xr.WithDlrr(dlrr)); + EXPECT_TRUE(xr.AddDlrr(dlrr)); + EXPECT_FALSE(xr.AddDlrr(dlrr)); VoipMetric voip_metric = Rand(); for (size_t i = 0; i < kMaxBlocks; ++i) - EXPECT_TRUE(xr.WithVoipMetric(voip_metric)); - EXPECT_FALSE(xr.WithVoipMetric(voip_metric)); + EXPECT_TRUE(xr.AddVoipMetric(voip_metric)); + EXPECT_FALSE(xr.AddVoipMetric(voip_metric)); } } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h index ddf2cfaf2a..59f3b61729 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h @@ -36,8 +36,8 @@ class Fir : public Psfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithRequestTo(uint32_t ssrc, uint8_t seq_num) { - items_.push_back(Request(ssrc, seq_num)); + void AddRequestTo(uint32_t ssrc, uint8_t seq_num) { + items_.emplace_back(ssrc, seq_num); } const std::vector& requests() const { return items_; } @@ -53,7 +53,7 @@ class Fir : public Psfb { return kHeaderLength + kCommonFeedbackLength + kFciLength * items_.size(); } // SSRC of media source is not used in FIR packet. Shadow base functions. - void To(uint32_t ssrc); + void SetMediaSsrc(uint32_t ssrc); uint32_t media_ssrc() const; std::vector items_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc index 8c48a83a7f..bce5f95b75 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc @@ -49,8 +49,8 @@ TEST(RtcpPacketFirTest, Parse) { TEST(RtcpPacketFirTest, Create) { Fir fir; - fir.From(kSenderSsrc); - fir.WithRequestTo(kRemoteSsrc, kSeqNr); + fir.SetSenderSsrc(kSenderSsrc); + fir.AddRequestTo(kRemoteSsrc, kSeqNr); rtc::Buffer packet = fir.Build(); @@ -60,9 +60,9 @@ TEST(RtcpPacketFirTest, Create) { TEST(RtcpPacketFirTest, TwoFciEntries) { Fir fir; - fir.From(kSenderSsrc); - fir.WithRequestTo(kRemoteSsrc, kSeqNr); - fir.WithRequestTo(kRemoteSsrc + 1, kSeqNr + 1); + fir.SetSenderSsrc(kSenderSsrc); + fir.AddRequestTo(kRemoteSsrc, kSeqNr); + fir.AddRequestTo(kRemoteSsrc + 1, kSeqNr + 1); rtc::Buffer packet = fir.Build(); Fir parsed; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc index 0c1f577f7b..956b16f784 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc @@ -121,7 +121,7 @@ size_t Nack::BlockLength() const { packed_.size() * kNackItemLength; } -void Nack::WithList(const uint16_t* nack_list, size_t length) { +void Nack::SetPacketIds(const uint16_t* nack_list, size_t length) { RTC_DCHECK(nack_list); RTC_DCHECK(packet_ids_.empty()); RTC_DCHECK(packed_.empty()); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h index 83b3ba954b..e346200a8e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h @@ -30,7 +30,7 @@ class Nack : public Rtpfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithList(const uint16_t* nack_list, size_t length); + void SetPacketIds(const uint16_t* nack_list, size_t length); const std::vector& packet_ids() const { return packet_ids_; } protected: @@ -48,7 +48,7 @@ class Nack : public Rtpfb { uint16_t bitmask; }; - void Pack(); // Fills packed_ using packed_ids_. (used in WithList). + void Pack(); // Fills packed_ using packed_ids_. (used in SetPacketIds). void Unpack(); // Fills packet_ids_ using packed_. (used in Parse). std::vector packed_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc index d335d66bf8..a9920196c4 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc @@ -57,9 +57,9 @@ constexpr uint8_t kTooSmallPacket[] = { TEST(RtcpPacketNackTest, Create) { Nack nack; - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, kListLength); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kRemoteSsrc); + nack.SetPacketIds(kList, kListLength); rtc::Buffer packet = nack.Build(); @@ -79,9 +79,9 @@ TEST(RtcpPacketNackTest, Parse) { TEST(RtcpPacketNackTest, CreateWrap) { Nack nack; - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kWrapList, kWrapListLength); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kRemoteSsrc); + nack.SetPacketIds(kWrapList, kWrapListLength); rtc::Buffer packet = nack.Build(); @@ -104,9 +104,9 @@ TEST(RtcpPacketNackTest, BadOrder) { const size_t kUnorderedListLength = sizeof(kUnorderedList) / sizeof(kUnorderedList[0]); Nack nack; - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kUnorderedList, kUnorderedListLength); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kRemoteSsrc); + nack.SetPacketIds(kUnorderedList, kUnorderedListLength); rtc::Buffer packet = nack.Build(); @@ -122,9 +122,9 @@ TEST(RtcpPacketNackTest, CreateFragmented) { Nack nack; const uint16_t kList[] = {1, 100, 200, 300, 400}; const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, kListLength); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kRemoteSsrc); + nack.SetPacketIds(kList, kListLength); class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback { public: @@ -156,9 +156,9 @@ TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) { const uint16_t kList[] = {1}; const size_t kMinNackBlockSize = 16; Nack nack; - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, 1); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kRemoteSsrc); + nack.SetPacketIds(kList, 1); class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { public: void OnPacketReady(uint8_t* data, size_t length) override { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc index 4304f191d5..f75182218c 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc @@ -40,8 +40,8 @@ TEST(RtcpPacketPliTest, Parse) { TEST(RtcpPacketPliTest, Create) { Pli pli; - pli.From(kSenderSsrc); - pli.To(kRemoteSsrc); + pli.SetSenderSsrc(kSenderSsrc); + pli.SetMediaSsrc(kRemoteSsrc); rtc::Buffer packet = pli.Build(); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h index 8707a5dbaf..762dc61138 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h @@ -27,8 +27,8 @@ class Psfb : public RtcpPacket { Psfb() : sender_ssrc_(0), media_ssrc_(0) {} ~Psfb() override {} - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } - void To(uint32_t ssrc) { media_ssrc_ = ssrc; } + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; } uint32_t sender_ssrc() const { return sender_ssrc_; } uint32_t media_ssrc() const { return media_ssrc_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc index 60d46d13c5..8dcc46dfd8 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc @@ -39,8 +39,8 @@ TEST(RtcpPacketRapidResyncRequestTest, Parse) { TEST(RtcpPacketRapidResyncRequestTest, Create) { RapidResyncRequest rrr; - rrr.From(kSenderSsrc); - rrr.To(kRemoteSsrc); + rrr.SetSenderSsrc(kSenderSsrc); + rrr.SetMediaSsrc(kRemoteSsrc); rtc::Buffer packet = rrr.Build(); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc index a393181cea..808190ad10 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc @@ -74,7 +74,7 @@ bool ReceiverReport::Create(uint8_t* packet, return true; } -bool ReceiverReport::WithReportBlock(const ReportBlock& block) { +bool ReceiverReport::AddReportBlock(const ReportBlock& block) { if (report_blocks_.size() >= kMaxNumberOfReportBlocks) { LOG(LS_WARNING) << "Max report blocks reached."; return false; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h index 0630adbac2..2bfe174c50 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h @@ -32,8 +32,8 @@ class ReceiverReport : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } - bool WithReportBlock(const ReportBlock& block); + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + bool AddReportBlock(const ReportBlock& block); uint32_t sender_ssrc() const { return sender_ssrc_; } const std::vector& report_blocks() const { diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc index d2c833b866..5e28ff4f1e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc @@ -65,16 +65,16 @@ TEST(RtcpPacketReceiverReportTest, ParseFailsOnIncorrectSize) { TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) { ReceiverReport rr; - rr.From(kSenderSsrc); + rr.SetSenderSsrc(kSenderSsrc); ReportBlock rb; - rb.To(kRemoteSsrc); - rb.WithFractionLost(kFractionLost); - rb.WithCumulativeLost(kCumulativeLost); - rb.WithExtHighestSeqNum(kExtHighestSeqNum); - rb.WithJitter(kJitter); - rb.WithLastSr(kLastSr); - rb.WithDelayLastSr(kDelayLastSr); - rr.WithReportBlock(rb); + rb.SetMediaSsrc(kRemoteSsrc); + rb.SetFractionLost(kFractionLost); + rb.SetCumulativeLost(kCumulativeLost); + rb.SetExtHighestSeqNum(kExtHighestSeqNum); + rb.SetJitter(kJitter); + rb.SetLastSr(kLastSr); + rb.SetDelayLastSr(kDelayLastSr); + rr.AddReportBlock(rb); rtc::Buffer raw = rr.Build(); @@ -83,7 +83,7 @@ TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) { TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) { ReceiverReport rr; - rr.From(kSenderSsrc); + rr.SetSenderSsrc(kSenderSsrc); rtc::Buffer raw = rr.Build(); ReceiverReport parsed; @@ -96,13 +96,13 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) { TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) { ReceiverReport rr; ReportBlock rb1; - rb1.To(kRemoteSsrc); + rb1.SetMediaSsrc(kRemoteSsrc); ReportBlock rb2; - rb2.To(kRemoteSsrc + 1); + rb2.SetMediaSsrc(kRemoteSsrc + 1); - rr.From(kSenderSsrc); - EXPECT_TRUE(rr.WithReportBlock(rb1)); - EXPECT_TRUE(rr.WithReportBlock(rb2)); + rr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(rr.AddReportBlock(rb1)); + EXPECT_TRUE(rr.AddReportBlock(rb2)); rtc::Buffer raw = rr.Build(); ReceiverReport parsed; @@ -116,15 +116,15 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) { TEST(RtcpPacketReceiverReportTest, CreateWithTooManyReportBlocks) { ReceiverReport rr; - rr.From(kSenderSsrc); + rr.SetSenderSsrc(kSenderSsrc); const size_t kMaxReportBlocks = (1 << 5) - 1; ReportBlock rb; for (size_t i = 0; i < kMaxReportBlocks; ++i) { - rb.To(kRemoteSsrc + i); - EXPECT_TRUE(rr.WithReportBlock(rb)); + rb.SetMediaSsrc(kRemoteSsrc + i); + EXPECT_TRUE(rr.AddReportBlock(rb)); } - rb.To(kRemoteSsrc + kMaxReportBlocks); - EXPECT_FALSE(rr.WithReportBlock(rb)); + rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks); + EXPECT_FALSE(rr.AddReportBlock(rb)); } } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc index 2f59fbbd55..ac5fc1a68f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc @@ -10,6 +10,8 @@ #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" +#include + #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" @@ -81,22 +83,12 @@ bool Remb::Parse(const CommonHeader& packet) { return true; } -bool Remb::AppliesTo(uint32_t ssrc) { - if (ssrcs_.size() >= kMaxNumberOfSsrcs) { - LOG(LS_WARNING) << "Max number of REMB feedback SSRCs reached."; - return false; - } - ssrcs_.push_back(ssrc); - return true; -} - -bool Remb::AppliesToMany(const std::vector& ssrcs) { - if (ssrcs_.size() + ssrcs.size() > kMaxNumberOfSsrcs) { +bool Remb::SetSsrcs(std::vector ssrcs) { + if (ssrcs.size() > kMaxNumberOfSsrcs) { LOG(LS_WARNING) << "Not enough space for all given SSRCs."; return false; } - // Append. - ssrcs_.insert(ssrcs_.end(), ssrcs.begin(), ssrcs.end()); + ssrcs_ = std::move(ssrcs); return true; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h index 9f10921c99..5cc00a2964 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h @@ -25,6 +25,7 @@ class CommonHeader; class Remb : public Psfb { public: static constexpr uint8_t kFeedbackMessageType = 15; + static constexpr size_t kMaxNumberOfSsrcs = 0xff; Remb() : bitrate_bps_(0) {} ~Remb() override {} @@ -32,9 +33,8 @@ class Remb : public Psfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - bool AppliesTo(uint32_t ssrc); - bool AppliesToMany(const std::vector& ssrcs); - void WithBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; } + bool SetSsrcs(std::vector ssrcs); + void SetBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; } uint64_t bitrate_bps() const { return bitrate_bps_; } const std::vector& ssrcs() const { return ssrcs_; } @@ -50,11 +50,10 @@ class Remb : public Psfb { } private: - static constexpr size_t kMaxNumberOfSsrcs = 0xff; static constexpr uint32_t kUniqueIdentifier = 0x52454D42; // 'R' 'E' 'M' 'B'. // Media ssrc is unused, shadow base class setter and getter. - void To(uint32_t); + void SetMediaSsrc(uint32_t); uint32_t media_ssrc() const; uint64_t bitrate_bps_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc index d504143f6f..af4c5b42c5 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc @@ -34,11 +34,10 @@ const size_t kPacketLength = sizeof(kPacket); TEST(RtcpPacketRembTest, Create) { Remb remb; - remb.From(kSenderSsrc); - remb.AppliesTo(kRemoteSsrcs[0]); - remb.AppliesTo(kRemoteSsrcs[1]); - remb.AppliesTo(kRemoteSsrcs[2]); - remb.WithBitrateBps(kBitrateBps); + remb.SetSenderSsrc(kSenderSsrc); + remb.SetSsrcs( + std::vector(std::begin(kRemoteSsrcs), std::end(kRemoteSsrcs))); + remb.SetBitrateBps(kBitrateBps); rtc::Buffer packet = remb.Build(); @@ -58,8 +57,8 @@ TEST(RtcpPacketRembTest, Parse) { TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) { Remb remb; - remb.From(kSenderSsrc); - remb.WithBitrateBps(kBitrateBps); + remb.SetSenderSsrc(kSenderSsrc); + remb.SetBitrateBps(kBitrateBps); rtc::Buffer packet = remb.Build(); Remb parsed; @@ -71,7 +70,7 @@ TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) { TEST(RtcpPacketRembTest, CreateAndParse64bitBitrate) { Remb remb; - remb.WithBitrateBps(kBitrateBps64bit); + remb.SetBitrateBps(kBitrateBps64bit); rtc::Buffer packet = remb.Build(); Remb parsed; @@ -119,27 +118,11 @@ TEST(RtcpPacketRembTest, ParseFailsWhenSsrcCountMismatchLength) { } TEST(RtcpPacketRembTest, TooManySsrcs) { - const size_t kMax = 0xff; Remb remb; - for (size_t i = 1; i <= kMax; ++i) - EXPECT_TRUE(remb.AppliesTo(kRemoteSsrcs[0] + i)); - EXPECT_FALSE(remb.AppliesTo(kRemoteSsrcs[0])); -} - -TEST(RtcpPacketRembTest, TooManySsrcsForBatchAssign) { - const uint32_t kRemoteSsrc = kRemoteSsrcs[0]; - const size_t kMax = 0xff; - const std::vector kAllButOneSsrc(kMax - 1, kRemoteSsrc); - const std::vector kTwoSsrcs(2, kRemoteSsrc); - - Remb remb; - EXPECT_TRUE(remb.AppliesToMany(kAllButOneSsrc)); - // Should be no place for 2 more. - EXPECT_FALSE(remb.AppliesToMany(kTwoSsrcs)); - // But enough place for 1 more. - EXPECT_TRUE(remb.AppliesTo(kRemoteSsrc)); - // But not for another one. - EXPECT_FALSE(remb.AppliesTo(kRemoteSsrc)); + EXPECT_FALSE(remb.SetSsrcs( + std::vector(Remb::kMaxNumberOfSsrcs + 1, kRemoteSsrcs[0]))); + EXPECT_TRUE(remb.SetSsrcs( + std::vector(Remb::kMaxNumberOfSsrcs, kRemoteSsrcs[0]))); } } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc index 4911dbf5b7..8015fa398b 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc @@ -76,7 +76,7 @@ void ReportBlock::Create(uint8_t* buffer) const { ByteWriter::WriteBigEndian(&buffer[20], delay_since_last_sr()); } -bool ReportBlock::WithCumulativeLost(uint32_t cumulative_lost) { +bool ReportBlock::SetCumulativeLost(uint32_t cumulative_lost) { if (cumulative_lost >= (1u << 24)) { // Have only 3 bytes to store it. LOG(LS_WARNING) << "Cumulative lost is too big to fit into Report Block"; return false; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h index ef99e17297..bdc3cbcd1f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h @@ -30,17 +30,17 @@ class ReportBlock { // Consumes ReportBlock::kLength bytes. void Create(uint8_t* buffer) const; - void To(uint32_t ssrc) { source_ssrc_ = ssrc; } - void WithFractionLost(uint8_t fraction_lost) { + void SetMediaSsrc(uint32_t ssrc) { source_ssrc_ = ssrc; } + void SetFractionLost(uint8_t fraction_lost) { fraction_lost_ = fraction_lost; } - bool WithCumulativeLost(uint32_t cumulative_lost); - void WithExtHighestSeqNum(uint32_t ext_highest_seq_num) { + bool SetCumulativeLost(uint32_t cumulative_lost); + void SetExtHighestSeqNum(uint32_t ext_highest_seq_num) { extended_high_seq_num_ = ext_highest_seq_num; } - void WithJitter(uint32_t jitter) { jitter_ = jitter; } - void WithLastSr(uint32_t last_sr) { last_sr_ = last_sr; } - void WithDelayLastSr(uint32_t delay_last_sr) { + void SetJitter(uint32_t jitter) { jitter_ = jitter; } + void SetLastSr(uint32_t last_sr) { last_sr_ = last_sr; } + void SetDelayLastSr(uint32_t delay_last_sr) { delay_since_last_sr_ = delay_last_sr; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc index 85bbb404a4..957a08ffbf 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc @@ -52,13 +52,13 @@ TEST(RtcpPacketReportBlockTest, ParseAnyData) { TEST(RtcpPacketReportBlockTest, ParseMatchCreate) { ReportBlock rb; - rb.To(kRemoteSsrc); - rb.WithFractionLost(kFractionLost); - rb.WithCumulativeLost(kCumulativeLost); - rb.WithExtHighestSeqNum(kExtHighestSeqNum); - rb.WithJitter(kJitter); - rb.WithLastSr(kLastSr); - rb.WithDelayLastSr(kDelayLastSr); + rb.SetMediaSsrc(kRemoteSsrc); + rb.SetFractionLost(kFractionLost); + rb.SetCumulativeLost(kCumulativeLost); + rb.SetExtHighestSeqNum(kExtHighestSeqNum); + rb.SetJitter(kJitter); + rb.SetLastSr(kLastSr); + rb.SetDelayLastSr(kDelayLastSr); uint8_t buffer[kBufferLength]; rb.Create(buffer); @@ -78,8 +78,8 @@ TEST(RtcpPacketReportBlockTest, ParseMatchCreate) { TEST(RtcpPacketReportBlockTest, ValidateCumulativeLost) { const uint32_t kMaxCumulativeLost = 0xffffff; ReportBlock rb; - EXPECT_FALSE(rb.WithCumulativeLost(kMaxCumulativeLost + 1)); - EXPECT_TRUE(rb.WithCumulativeLost(kMaxCumulativeLost)); + EXPECT_FALSE(rb.SetCumulativeLost(kMaxCumulativeLost + 1)); + EXPECT_TRUE(rb.SetCumulativeLost(kMaxCumulativeLost)); } } // namespace diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc index 3d6e72f89e..cfa59d6f2d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc @@ -130,12 +130,12 @@ bool Rpsi::Create(uint8_t* packet, return true; } -void Rpsi::WithPayloadType(uint8_t payload) { +void Rpsi::SetPayloadType(uint8_t payload) { RTC_DCHECK_LE(payload, 0x7f); payload_type_ = payload; } -void Rpsi::WithPictureId(uint64_t picture_id) { +void Rpsi::SetPictureId(uint64_t picture_id) { picture_id_ = picture_id; block_length_ = CalculateBlockLength(RequiredBytes(picture_id_)); } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h index 49669f42bb..79b6acec3e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h @@ -30,8 +30,8 @@ class Rpsi : public Psfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithPayloadType(uint8_t payload); - void WithPictureId(uint64_t picture_id); + void SetPayloadType(uint8_t payload); + void SetPictureId(uint64_t picture_id); uint8_t payload_type() const { return payload_type_; } uint64_t picture_id() const { return picture_id_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc index 7ed8c2ac9b..9268e19f2c 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc @@ -46,10 +46,10 @@ TEST(RtcpPacketRpsiTest, Parse) { TEST(RtcpPacketRpsiTest, Create) { Rpsi rpsi; - rpsi.From(kSenderSsrc); - rpsi.To(kRemoteSsrc); - rpsi.WithPayloadType(kPayloadType); - rpsi.WithPictureId(kPictureId); + rpsi.SetSenderSsrc(kSenderSsrc); + rpsi.SetMediaSsrc(kRemoteSsrc); + rpsi.SetPayloadType(kPayloadType); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); @@ -59,8 +59,8 @@ TEST(RtcpPacketRpsiTest, Create) { TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) { Rpsi rpsi; - rpsi.From(kSenderSsrc); - rpsi.To(kRemoteSsrc); + rpsi.SetSenderSsrc(kSenderSsrc); + rpsi.SetMediaSsrc(kRemoteSsrc); rtc::Buffer packet = rpsi.Build(); packet[3]--; // Reduce size field by one word (4 bytes). @@ -71,9 +71,9 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) { TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) { Rpsi rpsi; - rpsi.From(kSenderSsrc); - rpsi.To(kRemoteSsrc); - rpsi.WithPictureId(kPictureId); + rpsi.SetSenderSsrc(kSenderSsrc); + rpsi.SetMediaSsrc(kRemoteSsrc); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); uint8_t* padding_bits = packet.data() + 12; uint8_t saved_padding_bits = *padding_bits; @@ -87,9 +87,9 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) { TEST(RtcpPacketRpsiTest, ParseFailsOnTooBigPadding) { Rpsi rpsi; - rpsi.From(kSenderSsrc); - rpsi.To(kRemoteSsrc); - rpsi.WithPictureId(1); // Small picture id that occupy just 1 byte. + rpsi.SetSenderSsrc(kSenderSsrc); + rpsi.SetMediaSsrc(kRemoteSsrc); + rpsi.SetPictureId(1); // Small picture id that occupy just 1 byte. rtc::Buffer packet = rpsi.Build(); uint8_t* padding_bits = packet.data() + 12; ASSERT_TRUE(test::ParseSinglePacket(packet, &rpsi)); @@ -112,7 +112,7 @@ TEST(RtcpPacketRpsiTest, WithOneByteNativeString) { // 1000001 (7 bits = 1 byte in native string). const uint64_t kPictureId = 0x41; const uint16_t kNumberOfValidBytes = 1; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); @@ -127,7 +127,7 @@ TEST(RtcpPacketRpsiTest, WithTwoByteNativeString) { // |1 0000001 (7 bits = 1 byte in native string). const uint64_t kPictureId = 0x81; const uint16_t kNumberOfValidBytes = 2; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); @@ -142,7 +142,7 @@ TEST(RtcpPacketRpsiTest, WithThreeByteNativeString) { // 10000|00 100000|0 1000000 (7 bits = 1 byte in native string). const uint64_t kPictureId = 0x102040; const uint16_t kNumberOfValidBytes = 3; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); @@ -157,7 +157,7 @@ TEST(RtcpPacketRpsiTest, WithFourByteNativeString) { // 1000|001 00001|01 100001|1 1000010 (7 bits = 1 byte in native string). const uint64_t kPictureId = 0x84161C2; const uint16_t kNumberOfValidBytes = 4; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); @@ -173,7 +173,7 @@ TEST(RtcpPacketRpsiTest, WithMaxPictureId) { // 11 111111|1 1111111 (7 bits = 1 byte in native string). const uint64_t kPictureId = 0xffffffffffffffff; const uint16_t kNumberOfValidBytes = 10; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); rtc::Buffer packet = rpsi.Build(); EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h index 3354f61df6..f123aaf4f1 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h @@ -36,7 +36,7 @@ class Rrtr { // Consumes Rrtr::kLength bytes. void Create(uint8_t* buffer) const; - void WithNtp(const NtpTime& ntp) { ntp_ = ntp; } + void SetNtp(NtpTime ntp) { ntp_ = ntp; } NtpTime ntp() const { return ntp_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc index 6536e06186..6dff06fd3a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc @@ -30,7 +30,7 @@ static_assert( TEST(RtcpPacketRrtrTest, Create) { uint8_t buffer[Rrtr::kLength]; Rrtr rrtr; - rrtr.WithNtp(NtpTime(kNtpSec, kNtpFrac)); + rrtr.SetNtp(NtpTime(kNtpSec, kNtpFrac)); rrtr.Create(buffer); EXPECT_EQ(0, memcmp(buffer, kBlock, kBlockSizeBytes)); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h index de1cf760bb..b34e4a02d6 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h @@ -27,8 +27,8 @@ class Rtpfb : public RtcpPacket { Rtpfb() : sender_ssrc_(0), media_ssrc_(0) {} ~Rtpfb() override {} - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } - void To(uint32_t ssrc) { media_ssrc_ = ssrc; } + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; } uint32_t sender_ssrc() const { return sender_ssrc_; } uint32_t media_ssrc() const { return media_ssrc_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc index 3a905ba315..9c44547aed 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc @@ -10,6 +10,8 @@ #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" +#include + #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" @@ -137,7 +139,7 @@ bool Sdes::Parse(const CommonHeader& packet) { return true; } -bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) { +bool Sdes::AddCName(uint32_t ssrc, std::string cname) { RTC_DCHECK_LE(cname.length(), 0xffu); if (chunks_.size() >= kMaxNumberOfChunks) { LOG(LS_WARNING) << "Max SDES chunks reached."; @@ -145,7 +147,7 @@ bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) { } Chunk chunk; chunk.ssrc = ssrc; - chunk.cname = cname; + chunk.cname = std::move(cname); chunks_.push_back(chunk); block_length_ += ChunkSize(chunk); return true; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h index 19d5b42b55..d9a9526733 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h @@ -36,7 +36,7 @@ class Sdes : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - bool WithCName(uint32_t ssrc, const std::string& cname); + bool AddCName(uint32_t ssrc, std::string cname); const std::vector& chunks() const { return chunks_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc index 53cda68b10..206558a8db 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc @@ -39,7 +39,7 @@ TEST(RtcpPacketSdesTest, CreateAndParseWithOneChunk) { const std::string kCname = "alice@host"; Sdes sdes; - EXPECT_TRUE(sdes.WithCName(kSenderSsrc, kCname)); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc, kCname)); rtc::Buffer packet = sdes.Build(); Sdes sdes_parsed; @@ -53,12 +53,12 @@ TEST(RtcpPacketSdesTest, CreateAndParseWithOneChunk) { TEST(RtcpPacketSdesTest, CreateAndParseWithMultipleChunks) { Sdes sdes; - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 0, "a")); - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 1, "ab")); - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 2, "abc")); - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 3, "abcd")); - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 4, "abcde")); - EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 5, "abcdef")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 0, "a")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 1, "ab")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 2, "abc")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 3, "abcd")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 4, "abcde")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 5, "abcdef")); rtc::Buffer packet = sdes.Build(); Sdes parsed; @@ -76,14 +76,14 @@ TEST(RtcpPacketSdesTest, CreateWithTooManyChunks) { uint32_t ssrc = kSenderSsrc + i; std::ostringstream oss; oss << "cname" << i; - EXPECT_TRUE(sdes.WithCName(ssrc, oss.str())); + EXPECT_TRUE(sdes.AddCName(ssrc, oss.str())); } - EXPECT_FALSE(sdes.WithCName(kSenderSsrc + kMaxChunks, "foo")); + EXPECT_FALSE(sdes.AddCName(kSenderSsrc + kMaxChunks, "foo")); } TEST(RtcpPacketSdesTest, CreateAndParseCnameItemWithEmptyString) { Sdes sdes; - EXPECT_TRUE(sdes.WithCName(kSenderSsrc, "")); + EXPECT_TRUE(sdes.AddCName(kSenderSsrc, "")); rtc::Buffer packet = sdes.Build(); Sdes parsed; @@ -224,7 +224,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) { Sdes source; const std::string kAlice = "alice@host"; const std::string kBob = "bob@host"; - source.WithCName(kSenderSsrc, kAlice); + source.AddCName(kSenderSsrc, kAlice); rtc::Buffer packet1 = source.Build(); Sdes middle; @@ -232,7 +232,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) { EXPECT_EQ(source.BlockLength(), middle.BlockLength()); - middle.WithCName(kSenderSsrc + 1, kBob); + middle.AddCName(kSenderSsrc + 1, kBob); rtc::Buffer packet2 = middle.Build(); Sdes destination; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc index 4795bf16e5..5e3a6cdff0 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc @@ -105,7 +105,7 @@ bool SenderReport::Create(uint8_t* packet, return true; } -bool SenderReport::WithReportBlock(const ReportBlock& block) { +bool SenderReport::AddReportBlock(const ReportBlock& block) { if (report_blocks_.size() >= kMaxNumberOfReportBlocks) { LOG(LS_WARNING) << "Max report blocks reached."; return false; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h index a544017f14..91a66b7e8a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h @@ -32,18 +32,18 @@ class SenderReport : public RtcpPacket { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } - void WithNtp(NtpTime ntp) { ntp_ = ntp; } - void WithRtpTimestamp(uint32_t rtp_timestamp) { + void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void SetNtp(NtpTime ntp) { ntp_ = ntp; } + void SetRtpTimestamp(uint32_t rtp_timestamp) { rtp_timestamp_ = rtp_timestamp; } - void WithPacketCount(uint32_t packet_count) { + void SetPacketCount(uint32_t packet_count) { sender_packet_count_ = packet_count; } - void WithOctetCount(uint32_t octet_count) { + void SetOctetCount(uint32_t octet_count) { sender_octet_count_ = octet_count; } - bool WithReportBlock(const ReportBlock& block); + bool AddReportBlock(const ReportBlock& block); void ClearReportBlocks() { report_blocks_.clear(); } uint32_t sender_ssrc() const { return sender_ssrc_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc index ac7fbcaa64..6611991fbc 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc @@ -39,11 +39,11 @@ const uint8_t kPacket[] = {0x80, 200, 0x00, 0x06, TEST(RtcpPacketSenderReportTest, CreateWithoutReportBlocks) { SenderReport sr; - sr.From(kSenderSsrc); - sr.WithNtp(kNtp); - sr.WithRtpTimestamp(kRtpTimestamp); - sr.WithPacketCount(kPacketCount); - sr.WithOctetCount(kOctetCount); + sr.SetSenderSsrc(kSenderSsrc); + sr.SetNtp(kNtp); + sr.SetRtpTimestamp(kRtpTimestamp); + sr.SetPacketCount(kPacketCount); + sr.SetOctetCount(kOctetCount); rtc::Buffer raw = sr.Build(); EXPECT_THAT(make_tuple(raw.data(), raw.size()), ElementsAreArray(kPacket)); @@ -63,11 +63,11 @@ TEST(RtcpPacketSenderReportTest, ParseWithoutReportBlocks) { TEST(RtcpPacketSenderReportTest, CreateAndParseWithOneReportBlock) { ReportBlock rb; - rb.To(kRemoteSsrc); + rb.SetMediaSsrc(kRemoteSsrc); SenderReport sr; - sr.From(kSenderSsrc); - EXPECT_TRUE(sr.WithReportBlock(rb)); + sr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(sr.AddReportBlock(rb)); rtc::Buffer raw = sr.Build(); SenderReport parsed; @@ -80,14 +80,14 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithOneReportBlock) { TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) { ReportBlock rb1; - rb1.To(kRemoteSsrc); + rb1.SetMediaSsrc(kRemoteSsrc); ReportBlock rb2; - rb2.To(kRemoteSsrc + 1); + rb2.SetMediaSsrc(kRemoteSsrc + 1); SenderReport sr; - sr.From(kSenderSsrc); - EXPECT_TRUE(sr.WithReportBlock(rb1)); - EXPECT_TRUE(sr.WithReportBlock(rb2)); + sr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(sr.AddReportBlock(rb1)); + EXPECT_TRUE(sr.AddReportBlock(rb2)); rtc::Buffer raw = sr.Build(); SenderReport parsed; @@ -101,15 +101,15 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) { TEST(RtcpPacketSenderReportTest, CreateWithTooManyReportBlocks) { SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); const size_t kMaxReportBlocks = (1 << 5) - 1; ReportBlock rb; for (size_t i = 0; i < kMaxReportBlocks; ++i) { - rb.To(kRemoteSsrc + i); - EXPECT_TRUE(sr.WithReportBlock(rb)); + rb.SetMediaSsrc(kRemoteSsrc + i); + EXPECT_TRUE(sr.AddReportBlock(rb)); } - rb.To(kRemoteSsrc + kMaxReportBlocks); - EXPECT_FALSE(sr.WithReportBlock(rb)); + rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks); + EXPECT_FALSE(sr.AddReportBlock(rb)); } } // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h index ce1dfe5bc5..3214b96dec 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h @@ -49,11 +49,13 @@ class Sli : public Psfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithPictureId(uint8_t picture_id, - uint16_t first_macroblock = 0, - uint16_t number_macroblocks = 0x1fff) { - items_.push_back( - Macroblocks(picture_id, first_macroblock, number_macroblocks)); + void AddPictureId(uint8_t picture_id) { + items_.emplace_back(picture_id, 0, 0x1fff); + } + void AddPictureId(uint8_t picture_id, + uint16_t first_macroblock, + uint16_t number_macroblocks) { + items_.emplace_back(picture_id, first_macroblock, number_macroblocks); } const std::vector& macroblocks() const { return items_; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc index dfb7d594b9..4b2fdea92b 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc @@ -42,9 +42,9 @@ constexpr uint8_t kPacket[] = {0x82, 206, 0x00, 0x03, TEST(RtcpPacketSliTest, Create) { Sli sli; - sli.From(kSenderSsrc); - sli.To(kRemoteSsrc); - sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb); + sli.SetSenderSsrc(kSenderSsrc); + sli.SetMediaSsrc(kRemoteSsrc); + sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb); rtc::Buffer packet = sli.Build(); @@ -67,9 +67,9 @@ TEST(RtcpPacketSliTest, Parse) { TEST(RtcpPacketSliTest, ParseFailsOnTooSmallPacket) { Sli sli; - sli.From(kSenderSsrc); - sli.To(kRemoteSsrc); - sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb); + sli.SetSenderSsrc(kSenderSsrc); + sli.SetMediaSsrc(kRemoteSsrc); + sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb); rtc::Buffer packet = sli.Build(); packet[3]--; // Decrease size by 1 word (4 bytes). diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc index f5683fb8f2..a0b785c596 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc @@ -70,7 +70,7 @@ bool Tmmbn::Parse(const CommonHeader& packet) { return true; } -void Tmmbn::WithTmmbr(const TmmbItem& item) { +void Tmmbn::AddTmmbr(const TmmbItem& item) { items_.push_back(item); } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h index a801816650..23db484edf 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h @@ -34,10 +34,7 @@ class Tmmbn : public Rtpfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead) { - WithTmmbr(TmmbItem(ssrc, bitrate_kbps * 1000, overhead)); - } - void WithTmmbr(const TmmbItem& item); + void AddTmmbr(const TmmbItem& item); const std::vector& items() const { return items_; } @@ -54,7 +51,7 @@ class Tmmbn : public Rtpfb { } // Media ssrc is unused, shadow base class setter and getter. - void To(uint32_t ssrc); + void SetMediaSsrc(uint32_t ssrc); uint32_t media_ssrc() const; std::vector items_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc index 3df6b5dcdd..e2a3aca43f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc @@ -35,8 +35,8 @@ const uint8_t kPacket[] = {0x84, 205, 0x00, 0x04, TEST(RtcpPacketTmmbnTest, Create) { Tmmbn tmmbn; - tmmbn.From(kSenderSsrc); - tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); + tmmbn.SetSenderSsrc(kSenderSsrc); + tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); rtc::Buffer packet = tmmbn.Build(); @@ -59,7 +59,7 @@ TEST(RtcpPacketTmmbnTest, Parse) { TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) { Tmmbn tmmbn; - tmmbn.From(kSenderSsrc); + tmmbn.SetSenderSsrc(kSenderSsrc); rtc::Buffer packet = tmmbn.Build(); Tmmbn parsed; @@ -71,9 +71,9 @@ TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) { TEST(RtcpPacketTmmbnTest, CreateAndParseWithTwoItems) { Tmmbn tmmbn; - tmmbn.From(kSenderSsrc); - tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); - tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40)); + tmmbn.SetSenderSsrc(kSenderSsrc); + tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); + tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40)); rtc::Buffer packet = tmmbn.Build(); Tmmbn parsed; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc index 6f957ae3e2..b4b8ccba4e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc @@ -71,7 +71,7 @@ bool Tmmbr::Parse(const CommonHeader& packet) { return true; } -void Tmmbr::WithTmmbr(const TmmbItem& item) { +void Tmmbr::AddTmmbr(const TmmbItem& item) { items_.push_back(item); } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h index 20ccdf2dfe..1db99f46ea 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h @@ -34,7 +34,7 @@ class Tmmbr : public Rtpfb { // Parse assumes header is already parsed and validated. bool Parse(const CommonHeader& packet); - void WithTmmbr(const TmmbItem& item); + void AddTmmbr(const TmmbItem& item); const std::vector& requests() const { return items_; } @@ -51,7 +51,7 @@ class Tmmbr : public Rtpfb { } // Media ssrc is unused, shadow base class setter. - void To(uint32_t ssrc); + void SetMediaSsrc(uint32_t ssrc); std::vector items_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc index 45f12c3e99..415ca94c90 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc @@ -35,8 +35,8 @@ const uint8_t kPacket[] = {0x83, 205, 0x00, 0x04, TEST(RtcpPacketTmmbrTest, Create) { Tmmbr tmmbr; - tmmbr.From(kSenderSsrc); - tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); + tmmbr.SetSenderSsrc(kSenderSsrc); + tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); rtc::Buffer packet = tmmbr.Build(); @@ -58,9 +58,9 @@ TEST(RtcpPacketTmmbrTest, Parse) { TEST(RtcpPacketTmmbrTest, CreateAndParseWithTwoEntries) { Tmmbr tmmbr; - tmmbr.From(kSenderSsrc); - tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); - tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1)); + tmmbr.SetSenderSsrc(kSenderSsrc); + tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead)); + tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1)); rtc::Buffer packet = tmmbr.Build(); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc index a4f0f6bbdc..9008aa0939 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc @@ -304,8 +304,8 @@ int64_t TransportFeedback::Unwrap(uint16_t sequence_number) { return last_seq_ + delta; } -void TransportFeedback::WithBase(uint16_t base_sequence, - int64_t ref_timestamp_us) { +void TransportFeedback::SetBase(uint16_t base_sequence, + int64_t ref_timestamp_us) { RTC_DCHECK_EQ(-1, base_seq_); RTC_DCHECK_NE(-1, ref_timestamp_us); base_seq_ = base_sequence; @@ -318,12 +318,12 @@ void TransportFeedback::WithBase(uint16_t base_sequence, last_timestamp_ = base_time_ * kBaseScaleFactor; } -void TransportFeedback::WithFeedbackSequenceNumber(uint8_t feedback_sequence) { +void TransportFeedback::SetFeedbackSequenceNumber(uint8_t feedback_sequence) { feedback_seq_ = feedback_sequence; } -bool TransportFeedback::WithReceivedPacket(uint16_t sequence_number, - int64_t timestamp) { +bool TransportFeedback::AddReceivedPacket(uint16_t sequence_number, + int64_t timestamp) { RTC_DCHECK_NE(-1, base_seq_); int64_t seq = Unwrap(sequence_number); if (seq != base_seq_ && seq <= last_seq_) diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h index 6a381efbbf..3d7ef51457 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h @@ -16,6 +16,7 @@ #include #include "webrtc/base/constructormagic.h" +#include "webrtc/base/deprecation.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h" namespace webrtc { @@ -33,13 +34,11 @@ class TransportFeedback : public Rtpfb { TransportFeedback(); ~TransportFeedback() override; - void WithPacketSenderSsrc(uint32_t ssrc) { From(ssrc); } - void WithMediaSourceSsrc(uint32_t ssrc) { To(ssrc); } - void WithBase(uint16_t base_sequence, // Seq# of first packet in this msg. - int64_t ref_timestamp_us); // Reference timestamp for this msg. - void WithFeedbackSequenceNumber(uint8_t feedback_sequence); + void SetBase(uint16_t base_sequence, // Seq# of first packet in this msg. + int64_t ref_timestamp_us); // Reference timestamp for this msg. + void SetFeedbackSequenceNumber(uint8_t feedback_sequence); // NOTE: This method requires increasing sequence numbers (excepting wraps). - bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us); + bool AddReceivedPacket(uint16_t sequence_number, int64_t timestamp_us); enum class StatusSymbol { kNotReceived, @@ -57,13 +56,27 @@ class TransportFeedback : public Rtpfb { // is relative the base time. std::vector GetReceiveDeltasUs() const; - uint32_t GetPacketSenderSsrc() const { return sender_ssrc(); } - uint32_t GetMediaSourceSsrc() const { return media_ssrc(); } - bool Parse(const CommonHeader& packet); static std::unique_ptr ParseFrom(const uint8_t* buffer, size_t length); + RTC_DEPRECATED + void WithPacketSenderSenderSsrc(uint32_t ssrc) { SetSenderSsrc(ssrc); } + RTC_DEPRECATED + void WithMediaSourceSsrc(uint32_t ssrc) { SetMediaSsrc(ssrc); } + RTC_DEPRECATED + void WithBase(uint16_t base_sequence, int64_t ref_timestamp_us) { + SetBase(base_sequence, ref_timestamp_us); + } + RTC_DEPRECATED + void WithFeedbackSequenceNumber(uint8_t feedback_sequence) { + SetFeedbackSequenceNumber(feedback_sequence); + } + RTC_DEPRECATED + bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us) { + return AddReceivedPacket(sequence_number, timestamp_us); + } + protected: bool Create(uint8_t* packet, size_t* position, diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc index 07f9049c85..5387330243 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc @@ -55,11 +55,11 @@ class FeedbackTester { expected_deltas_.clear(); feedback_.reset(new TransportFeedback()); - feedback_->WithBase(received_seq[0], received_ts[0]); + feedback_->SetBase(received_seq[0], received_ts[0]); int64_t last_time = feedback_->GetBaseTimeUs(); for (int i = 0; i < length; ++i) { int64_t time = received_ts[i]; - EXPECT_TRUE(feedback_->WithReceivedPacket(received_seq[i], time)); + EXPECT_TRUE(feedback_->AddReceivedPacket(received_seq[i], time)); if (last_time != -1) { int64_t delta = time - last_time; @@ -332,13 +332,13 @@ TEST(RtcpPacketTest, TransportFeedback_OneToTwoBitVectorSplit) { TEST(RtcpPacketTest, TransportFeedback_Aliasing) { TransportFeedback feedback; - feedback.WithBase(0, 0); + feedback.SetBase(0, 0); const int kSamples = 100; const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3; for (int i = 0; i < kSamples; ++i) - feedback.WithReceivedPacket(i, i * kTooSmallDelta); + feedback.AddReceivedPacket(i, i * kTooSmallDelta); feedback.Build(); std::vector deltas = feedback.GetReceiveDeltasUs(); @@ -358,48 +358,48 @@ TEST(RtcpPacketTest, TransportFeedback_Aliasing) { TEST(RtcpPacketTest, TransportFeedback_Limits) { // Sequence number wrap above 0x8000. std::unique_ptr packet(new TransportFeedback()); - packet->WithBase(0, 0); - EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); - EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000)); + packet->SetBase(0, 0); + EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); + EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000)); packet.reset(new TransportFeedback()); - packet->WithBase(0, 0); - EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); - EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000)); + packet->SetBase(0, 0); + EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); + EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, 1000)); // Packet status count max 0xFFFF. packet.reset(new TransportFeedback()); - packet->WithBase(0, 0); - EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); - EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000)); - EXPECT_TRUE(packet->WithReceivedPacket(0xFFFF, 2000)); - EXPECT_FALSE(packet->WithReceivedPacket(0, 3000)); + packet->SetBase(0, 0); + EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); + EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000)); + EXPECT_TRUE(packet->AddReceivedPacket(0xFFFF, 2000)); + EXPECT_FALSE(packet->AddReceivedPacket(0, 3000)); // Too large delta. packet.reset(new TransportFeedback()); - packet->WithBase(0, 0); + packet->SetBase(0, 0); int64_t kMaxPositiveTimeDelta = std::numeric_limits::max() * TransportFeedback::kDeltaScaleFactor; - EXPECT_FALSE(packet->WithReceivedPacket( + EXPECT_FALSE(packet->AddReceivedPacket( 1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor)); - EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxPositiveTimeDelta)); + EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxPositiveTimeDelta)); // Too large negative delta. packet.reset(new TransportFeedback()); - packet->WithBase(0, 0); + packet->SetBase(0, 0); int64_t kMaxNegativeTimeDelta = std::numeric_limits::min() * TransportFeedback::kDeltaScaleFactor; - EXPECT_FALSE(packet->WithReceivedPacket( + EXPECT_FALSE(packet->AddReceivedPacket( 1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor)); - EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxNegativeTimeDelta)); + EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxNegativeTimeDelta)); // Base time at maximum value. int64_t kMaxBaseTime = static_cast(TransportFeedback::kDeltaScaleFactor) * (1L << 8) * ((1L << 23) - 1); packet.reset(new TransportFeedback()); - packet->WithBase(0, kMaxBaseTime); - packet->WithReceivedPacket(0, kMaxBaseTime); + packet->SetBase(0, kMaxBaseTime); + packet->AddReceivedPacket(0, kMaxBaseTime); // Serialize and de-serialize (verify 24bit parsing). rtc::Buffer raw_packet = packet->Build(); packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); @@ -409,8 +409,8 @@ TEST(RtcpPacketTest, TransportFeedback_Limits) { int64_t kTooLargeBaseTime = kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8)); packet.reset(new TransportFeedback()); - packet->WithBase(0, kTooLargeBaseTime); - packet->WithReceivedPacket(0, kTooLargeBaseTime); + packet->SetBase(0, kTooLargeBaseTime); + packet->AddReceivedPacket(0, kTooLargeBaseTime); raw_packet = packet->Build(); packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs()); @@ -425,8 +425,8 @@ TEST(RtcpPacketTest, TransportFeedback_Padding) { const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4; TransportFeedback feedback; - feedback.WithBase(0, 0); - EXPECT_TRUE(feedback.WithReceivedPacket(0, 0)); + feedback.SetBase(0, 0); + EXPECT_TRUE(feedback.AddReceivedPacket(0, 0)); rtc::Buffer packet = feedback.Build(); EXPECT_EQ(kExpectedSizeWords * 4, packet.size()); @@ -466,10 +466,10 @@ TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) { for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) { TransportFeedback feedback; - feedback.WithBase(0, 0); + feedback.SetBase(0, 0); for (int i = 0; i < deltas; ++i) - feedback.WithReceivedPacket(i, i * 1000); - feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta); + feedback.AddReceivedPacket(i, i * 1000); + feedback.AddReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta); rtc::Buffer serialized_packet = feedback.Build(); std::unique_ptr deserialized_packet = diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h index 9e3e41995a..62c26fef37 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h @@ -35,8 +35,8 @@ class VoipMetric { // Consumes VoipMetric::kLength bytes. void Create(uint8_t* buffer) const; - void To(uint32_t ssrc) { ssrc_ = ssrc; } - void WithVoipMetric(const RTCPVoIPMetric& voip_metric) { + void SetMediaSsrc(uint32_t ssrc) { ssrc_ = ssrc; } + void SetVoipMetric(const RTCPVoIPMetric& voip_metric) { voip_metric_ = voip_metric; } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc index 44c82d67a9..d12889d7b9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc @@ -51,8 +51,8 @@ TEST(RtcpPacketVoipMetricTest, Create) { metric.JBmax = 0x6667; metric.JBabsMax = 0x7778; VoipMetric metric_block; - metric_block.To(kRemoteSsrc); - metric_block.WithVoipMetric(metric); + metric_block.SetMediaSsrc(kRemoteSsrc); + metric_block.SetVoipMetric(metric); metric_block.Create(buffer); EXPECT_EQ(0, memcmp(buffer, kBlock, kBlockSizeBytes)); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc index 58218ddbfd..082d1c7773 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc @@ -24,8 +24,8 @@ const uint32_t kSenderSsrc = 0x12345678; TEST(RtcpPacketTest, BuildWithTooSmallBuffer) { ReportBlock rb; ReceiverReport rr; - rr.From(kSenderSsrc); - EXPECT_TRUE(rr.WithReportBlock(rb)); + rr.SetSenderSsrc(kSenderSsrc); + EXPECT_TRUE(rr.AddReportBlock(rb)); const size_t kRrLength = 8; const size_t kReportBlockLength = 24; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index c7ca304210..6f8fe45e31 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -214,7 +214,7 @@ TEST_F(RtcpReceiverTest, TwoHalfValidRpsiAreIgnored) { TEST_F(RtcpReceiverTest, InjectRpsiPacket) { const uint64_t kPictureId = 0x123456789; rtcp::Rpsi rpsi; - rpsi.WithPictureId(kPictureId); + rpsi.SetPictureId(kPictureId); EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId)); InjectRtcpPacket(rpsi); @@ -226,7 +226,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacket) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); EXPECT_CALL(bandwidth_observer_, @@ -239,7 +239,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacket) { TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::SenderReport sr; - sr.From(kUnknownSenderSsrc); + sr.SetSenderSsrc(kUnknownSenderSsrc); // The parser will handle report blocks in Sender Report from other than his // expected peer. @@ -266,12 +266,12 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); rtcp::ReportBlock block; - block.To(kReceiverMainSsrc); - block.WithLastSr(sent_ntp); - block.WithDelayLastSr(kDelayNtp); - sr.WithReportBlock(block); + block.SetMediaSsrc(kReceiverMainSsrc); + block.SetLastSr(sent_ntp); + block.SetDelayLastSr(kDelayNtp); + sr.AddReportBlock(block); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); @@ -296,12 +296,12 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); rtcp::ReportBlock block; - block.To(kReceiverMainSsrc); - block.WithLastSr(sent_ntp); - block.WithDelayLastSr(kDelayNtp); - sr.WithReportBlock(block); + block.SetMediaSsrc(kReceiverMainSsrc); + block.SetLastSr(sent_ntp); + block.SetDelayLastSr(kDelayNtp); + sr.AddReportBlock(block); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); EXPECT_CALL(bandwidth_observer_, @@ -316,7 +316,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { TEST_F(RtcpReceiverTest, InjectRrPacket) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::ReceiverReport rr; - rr.From(kSenderSsrc); + rr.SetSenderSsrc(kSenderSsrc); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); EXPECT_CALL(bandwidth_observer_, @@ -334,10 +334,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacket) { TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::ReportBlock rb; - rb.To(kNotToUsSsrc); + rb.SetMediaSsrc(kNotToUsSsrc); rtcp::ReceiverReport rr; - rr.From(kSenderSsrc); - rr.WithReportBlock(rb); + rr.SetSenderSsrc(kSenderSsrc); + rr.AddReportBlock(rb); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); EXPECT_CALL(bandwidth_observer_, @@ -354,10 +354,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::ReportBlock rb; - rb.To(kReceiverMainSsrc); + rb.SetMediaSsrc(kReceiverMainSsrc); rtcp::ReceiverReport rr; - rr.From(kSenderSsrc); - rr.WithReportBlock(rb); + rr.SetSenderSsrc(kSenderSsrc); + rr.AddReportBlock(rb); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); EXPECT_CALL(bandwidth_observer_, @@ -377,19 +377,19 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { int64_t now = system_clock_.TimeInMilliseconds(); rtcp::ReportBlock rb1; - rb1.To(kReceiverMainSsrc); - rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); - rb1.WithFractionLost(10); + rb1.SetMediaSsrc(kReceiverMainSsrc); + rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); + rb1.SetFractionLost(10); rtcp::ReportBlock rb2; - rb2.To(kReceiverExtraSsrc); - rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); - rb2.WithFractionLost(0); + rb2.SetMediaSsrc(kReceiverExtraSsrc); + rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); + rb2.SetFractionLost(0); rtcp::ReceiverReport rr1; - rr1.From(kSenderSsrc); - rr1.WithReportBlock(rb1); - rr1.WithReportBlock(rb2); + rr1.SetSenderSsrc(kSenderSsrc); + rr1.AddReportBlock(rb1); + rr1.AddReportBlock(rb2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); EXPECT_CALL(bandwidth_observer_, @@ -405,21 +405,21 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { // Insert next receiver report with same ssrc but new values. rtcp::ReportBlock rb3; - rb3.To(kReceiverMainSsrc); - rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); - rb3.WithFractionLost(kFracLost[0]); - rb3.WithCumulativeLost(kCumLost[0]); + rb3.SetMediaSsrc(kReceiverMainSsrc); + rb3.SetExtHighestSeqNum(kSequenceNumbers[0]); + rb3.SetFractionLost(kFracLost[0]); + rb3.SetCumulativeLost(kCumLost[0]); rtcp::ReportBlock rb4; - rb4.To(kReceiverExtraSsrc); - rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); - rb4.WithFractionLost(kFracLost[1]); - rb4.WithCumulativeLost(kCumLost[1]); + rb4.SetMediaSsrc(kReceiverExtraSsrc); + rb4.SetExtHighestSeqNum(kSequenceNumbers[1]); + rb4.SetFractionLost(kFracLost[1]); + rb4.SetCumulativeLost(kCumLost[1]); rtcp::ReceiverReport rr2; - rr2.From(kSenderSsrc); - rr2.WithReportBlock(rb3); - rr2.WithReportBlock(rb4); + rr2.SetSenderSsrc(kSenderSsrc); + rr2.AddReportBlock(rb3); + rr2.AddReportBlock(rb4); // Advance time to make 1st sent time and 2nd sent time different. system_clock_.AdvanceTimeMilliseconds(500); @@ -454,13 +454,13 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { const uint8_t kFracLost[] = {20, 11}; rtcp::ReportBlock rb1; - rb1.To(kReceiverMainSsrc); - rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); - rb1.WithFractionLost(kFracLost[0]); - rb1.WithCumulativeLost(kCumLost[0]); + rb1.SetMediaSsrc(kReceiverMainSsrc); + rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); + rb1.SetFractionLost(kFracLost[0]); + rb1.SetCumulativeLost(kCumLost[0]); rtcp::ReceiverReport rr1; - rr1.From(kSenderSsrc); - rr1.WithReportBlock(rb1); + rr1.SetSenderSsrc(kSenderSsrc); + rr1.AddReportBlock(rb1); int64_t now = system_clock_.TimeInMilliseconds(); @@ -481,13 +481,13 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); rtcp::ReportBlock rb2; - rb2.To(kReceiverMainSsrc); - rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); - rb2.WithFractionLost(kFracLost[1]); - rb2.WithCumulativeLost(kCumLost[1]); + rb2.SetMediaSsrc(kReceiverMainSsrc); + rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); + rb2.SetFractionLost(kFracLost[1]); + rb2.SetCumulativeLost(kCumLost[1]); rtcp::ReceiverReport rr2; - rr2.From(kSenderSsrc2); - rr2.WithReportBlock(rb2); + rr2.SetSenderSsrc(kSenderSsrc2); + rr2.AddReportBlock(rb2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); EXPECT_CALL(bandwidth_observer_, @@ -519,11 +519,11 @@ TEST_F(RtcpReceiverTest, GetRtt) { -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); rtcp::ReportBlock rb; - rb.To(kReceiverMainSsrc); + rb.SetMediaSsrc(kReceiverMainSsrc); rtcp::ReceiverReport rr; - rr.From(kSenderSsrc); - rr.WithReportBlock(rb); + rr.SetSenderSsrc(kSenderSsrc); + rr.AddReportBlock(rb); int64_t now = system_clock_.TimeInMilliseconds(); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); @@ -544,10 +544,10 @@ TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { // App packets are ignored. TEST_F(RtcpReceiverTest, InjectApp) { rtcp::App app; - app.WithSubType(30); - app.WithName(0x17a177e); + app.SetSubType(30); + app.SetName(0x17a177e); const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; - app.WithData(kData, sizeof(kData)); + app.SetData(kData, sizeof(kData)); InjectRtcpPacket(app); } @@ -557,7 +557,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { MockRtcpCallbackImpl callback; rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); rtcp::Sdes sdes; - sdes.WithCName(kSenderSsrc, kCname); + sdes.AddCName(kSenderSsrc, kCname); EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc)); InjectRtcpPacket(sdes); @@ -570,7 +570,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { const char kCname[] = "alice@host"; rtcp::Sdes sdes; - sdes.WithCName(kSenderSsrc, kCname); + sdes.AddCName(kSenderSsrc, kCname); InjectRtcpPacket(sdes); @@ -579,7 +579,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { // Verify that BYE removes the CNAME. rtcp::Bye bye; - bye.From(kSenderSsrc); + bye.SetSenderSsrc(kSenderSsrc); InjectRtcpPacket(bye); @@ -588,13 +588,13 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { rtcp::ReportBlock rb1; - rb1.To(kReceiverMainSsrc); + rb1.SetMediaSsrc(kReceiverMainSsrc); rtcp::ReportBlock rb2; - rb2.To(kReceiverExtraSsrc); + rb2.SetMediaSsrc(kReceiverExtraSsrc); rtcp::ReceiverReport rr; - rr.From(kSenderSsrc); - rr.WithReportBlock(rb1); - rr.WithReportBlock(rb2); + rr.SetSenderSsrc(kSenderSsrc); + rr.AddReportBlock(rb1); + rr.AddReportBlock(rb2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); @@ -606,7 +606,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { // Verify that BYE removes the report blocks. rtcp::Bye bye; - bye.From(kSenderSsrc); + bye.SetSenderSsrc(kSenderSsrc); InjectRtcpPacket(bye); @@ -626,7 +626,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { TEST_F(RtcpReceiverTest, InjectPliPacket) { rtcp::Pli pli; - pli.To(kReceiverMainSsrc); + pli.SetMediaSsrc(kReceiverMainSsrc); EXPECT_CALL( packet_type_counter_observer_, @@ -639,7 +639,7 @@ TEST_F(RtcpReceiverTest, InjectPliPacket) { TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { rtcp::Pli pli; - pli.To(kNotToUsSsrc); + pli.SetMediaSsrc(kNotToUsSsrc); EXPECT_CALL( packet_type_counter_observer_, @@ -651,7 +651,7 @@ TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { TEST_F(RtcpReceiverTest, InjectFirPacket) { rtcp::Fir fir; - fir.WithRequestTo(kReceiverMainSsrc, 13); + fir.AddRequestTo(kReceiverMainSsrc, 13); EXPECT_CALL( packet_type_counter_observer_, @@ -664,7 +664,7 @@ TEST_F(RtcpReceiverTest, InjectFirPacket) { TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { rtcp::Fir fir; - fir.WithRequestTo(kNotToUsSsrc, 13); + fir.AddRequestTo(kNotToUsSsrc, 13); EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); InjectRtcpPacket(fir); @@ -673,7 +673,7 @@ TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { TEST_F(RtcpReceiverTest, InjectSliPacket) { const uint8_t kPictureId = 40; rtcp::Sli sli; - sli.WithPictureId(kPictureId); + sli.AddPictureId(kPictureId); EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, kPictureId)); InjectRtcpPacket(sli); @@ -681,7 +681,7 @@ TEST_F(RtcpReceiverTest, InjectSliPacket) { TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); + xr.SetSenderSsrc(kSenderSsrc); InjectRtcpPacket(xr); } @@ -690,23 +690,23 @@ TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { const uint8_t kLossRate = 123; rtcp::VoipMetric voip_metric; - voip_metric.To(kReceiverMainSsrc); + voip_metric.SetMediaSsrc(kReceiverMainSsrc); RTCPVoIPMetric metric; metric.lossRate = kLossRate; - voip_metric.WithVoipMetric(metric); + voip_metric.SetVoipMetric(metric); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithVoipMetric(voip_metric); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddVoipMetric(voip_metric); InjectRtcpPacket(xr); } TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { rtcp::VoipMetric voip_metric; - voip_metric.To(kNotToUsSsrc); + voip_metric.SetMediaSsrc(kNotToUsSsrc); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithVoipMetric(voip_metric); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddVoipMetric(voip_metric); InjectRtcpPacket(xr); } @@ -714,10 +714,10 @@ TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { const NtpTime kNtp(0x10203, 0x40506); rtcp::Rrtr rrtr; - rrtr.WithNtp(kNtp); + rrtr.SetNtp(kNtp); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithRrtr(rrtr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddRrtr(rrtr); RtcpReceiveTimeInfo rrtime; EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); @@ -739,10 +739,10 @@ TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { rtcp_receiver_.SetRtcpXrRrtrStatus(true); rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kNotToUsSsrc, 0x12345, 0x67890); + dlrr.AddDlrrItem(kNotToUsSsrc, 0x12345, 0x67890); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithDlrr(dlrr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddDlrr(dlrr); InjectRtcpPacket(xr); @@ -758,10 +758,10 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); + dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithDlrr(dlrr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddDlrr(dlrr); InjectRtcpPacket(xr); @@ -777,12 +777,12 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { rtcp_receiver_.SetRtcpXrRrtrStatus(true); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); + xr.SetSenderSsrc(kSenderSsrc); rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); - dlrr.WithDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890); - dlrr.WithDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890); - xr.WithDlrr(dlrr); + dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay); + dlrr.AddDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890); + dlrr.AddDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890); + xr.AddDlrr(dlrr); InjectRtcpPacket(xr); @@ -798,14 +798,14 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { rtcp::Rrtr rrtr; rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); + dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); rtcp::VoipMetric metric; - metric.To(kReceiverMainSsrc); + metric.SetMediaSsrc(kReceiverMainSsrc); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithRrtr(rrtr); - xr.WithDlrr(dlrr); - xr.WithVoipMetric(metric); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddRrtr(rrtr); + xr.AddDlrr(dlrr); + xr.AddVoipMetric(metric); InjectRtcpPacket(xr); @@ -820,14 +820,14 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { rtcp::Rrtr rrtr; rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); + dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890); rtcp::VoipMetric metric; - metric.To(kReceiverMainSsrc); + metric.SetMediaSsrc(kReceiverMainSsrc); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithRrtr(rrtr); - xr.WithDlrr(dlrr); - xr.WithVoipMetric(metric); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddRrtr(rrtr); + xr.AddDlrr(dlrr); + xr.AddVoipMetric(metric); rtc::Buffer packet = xr.Build(); // Modify the DLRR block to have an unsupported block type, from 5 to 6. @@ -861,10 +861,10 @@ TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); + dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithDlrr(dlrr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddDlrr(dlrr); InjectRtcpPacket(xr); @@ -884,10 +884,10 @@ TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { rtcp_receiver_.SetRtcpXrRrtrStatus(true); rtcp::Dlrr dlrr; - dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); + dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithDlrr(dlrr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddDlrr(dlrr); InjectRtcpPacket(xr); @@ -906,10 +906,10 @@ TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { const uint32_t kNtpMid = CompactNtp(kNtp); rtcp::Rrtr rrtr; - rrtr.WithNtp(kNtp); + rrtr.SetNtp(kNtp); rtcp::ExtendedReports xr; - xr.From(kSenderSsrc); - xr.WithRrtr(rrtr); + xr.SetSenderSsrc(kSenderSsrc); + xr.AddRrtr(rrtr); InjectRtcpPacket(xr); @@ -935,11 +935,11 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { // Add a RR and advance the clock just enough to not trigger a timeout. rtcp::ReportBlock rb1; - rb1.To(kReceiverMainSsrc); - rb1.WithExtHighestSeqNum(kSequenceNumber); + rb1.SetMediaSsrc(kReceiverMainSsrc); + rb1.SetExtHighestSeqNum(kSequenceNumber); rtcp::ReceiverReport rr1; - rr1.From(kSenderSsrc); - rr1.WithReportBlock(rb1); + rr1.SetSenderSsrc(kSenderSsrc); + rr1.AddReportBlock(rb1); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); @@ -970,11 +970,11 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { // Add a new RR with increase sequence number to reset timers. rtcp::ReportBlock rb2; - rb2.To(kReceiverMainSsrc); - rb2.WithExtHighestSeqNum(kSequenceNumber + 1); + rb2.SetMediaSsrc(kReceiverMainSsrc); + rb2.SetExtHighestSeqNum(kSequenceNumber + 1); rtcp::ReceiverReport rr2; - rr2.From(kSenderSsrc); - rr2.WithReportBlock(rb2); + rr2.SetSenderSsrc(kSenderSsrc); + rr2.AddReportBlock(rb2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); @@ -1004,10 +1004,10 @@ TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { const uint32_t kBitrateBps = 30000; rtcp::Tmmbr tmmbr; - tmmbr.From(kSenderSsrc); - tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0)); + tmmbr.SetSenderSsrc(kSenderSsrc); + tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0)); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); rtcp::CompoundPacket compound; compound.Append(&sr); compound.Append(&tmmbr); @@ -1027,11 +1027,11 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { const uint32_t kBitrateBps = 30000; rtcp::Tmmbr tmmbr; - tmmbr.From(kSenderSsrc); - tmmbr.WithTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0)); + tmmbr.SetSenderSsrc(kSenderSsrc); + tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0)); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); rtcp::CompoundPacket compound; compound.Append(&sr); compound.Append(&tmmbr); @@ -1046,10 +1046,10 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { rtcp::Tmmbr tmmbr; - tmmbr.From(kSenderSsrc); - tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); + tmmbr.SetSenderSsrc(kSenderSsrc); + tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); rtcp::SenderReport sr; - sr.From(kSenderSsrc); + sr.SetSenderSsrc(kSenderSsrc); rtcp::CompoundPacket compound; compound.Append(&sr); compound.Append(&tmmbr); @@ -1067,10 +1067,10 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { rtcp::Tmmbr tmmbr; - tmmbr.From(ssrc); - tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0)); + tmmbr.SetSenderSsrc(ssrc); + tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0)); rtcp::SenderReport sr; - sr.From(ssrc); + sr.SetSenderSsrc(ssrc); rtcp::CompoundPacket compound; compound.Append(&sr); compound.Append(&tmmbr); @@ -1108,15 +1108,15 @@ TEST_F(RtcpReceiverTest, Callbacks) { // First packet, all numbers should just propagate. rtcp::ReportBlock rb1; - rb1.To(kReceiverMainSsrc); - rb1.WithExtHighestSeqNum(kSequenceNumber); - rb1.WithFractionLost(kFractionLoss); - rb1.WithCumulativeLost(kCumulativeLoss); - rb1.WithJitter(kJitter); + rb1.SetMediaSsrc(kReceiverMainSsrc); + rb1.SetExtHighestSeqNum(kSequenceNumber); + rb1.SetFractionLost(kFractionLoss); + rb1.SetCumulativeLost(kCumulativeLoss); + rb1.SetJitter(kJitter); rtcp::ReceiverReport rr1; - rr1.From(kSenderSsrc); - rr1.WithReportBlock(rb1); + rr1.SetSenderSsrc(kSenderSsrc); + rr1.AddReportBlock(rb1); EXPECT_CALL( callback, StatisticsUpdated( @@ -1134,15 +1134,15 @@ TEST_F(RtcpReceiverTest, Callbacks) { // Add arbitrary numbers, callback should not be called. rtcp::ReportBlock rb2; - rb2.To(kReceiverMainSsrc); - rb2.WithExtHighestSeqNum(kSequenceNumber + 1); - rb2.WithFractionLost(42); - rb2.WithCumulativeLost(137); - rb2.WithJitter(4711); + rb2.SetMediaSsrc(kReceiverMainSsrc); + rb2.SetExtHighestSeqNum(kSequenceNumber + 1); + rb2.SetFractionLost(42); + rb2.SetCumulativeLost(137); + rb2.SetJitter(4711); rtcp::ReceiverReport rr2; - rr2.From(kSenderSsrc); - rr2.WithReportBlock(rb2); + rr2.SetSenderSsrc(kSenderSsrc); + rr2.AddReportBlock(rb2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); @@ -1152,10 +1152,10 @@ TEST_F(RtcpReceiverTest, Callbacks) { TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { rtcp::TransportFeedback packet; - packet.To(kReceiverMainSsrc); - packet.From(kSenderSsrc); - packet.WithBase(1, 1000); - packet.WithReceivedPacket(1, 1000); + packet.SetMediaSsrc(kReceiverMainSsrc); + packet.SetSenderSsrc(kSenderSsrc); + packet.SetBase(1, 1000); + packet.AddReceivedPacket(1, 1000); EXPECT_CALL( transport_feedback_observer_, @@ -1168,8 +1168,8 @@ TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { TEST_F(RtcpReceiverTest, ReceivesRemb) { const uint32_t kBitrateBps = 500000; rtcp::Remb remb; - remb.From(kSenderSsrc); - remb.WithBitrateBps(kBitrateBps); + remb.SetSenderSsrc(kSenderSsrc); + remb.SetBitrateBps(kBitrateBps); EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); InjectRtcpPacket(remb); @@ -1178,15 +1178,15 @@ TEST_F(RtcpReceiverTest, ReceivesRemb) { TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { // Send a compound packet with a TransportFeedback followed by something else. rtcp::TransportFeedback packet; - packet.To(kReceiverMainSsrc); - packet.From(kSenderSsrc); - packet.WithBase(1, 1000); - packet.WithReceivedPacket(1, 1000); + packet.SetMediaSsrc(kReceiverMainSsrc); + packet.SetSenderSsrc(kSenderSsrc); + packet.SetBase(1, 1000); + packet.AddReceivedPacket(1, 1000); static uint32_t kBitrateBps = 50000; rtcp::Remb remb; - remb.From(kSenderSsrc); - remb.WithBitrateBps(kBitrateBps); + remb.SetSenderSsrc(kSenderSsrc); + remb.SetBitrateBps(kBitrateBps); rtcp::CompoundPacket compound; compound.Append(&packet); compound.Append(&remb); @@ -1214,9 +1214,9 @@ TEST_F(RtcpReceiverTest, Nack) { nack_set.insert(std::begin(kNackList2), std::end(kNackList2)); rtcp::Nack nack; - nack.From(kSenderSsrc); - nack.To(kReceiverMainSsrc); - nack.WithList(kNackList1, kNackListLength1); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kReceiverMainSsrc); + nack.SetPacketIds(kNackList1, kNackListLength1); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1))); EXPECT_CALL( @@ -1229,9 +1229,9 @@ TEST_F(RtcpReceiverTest, Nack) { InjectRtcpPacket(nack); rtcp::Nack nack2; - nack2.From(kSenderSsrc); - nack2.To(kReceiverMainSsrc); - nack2.WithList(kNackList2, kNackListLength2); + nack2.SetSenderSsrc(kSenderSsrc); + nack2.SetMediaSsrc(kReceiverMainSsrc); + nack2.SetPacketIds(kNackList2, kNackListLength2); EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList2))); EXPECT_CALL(packet_type_counter_observer_, RtcpPacketTypesCounterUpdated( @@ -1248,9 +1248,9 @@ TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); rtcp::Nack nack; - nack.From(kSenderSsrc); - nack.To(kNotToUsSsrc); - nack.WithList(kNackList1, kNackListLength1); + nack.SetSenderSsrc(kSenderSsrc); + nack.SetMediaSsrc(kNotToUsSsrc); + nack.SetPacketIds(kNackList1, kNackListLength1); EXPECT_CALL(packet_type_counter_observer_, RtcpPacketTypesCounterUpdated( @@ -1260,8 +1260,8 @@ TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { TEST_F(RtcpReceiverTest, ForceSenderReport) { rtcp::RapidResyncRequest rr; - rr.From(kSenderSsrc); - rr.To(kReceiverMainSsrc); + rr.SetSenderSsrc(kSenderSsrc); + rr.SetMediaSsrc(kReceiverMainSsrc); EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport()); InjectRtcpPacket(rr); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc index 7762e66bf2..859ac0549b 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc @@ -449,14 +449,14 @@ std::unique_ptr RTCPSender::BuildSR(const RtcpContext& ctx) { (ctx.feedback_state_.frequency_hz / 1000); rtcp::SenderReport* report = new rtcp::SenderReport(); - report->From(ssrc_); - report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); - report->WithRtpTimestamp(rtp_timestamp); - report->WithPacketCount(ctx.feedback_state_.packets_sent); - report->WithOctetCount(ctx.feedback_state_.media_bytes_sent); + report->SetSenderSsrc(ssrc_); + report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); + report->SetRtpTimestamp(rtp_timestamp); + report->SetPacketCount(ctx.feedback_state_.packets_sent); + report->SetOctetCount(ctx.feedback_state_.media_bytes_sent); for (auto it : report_blocks_) - report->WithReportBlock(it.second); + report->AddReportBlock(it.second); report_blocks_.clear(); @@ -469,19 +469,19 @@ std::unique_ptr RTCPSender::BuildSDES( RTC_CHECK_LT(length_cname, static_cast(RTCP_CNAME_SIZE)); rtcp::Sdes* sdes = new rtcp::Sdes(); - sdes->WithCName(ssrc_, cname_); + sdes->AddCName(ssrc_, cname_); for (const auto it : csrc_cnames_) - sdes->WithCName(it.first, it.second); + sdes->AddCName(it.first, it.second); return std::unique_ptr(sdes); } std::unique_ptr RTCPSender::BuildRR(const RtcpContext& ctx) { rtcp::ReceiverReport* report = new rtcp::ReceiverReport(); - report->From(ssrc_); + report->SetSenderSsrc(ssrc_); for (auto it : report_blocks_) - report->WithReportBlock(it.second); + report->AddReportBlock(it.second); report_blocks_.clear(); return std::unique_ptr(report); @@ -489,8 +489,8 @@ std::unique_ptr RTCPSender::BuildRR(const RtcpContext& ctx) { std::unique_ptr RTCPSender::BuildPLI(const RtcpContext& ctx) { rtcp::Pli* pli = new rtcp::Pli(); - pli->From(ssrc_); - pli->To(remote_ssrc_); + pli->SetSenderSsrc(ssrc_); + pli->SetMediaSsrc(remote_ssrc_); TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCPSender::PLI"); @@ -506,8 +506,8 @@ std::unique_ptr RTCPSender::BuildFIR(const RtcpContext& ctx) { ++sequence_number_fir_; // Do not increase if repetition. rtcp::Fir* fir = new rtcp::Fir(); - fir->From(ssrc_); - fir->WithRequestTo(remote_ssrc_, sequence_number_fir_); + fir->SetSenderSsrc(ssrc_); + fir->AddRequestTo(remote_ssrc_, sequence_number_fir_); TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCPSender::FIR"); @@ -527,10 +527,10 @@ std::unique_ptr RTCPSender::BuildFIR(const RtcpContext& ctx) { */ std::unique_ptr RTCPSender::BuildSLI(const RtcpContext& ctx) { rtcp::Sli* sli = new rtcp::Sli(); - sli->From(ssrc_); - sli->To(remote_ssrc_); + sli->SetSenderSsrc(ssrc_); + sli->SetMediaSsrc(remote_ssrc_); // Crop picture id to 6 least significant bits. - sli->WithPictureId(ctx.picture_id_ & 0x3F); + sli->AddPictureId(ctx.picture_id_ & 0x3F); return std::unique_ptr(sli); } @@ -553,10 +553,10 @@ std::unique_ptr RTCPSender::BuildRPSI( return nullptr; rtcp::Rpsi* rpsi = new rtcp::Rpsi(); - rpsi->From(ssrc_); - rpsi->To(remote_ssrc_); - rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type); - rpsi->WithPictureId(ctx.picture_id_); + rpsi->SetSenderSsrc(ssrc_); + rpsi->SetMediaSsrc(remote_ssrc_); + rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type); + rpsi->SetPictureId(ctx.picture_id_); return std::unique_ptr(rpsi); } @@ -564,10 +564,9 @@ std::unique_ptr RTCPSender::BuildRPSI( std::unique_ptr RTCPSender::BuildREMB( const RtcpContext& ctx) { rtcp::Remb* remb = new rtcp::Remb(); - remb->From(ssrc_); - for (uint32_t ssrc : remb_ssrcs_) - remb->AppliesTo(ssrc); - remb->WithBitrateBps(remb_bitrate_); + remb->SetSenderSsrc(ssrc_); + remb->SetBitrateBps(remb_bitrate_); + remb->SetSsrcs(remb_ssrcs_); TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCPSender::REMB"); @@ -626,12 +625,12 @@ std::unique_ptr RTCPSender::BuildTMMBR( return nullptr; rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr(); - tmmbr->From(ssrc_); + tmmbr->SetSenderSsrc(ssrc_); rtcp::TmmbItem request; request.set_ssrc(remote_ssrc_); request.set_bitrate_bps(tmmbr_send_bps_); request.set_packet_overhead(packet_oh_send_); - tmmbr->WithTmmbr(request); + tmmbr->AddTmmbr(request); return std::unique_ptr(tmmbr); } @@ -639,10 +638,10 @@ std::unique_ptr RTCPSender::BuildTMMBR( std::unique_ptr RTCPSender::BuildTMMBN( const RtcpContext& ctx) { rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn(); - tmmbn->From(ssrc_); + tmmbn->SetSenderSsrc(ssrc_); for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) { if (tmmbr.bitrate_bps() > 0) { - tmmbn->WithTmmbr(tmmbr); + tmmbn->AddTmmbr(tmmbr); } } @@ -651,10 +650,10 @@ std::unique_ptr RTCPSender::BuildTMMBN( std::unique_ptr RTCPSender::BuildAPP(const RtcpContext& ctx) { rtcp::App* app = new rtcp::App(); - app->From(ssrc_); - app->WithSubType(app_sub_type_); - app->WithName(app_name_); - app->WithData(app_data_.get(), app_length_); + app->SetSsrc(ssrc_); + app->SetSubType(app_sub_type_); + app->SetName(app_name_); + app->SetData(app_data_.get(), app_length_); return std::unique_ptr(app); } @@ -662,9 +661,9 @@ std::unique_ptr RTCPSender::BuildAPP(const RtcpContext& ctx) { std::unique_ptr RTCPSender::BuildNACK( const RtcpContext& ctx) { rtcp::Nack* nack = new rtcp::Nack(); - nack->From(ssrc_); - nack->To(remote_ssrc_); - nack->WithList(ctx.nack_list_, ctx.nack_size_); + nack->SetSenderSsrc(ssrc_); + nack->SetMediaSsrc(remote_ssrc_); + nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_); // Report stats. NACKStringBuilder stringBuilder; @@ -687,9 +686,8 @@ std::unique_ptr RTCPSender::BuildNACK( std::unique_ptr RTCPSender::BuildBYE(const RtcpContext& ctx) { rtcp::Bye* bye = new rtcp::Bye(); - bye->From(ssrc_); - for (uint32_t csrc : csrcs_) - bye->WithCsrc(csrc); + bye->SetSenderSsrc(ssrc_); + bye->SetCsrcs(csrcs_); return std::unique_ptr(bye); } @@ -698,12 +696,12 @@ std::unique_ptr RTCPSender::BuildReceiverReferenceTime( const RtcpContext& ctx) { rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); - xr->From(ssrc_); + xr->SetSenderSsrc(ssrc_); rtcp::Rrtr rrtr; - rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); + rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_)); - xr->WithRrtr(rrtr); + xr->AddRrtr(rrtr); // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP? @@ -713,13 +711,13 @@ std::unique_ptr RTCPSender::BuildReceiverReferenceTime( std::unique_ptr RTCPSender::BuildDlrr( const RtcpContext& ctx) { rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); - xr->From(ssrc_); + xr->SetSenderSsrc(ssrc_); rtcp::Dlrr dlrr; const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr; - dlrr.WithDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); + dlrr.AddDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR); - xr->WithDlrr(dlrr); + xr->AddDlrr(dlrr); return std::unique_ptr(xr); } @@ -728,13 +726,13 @@ std::unique_ptr RTCPSender::BuildDlrr( std::unique_ptr RTCPSender::BuildVoIPMetric( const RtcpContext& context) { rtcp::ExtendedReports* xr = new rtcp::ExtendedReports(); - xr->From(ssrc_); + xr->SetSenderSsrc(ssrc_); rtcp::VoipMetric voip; - voip.To(remote_ssrc_); - voip.WithVoipMetric(xr_voip_metric_); + voip.SetMediaSsrc(remote_ssrc_); + voip.SetVoipMetric(xr_voip_metric_); - xr->WithVoipMetric(voip); + xr->AddVoipMetric(voip); return std::unique_ptr(xr); } @@ -905,16 +903,16 @@ bool RTCPSender::AddReportBlock(const FeedbackState& feedback_state, } RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end()); rtcp::ReportBlock* block = &report_blocks_[ssrc]; - block->To(ssrc); - block->WithFractionLost(stats.fraction_lost); - if (!block->WithCumulativeLost(stats.cumulative_lost)) { + block->SetMediaSsrc(ssrc); + block->SetFractionLost(stats.fraction_lost); + if (!block->SetCumulativeLost(stats.cumulative_lost)) { report_blocks_.erase(ssrc); LOG(LS_WARNING) << "Cumulative lost is oversized."; return false; } - block->WithExtHighestSeqNum(stats.extended_max_sequence_number); - block->WithJitter(stats.jitter); - block->WithLastSr(feedback_state.remote_sr); + block->SetExtHighestSeqNum(stats.extended_max_sequence_number); + block->SetJitter(stats.jitter); + block->SetLastSr(feedback_state.remote_sr); // TODO(sprang): Do we really need separate time stamps for each report? // Get our NTP as late as possible to avoid a race. @@ -934,7 +932,7 @@ bool RTCPSender::AddReportBlock(const FeedbackState& feedback_state, receiveTime <<= 16; receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16; - block->WithDelayLastSr(now - receiveTime); + block->SetDelayLastSr(now - receiveTime); } return true; } diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index dfd928c8e2..b43f95d973 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -216,9 +216,9 @@ class RtpRtcpImplTest : public ::testing::Test { uint16_t list[1]; list[0] = sequence_number; const uint16_t kListLength = sizeof(list) / sizeof(list[0]); - nack.From(sender ? kReceiverSsrc : kSenderSsrc); - nack.To(sender ? kSenderSsrc : kReceiverSsrc); - nack.WithList(list, kListLength); + nack.SetSenderSsrc(sender ? kReceiverSsrc : kSenderSsrc); + nack.SetMediaSsrc(sender ? kSenderSsrc : kReceiverSsrc); + nack.SetPacketIds(list, kListLength); rtc::Buffer packet = nack.Build(); EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.data(), packet.size())); diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index 14e370e251..b3d667ef72 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -531,10 +531,10 @@ TEST_F(EndToEndTest, ReceivesNackAndRetransmitsAudio) { } else { // Send a NACK as often as necessary until retransmission is received. rtcp::Nack nack; - nack.From(local_ssrc_); - nack.To(remote_ssrc_); + nack.SetSenderSsrc(local_ssrc_); + nack.SetMediaSsrc(remote_ssrc_); uint16_t nack_list[] = {*sequence_number_to_retransmit_}; - nack.WithList(nack_list, 1); + nack.SetPacketIds(nack_list, 1); rtc::Buffer buffer = nack.Build(); EXPECT_TRUE(receive_transport_->SendRtcp(buffer.data(), buffer.size()));