admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unify rtcp packet setters

Browse Source 
Renamed setters in rtcp classes
from WithField to SetField
from WithItem to AddItem or SetItems
from From to SetSenderSsrc
from To to SetMediaSsrc
Some redundant or unsued setters removed.
Pass-by-const& replaced with pass-by-value when appropriate.

BUG=webrtc:5260

Review-Url: https://codereview.webrtc.org/2348623003
Cr-Commit-Position: refs/heads/master@{#14393}
This commit is contained in:
danilchap 2016-09-27 01:37:42 -07:00 committed by Commit bot
parent 4ecd9700ee
commit 20e77c7b8a
69 changed files with 664 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
webrtc/call/rtc_event_log_unittest.cc
View File

@ -139,15 +139,14 @@ RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
rtc::Buffer GenerateRtcpPacket(Random* prng) {
rtcp::ReportBlock report_block;
report_block.To(prng->Rand<uint32_t>()); // Remote SSRC.
report_block.WithFractionLost(prng->Rand(50));
report_block.SetMediaSsrc(prng->Rand<uint32_t>()); // Remote SSRC.
report_block.SetFractionLost(prng->Rand(50));
rtcp::SenderReport sender_report;
sender_report.From(prng->Rand<uint32_t>()); // Sender SSRC.
sender_report.WithNtp(
NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
sender_report.WithPacketCount(prng->Rand<uint32_t>());
sender_report.WithReportBlock(report_block);
sender_report.SetSenderSsrc(prng->Rand<uint32_t>());
sender_report.SetNtp(NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
sender_report.SetPacketCount(prng->Rand<uint32_t>());
sender_report.AddReportBlock(report_block);
return sender_report.Build();
}

2
webrtc/modules/pacing/packet_router.cc
View File

@ -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;
}

10
webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
View File

@ -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<uint16_t>(window_start_seq_ & 0xFFFF),
it->second * 1000);
feedback_packet->WithFeedbackSequenceNumber(feedback_sequence_++);
feedback_packet->SetBase(static_cast<uint16_t>(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<uint16_t>(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.

18
webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc
View File

@ -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<rtcp::TransportFeedback::StatusSymbol> 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<rtcp::TransportFeedback::StatusSymbol> 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<rtcp::TransportFeedback::StatusSymbol> 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<rtcp::TransportFeedback::StatusSymbol> 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<rtcp::TransportFeedback::StatusSymbol> 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<rtcp::TransportFeedback::StatusSymbol> 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<int64_t> 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<int64_t> 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<int64_t> delta_vec = packet->GetReceiveDeltasUs();
EXPECT_EQ(2u, delta_vec.size());

50
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc
View File

@ -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<rtcp::TransportFeedback> 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<rtcp::TransportFeedback> 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());

12
webrtc/modules/rtp_rtcp/source/rtcp_packet.h
View File

@ -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.

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc
View File

@ -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

8
webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h
View File

@ -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_; }

14
webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc
View File

@ -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();

14
webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc
View File

@ -10,6 +10,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
#include <utility>
#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<uint32_t> 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 {

6
webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h
View File

@ -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<uint32_t> csrcs);
void SetReason(std::string reason);
uint32_t sender_ssrc() const { return sender_ssrc_; }
const std::vector<uint32_t>& csrcs() const { return csrcs_; }

36
webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc
View File

@ -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<uint32_t>(kMaxCsrcs, kCsrc1)));
EXPECT_FALSE(bye.SetCsrcs(std::vector<uint32_t>(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

22
webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
View File

@ -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);

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc
View File

@ -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

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h
View File

@ -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<ReceiveTimeInfo>& sub_blocks() const { return sub_blocks_; }

8
webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc
View File

@ -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);

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
View File

@ -10,6 +10,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
#include <utility>
#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<uint32_t> 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;
}

8
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
View File

