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..03a1c4f728 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 WithPacketSenderSsrc(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()));