@ -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<uint32_t> jitter_values);
const std::vector<uint32_t>& jitters() { return inter_arrival_jitters_; }
const std::vector<uint32_t>& 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 {

22
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc
View File

@ -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<uint32_t>(kMaxItems + 1, kJitter1)));
EXPECT_TRUE(ij.SetJitterValues(std::vector<uint32_t>(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;

6
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
View File

@ -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;

8
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
View File

@ -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<Rrtr>& rrtrs() const { return rrtr_blocks_; }

76
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc
View File

@ -110,7 +110,7 @@ NtpTime RtcpPacketExtendedReportsTest::Rand<NtpTime>() {
template <>
Rrtr RtcpPacketExtendedReportsTest::Rand<Rrtr>() {
Rrtr rrtr;
rrtr.WithNtp(Rand<NtpTime>());
rrtr.SetNtp(Rand<NtpTime>());
return rrtr;
}
@ -143,14 +143,14 @@ RTCPVoIPMetric RtcpPacketExtendedReportsTest::Rand<RTCPVoIPMetric>() {
template <>
VoipMetric RtcpPacketExtendedReportsTest::Rand<VoipMetric>() {
VoipMetric voip_metric;
voip_metric.To(Rand<uint32_t>());
voip_metric.WithVoipMetric(Rand<RTCPVoIPMetric>());
voip_metric.SetMediaSsrc(Rand<uint32_t>());
voip_metric.SetVoipMetric(Rand<RTCPVoIPMetric>());
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<Rrtr>();
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>();
Rrtr rrtr2 = Rand<Rrtr>();
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<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
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<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
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<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr1.AddDlrrItem(Rand<ReceiveTimeInfo>()));
Dlrr dlrr2;
EXPECT_TRUE(dlrr2.WithDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr2.AddDlrrItem(Rand<ReceiveTimeInfo>()));
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<VoipMetric>();
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<Rrtr>();
Dlrr dlrr;
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
VoipMetric metric = Rand<VoipMetric>();
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<VoipMetric>();
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<Rrtr>();
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<VoipMetric>();
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

6
webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h
View File

@ -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<Request>& 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<Request> items_;

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc
View File

@ -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;

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc
View File

@ -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());

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h
View File

@ -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<uint16_t>& 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<PackedNack> packed_;

30
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc
View File

@ -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 {

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc
View File

@ -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();

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h
View File

@ -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_; }

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc
View File

@ -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();

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc
View File

@ -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;

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
View File

@ -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<ReportBlock>& report_blocks() const {

40
webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc
View File

@ -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

18
webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc
View File

@ -10,6 +10,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
#include <utility>
#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<uint32_t>& ssrcs) {
if (ssrcs_.size() + ssrcs.size() > kMaxNumberOfSsrcs) {
bool Remb::SetSsrcs(std::vector<uint32_t> 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;
}

9
webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h
View File

@ -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<uint32_t>& ssrcs);
void WithBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; }
bool SetSsrcs(std::vector<uint32_t> ssrcs);
void SetBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; }
uint64_t bitrate_bps() const { return bitrate_bps_; }
const std::vector<uint32_t>& 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_;

39
webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc
View File

@ -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<uint32_t>(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<uint32_t> kAllButOneSsrc(kMax - 1, kRemoteSsrc);
const std::vector<uint32_t> 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<uint32_t>(Remb::kMaxNumberOfSsrcs + 1, kRemoteSsrcs[0])));
EXPECT_TRUE(remb.SetSsrcs(
std::vector<uint32_t>(Remb::kMaxNumberOfSsrcs, kRemoteSsrcs[0])));
}
} // namespace webrtc

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc
View File

@ -76,7 +76,7 @@ void ReportBlock::Create(uint8_t* buffer) const {
ByteWriter<uint32_t>::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;

14
webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h
View File

@ -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;
}

18
webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc
View File

@ -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

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc
View File

@ -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_));
}

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h
View File

@ -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_; }

34
webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc
View File

@ -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));

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h
View File

@ -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_; }

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc
View File

@ -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));

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h
View File

@ -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_; }

6
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
View File

@ -10,6 +10,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include <utility>
#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;

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h
View File

@ -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<Chunk>& chunks() const { return chunks_; }

24
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc
View File

@ -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;

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc
View File

@ -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;

12
webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h
View File

@ -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_; }

36
webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc
View File

@ -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

12
webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h
View File

@ -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>& macroblocks() const { return items_; }

12
webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc
View File

@ -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).

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
View File

@ -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);
}

7
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h
View File

@ -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<TmmbItem>& 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<TmmbItem> items_;

12
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
View File

@ -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;

2
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
View File

@ -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);
}

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h
View File

@ -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<TmmbItem>& 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<TmmbItem> items_;

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc
View File

@ -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();

10
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
View File

@ -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_)

31
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
View File

@ -16,6 +16,7 @@
#include <vector>
#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<int64_t> 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<TransportFeedback> ParseFrom(const uint8_t* buffer,
size_t length);
RTC_DEPRECATED
void WithPacketSenderSenderSsrc(uint32_t ssrc) { SetSenderSsrc(ssrc); }
RTC_DEPRECATED
void WithMediaSourceSsrc(uint32_t ssrc) { SetMediaSsrc(ssrc); }
RTC_DEPRECATED
void WithBase(uint16_t base_sequence, int64_t ref_timestamp_us) {
SetBase(base_sequence, ref_timestamp_us);
}
RTC_DEPRECATED
void WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
SetFeedbackSequenceNumber(feedback_sequence);
}
RTC_DEPRECATED
bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us) {
return AddReceivedPacket(sequence_number, timestamp_us);
}
protected:
bool Create(uint8_t* packet,
size_t* position,

60
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc
View File

@ -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<int64_t> deltas = feedback.GetReceiveDeltasUs();
@ -358,48 +358,48 @@ TEST(RtcpPacketTest, TransportFeedback_Aliasing) {
TEST(RtcpPacketTest, TransportFeedback_Limits) {
// Sequence number wrap above 0x8000.
std::unique_ptr<TransportFeedback> 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<int16_t>::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<int16_t>::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<int64_t>(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<TransportFeedback> deserialized_packet =

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h
View File

@ -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;
}

4
webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc
View File

@ -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));

4
webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
View File

@ -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;

344
webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -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);

110
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -449,14 +449,14 @@ std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> RTCPSender::BuildSDES(
RTC_CHECK_LT(length_cname, static_cast<size_t>(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<rtcp::RtcpPacket>(sdes);
}
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(report);
@ -489,8 +489,8 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
*/
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(sli);
}
@ -553,10 +553,10 @@ std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(rpsi);
}
@ -564,10 +564,9 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(tmmbr);
}
@ -639,10 +638,10 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(app);
}
@ -662,9 +661,9 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> RTCPSender::BuildNACK(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(bye);
}
@ -698,12 +696,12 @@ std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(xr);
}
@ -728,13 +726,13 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
std::unique_ptr<rtcp::RtcpPacket> 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<rtcp::RtcpPacket>(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;
}

6
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -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()));

6
webrtc/video/end_to_end_tests.cc
View File

@ -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()));