zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert of Unify rtcp packet setters (patchset #8 id:130001 of https://codereview.webrtc.org/2348623003/ )

Browse Source 
Reason for revert:
Breaks compilation of internal downstream project.

Original issue's description:
> Unify rtcp packet setters
> Renamed setters in rtcp classes
> from WithField to SetField
> from WithItem to AddItem or SetItems
> from From to SetSenderSsrc
> from To to SetMediaSsrc
> Some redundant or unsued setters removed.
> Pass-by-const& replaced with pass-by-value when appropriate.
>
> BUG=webrtc:5260
>
> Committed: https://crrev.com/20e77c7b8a9f19942ef3c3c4f1fa3888b2cd54ea
> Cr-Commit-Position: refs/heads/master@{#14393}

TBR=sprang@webrtc.org,stefan@webrtc.org,danilchap@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:5260

Review-Url: https://codereview.webrtc.org/2372713005
Cr-Commit-Position: refs/heads/master@{#14400}
This commit is contained in:
kjellander
2016-09-27 08:39:35 -07:00
committed by Commit bot
parent 9532124659
commit efc6e41866
69 changed files with 679 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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::SetSubType(uint8_t subtype) {
void App::WithSubType(uint8_t subtype) {
RTC_DCHECK_LE(subtype, 0x1f);
sub_type_ = subtype;
}
void App::SetData(const uint8_t* data, size_t data_length) {
void App::WithData(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 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);
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);
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.SetSsrc(kSenderSsrc);
app.SetSubType(kSubtype);
app.SetName(kName);
app.From(kSenderSsrc);
app.WithSubType(kSubtype);
app.WithName(kName);
rtc::Buffer raw = app.Build();
@ -75,10 +75,10 @@ TEST(RtcpPacketAppTest, ParseWithoutData) {
TEST(RtcpPacketAppTest, CreateWithData) {
App app;
app.SetSsrc(kSenderSsrc);
app.SetSubType(kSubtype);
app.SetName(kName);
app.SetData(kData, sizeof(kData));
app.From(kSenderSsrc);
app.WithSubType(kSubtype);
app.WithName(kName);
app.WithData(kData, sizeof(kData));
rtc::Buffer raw = app.Build();

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

@ -10,8 +10,6 @@
#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"
@ -111,18 +109,18 @@ bool Bye::Create(uint8_t* packet,
return true;
}
bool Bye::SetCsrcs(std::vector<uint32_t> csrcs) {
if (csrcs.size() > kMaxNumberOfCsrcs) {
LOG(LS_WARNING) << "Too many CSRCs for Bye packet.";
bool Bye::WithCsrc(uint32_t csrc) {
if (csrcs_.size() >= kMaxNumberOfCsrcs) {
LOG(LS_WARNING) << "Max CSRC size reached.";
return false;
}
csrcs_ = std::move(csrcs);
csrcs_.push_back(csrc);
return true;
}
void Bye::SetReason(std::string reason) {
void Bye::WithReason(const std::string& reason) {
RTC_DCHECK_LE(reason.size(), 0xffu);
reason_ = std::move(reason);
reason_ = 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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
bool SetCsrcs(std::vector<uint32_t> csrcs);
void SetReason(std::string reason);
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
bool WithCsrc(uint32_t csrc);
void WithReason(const 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.SetSenderSsrc(kSenderSsrc);
bye.From(kSenderSsrc);
rtc::Buffer raw = bye.Build();
Bye parsed_bye;
@ -39,8 +39,9 @@ TEST(RtcpPacketByeTest, CreateAndParseWithoutReason) {
TEST(RtcpPacketByeTest, CreateAndParseWithCsrcs) {
Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2}));
bye.From(kSenderSsrc);
EXPECT_TRUE(bye.WithCsrc(kCsrc1));
EXPECT_TRUE(bye.WithCsrc(kCsrc2));
EXPECT_TRUE(bye.reason().empty());
rtc::Buffer raw = bye.Build();
@ -56,9 +57,10 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) {
Bye bye;
const std::string kReason = "Some Reason";
bye.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2}));
bye.SetReason(kReason);
bye.From(kSenderSsrc);
EXPECT_TRUE(bye.WithCsrc(kCsrc1));
EXPECT_TRUE(bye.WithCsrc(kCsrc2));
bye.WithReason(kReason);
rtc::Buffer raw = bye.Build();
Bye parsed_bye;
@ -71,18 +73,20 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) {
TEST(RtcpPacketByeTest, CreateWithTooManyCsrcs) {
Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
bye.From(kSenderSsrc);
const int kMaxCsrcs = (1 << 5) - 2; // 5 bit len, first item is sender SSRC.
EXPECT_TRUE(bye.SetCsrcs(std::vector<uint32_t>(kMaxCsrcs, kCsrc1)));
EXPECT_FALSE(bye.SetCsrcs(std::vector<uint32_t>(kMaxCsrcs + 1, kCsrc1)));
for (int i = 0; i < kMaxCsrcs; ++i) {
EXPECT_TRUE(bye.WithCsrc(i));
}
EXPECT_FALSE(bye.WithCsrc(kMaxCsrcs));
}
TEST(RtcpPacketByeTest, CreateAndParseWithAReason) {
Bye bye;
const std::string kReason = "Some Random Reason";
bye.SetSenderSsrc(kSenderSsrc);
bye.SetReason(kReason);
bye.From(kSenderSsrc);
bye.WithReason(kReason);
rtc::Buffer raw = bye.Build();
Bye parsed_bye;
@ -99,8 +103,8 @@ TEST(RtcpPacketByeTest, CreateAndParseWithReasons) {
for (size_t reminder = 0; reminder < 4; ++reminder) {
const std::string kReason(4 + reminder, 'a' + reminder);
Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
bye.SetReason(kReason);
bye.From(kSenderSsrc);
bye.WithReason(kReason);
rtc::Buffer raw = bye.Build();
Bye parsed_bye;
@ -121,7 +125,7 @@ TEST(RtcpPacketByeTest, ParseEmptyPacket) {
TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) {
Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
bye.From(kSenderSsrc);
rtc::Buffer raw = bye.Build();
raw[0]++; // Damage the packet: increase ssrc count by one.
@ -132,8 +136,8 @@ TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) {
TEST(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) {
Bye bye;
bye.SetSenderSsrc(kSenderSsrc);
bye.SetReason("18 characters long");
bye.From(kSenderSsrc);
bye.WithReason("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.AddRequestTo(kRemoteSsrc, kSeqNo);
fir.WithRequestTo(kRemoteSsrc, kSeqNo);
ReportBlock rb;
ReceiverReport rr;
rr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(rr.AddReportBlock(rb));
rr.From(kSenderSsrc);
EXPECT_TRUE(rr.WithReportBlock(rb));
compound.Append(&rr);
compound.Append(&fir);
@ -56,12 +56,12 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
CompoundPacket root;
CompoundPacket leaf;
Fir fir;
fir.AddRequestTo(kRemoteSsrc, kSeqNo);
fir.WithRequestTo(kRemoteSsrc, kSeqNo);
Bye bye;
ReportBlock rb;
ReceiverReport rr;
EXPECT_TRUE(rr.AddReportBlock(rb));
EXPECT_TRUE(rr.WithReportBlock(rb));
leaf.Append(&rr);
leaf.Append(&fir);
@ -83,11 +83,11 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
CompoundPacket compound;
Fir fir;
fir.AddRequestTo(kRemoteSsrc, kSeqNo);
fir.WithRequestTo(kRemoteSsrc, kSeqNo);
ReportBlock rb;
ReceiverReport rr;
rr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(rr.AddReportBlock(rb));
rr.From(kSenderSsrc);
EXPECT_TRUE(rr.WithReportBlock(rb));
compound.Append(&rr);
compound.Append(&fir);
@ -117,11 +117,11 @@ TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
TEST(RtcpCompoundPacketTest, BuildWithTooSmallBuffer_FragmentedSend) {
CompoundPacket compound;
Fir fir;
fir.AddRequestTo(kRemoteSsrc, kSeqNo);
fir.WithRequestTo(kRemoteSsrc, kSeqNo);
ReportBlock rb;
ReceiverReport rr;
rr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(rr.AddReportBlock(rb));
rr.From(kSenderSsrc);
EXPECT_TRUE(rr.WithReportBlock(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::AddDlrrItem(const ReceiveTimeInfo& block) {
bool Dlrr::WithDlrrItem(const ReceiveTimeInfo& block) {
if (sub_blocks_.size() >= kMaxNumberOfDlrrItems) {
LOG(LS_WARNING) << "Max DLRR items reached.";
return false;
@ -90,14 +90,14 @@ bool Dlrr::AddDlrrItem(const ReceiveTimeInfo& block) {
return true;
}
bool Dlrr::AddDlrrItem(uint32_t ssrc,
uint32_t last_rr,
uint32_t delay_last_rr) {
bool Dlrr::WithDlrrItem(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 AddDlrrItem(block);
return WithDlrrItem(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 AddDlrrItem(const ReceiveTimeInfo& time_info);
bool AddDlrrItem(uint32_t ssrc, uint32_t last_rr, uint32_t delay_last_rr);
bool WithDlrrItem(const ReceiveTimeInfo& time_info);
bool WithDlrrItem(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.AddDlrrItem(kSsrc, kLastRR, kDelay));
EXPECT_TRUE(dlrr.WithDlrrItem(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.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
}
EXPECT_FALSE(dlrr.AddDlrrItem(kSsrc, kLastRR, kDelay));
EXPECT_FALSE(dlrr.WithDlrrItem(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.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
EXPECT_TRUE(dlrr.WithDlrrItem(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,8 +10,6 @@
#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"
@ -58,12 +56,12 @@ bool ExtendedJitterReport::Parse(const CommonHeader& packet) {
return true;
}
bool ExtendedJitterReport::SetJitterValues(std::vector<uint32_t> values) {
if (values.size() > kMaxNumberOfJitterValues) {
LOG(LS_WARNING) << "Too many inter-arrival jitter items.";
bool ExtendedJitterReport::WithJitter(uint32_t jitter) {
if (inter_arrival_jitters_.size() >= kMaxNumberOfJitters) {
LOG(LS_WARNING) << "Max inter-arrival jitter items reached.";
return false;
}
inter_arrival_jitters_ = std::move(values);
inter_arrival_jitters_.push_back(jitter);
return true;
}

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

@ -23,7 +23,6 @@ class CommonHeader;
class ExtendedJitterReport : public RtcpPacket {
public:
static constexpr uint8_t kPacketType = 195;
static constexpr size_t kMaxNumberOfJitterValues = 0x1f;
ExtendedJitterReport() {}
~ExtendedJitterReport() override {}
@ -31,11 +30,9 @@ class ExtendedJitterReport : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
bool SetJitterValues(std::vector<uint32_t> jitter_values);
bool WithJitter(uint32_t jitter);
const std::vector<uint32_t>& jitter_values() {
return inter_arrival_jitters_;
}
const std::vector<uint32_t>& jitters() { return inter_arrival_jitters_; }
protected:
bool Create(uint8_t* packet,
@ -44,6 +41,7 @@ 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,42 +31,44 @@ TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithoutItems) {
ExtendedJitterReport parsed;
EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
EXPECT_THAT(parsed.jitter_values(), IsEmpty());
EXPECT_THAT(parsed.jitters(), IsEmpty());
}
TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithOneItem) {
ExtendedJitterReport ij;
EXPECT_TRUE(ij.SetJitterValues({kJitter1}));
EXPECT_TRUE(ij.WithJitter(kJitter1));
rtc::Buffer raw = ij.Build();
ExtendedJitterReport parsed;
EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1));
EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1));
}
TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithTwoItems) {
ExtendedJitterReport ij;
EXPECT_TRUE(ij.SetJitterValues({kJitter1, kJitter2}));
EXPECT_TRUE(ij.WithJitter(kJitter1));
EXPECT_TRUE(ij.WithJitter(kJitter2));
rtc::Buffer raw = ij.Build();
ExtendedJitterReport parsed;
EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1, kJitter2));
EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1, kJitter2));
}
TEST(RtcpPacketExtendedJitterReportTest, CreateWithTooManyItems) {
ExtendedJitterReport ij;
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)));
const int kMaxIjItems = (1 << 5) - 1;
for (int i = 0; i < kMaxIjItems; ++i) {
EXPECT_TRUE(ij.WithJitter(i));
}
EXPECT_FALSE(ij.WithJitter(kMaxIjItems));
}
TEST(RtcpPacketExtendedJitterReportTest, ParseFailsWithTooManyItems) {
ExtendedJitterReport ij;
ij.SetJitterValues({kJitter1});
ij.WithJitter(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::AddRrtr(const Rrtr& rrtr) {
bool ExtendedReports::WithRrtr(const Rrtr& rrtr) {
if (rrtr_blocks_.size() >= kMaxNumberOfRrtrBlocks) {
LOG(LS_WARNING) << "Max RRTR blocks reached.";
return false;
@ -100,7 +100,7 @@ bool ExtendedReports::AddRrtr(const Rrtr& rrtr) {
return true;
}
bool ExtendedReports::AddDlrr(const Dlrr& dlrr) {
bool ExtendedReports::WithDlrr(const Dlrr& dlrr) {
if (dlrr_blocks_.size() >= kMaxNumberOfDlrrBlocks) {
LOG(LS_WARNING) << "Max DLRR blocks reached.";
return false;
@ -109,7 +109,7 @@ bool ExtendedReports::AddDlrr(const Dlrr& dlrr) {
return true;
}
bool ExtendedReports::AddVoipMetric(const VoipMetric& voip_metric) {
bool ExtendedReports::WithVoipMetric(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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
// Max 50 items of each of {Rrtr, Dlrr, VoipMetric} allowed per Xr.
bool AddRrtr(const Rrtr& rrtr);
bool AddDlrr(const Dlrr& dlrr);
bool AddVoipMetric(const VoipMetric& voip_metric);
bool WithRrtr(const Rrtr& rrtr);
bool WithDlrr(const Dlrr& dlrr);
bool WithVoipMetric(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.SetNtp(Rand<NtpTime>());
rrtr.WithNtp(Rand<NtpTime>());
return rrtr;
}
@ -143,14 +143,14 @@ RTCPVoIPMetric RtcpPacketExtendedReportsTest::Rand<RTCPVoIPMetric>() {
template <>
VoipMetric RtcpPacketExtendedReportsTest::Rand<VoipMetric>() {
VoipMetric voip_metric;
voip_metric.SetMediaSsrc(Rand<uint32_t>());
voip_metric.SetVoipMetric(Rand<RTCPVoIPMetric>());
voip_metric.To(Rand<uint32_t>());
voip_metric.WithVoipMetric(Rand<RTCPVoIPMetric>());
return voip_metric;
}
TEST_F(RtcpPacketExtendedReportsTest, CreateWithoutReportBlocks) {
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
xr.From(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.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddRrtr(rrtr));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithRrtr(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.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddRrtr(rrtr1));
EXPECT_TRUE(xr.AddRrtr(rrtr2));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithRrtr(rrtr1));
EXPECT_TRUE(xr.WithRrtr(rrtr2));
rtc::Buffer packet = xr.Build();
@ -202,10 +202,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) {
TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
Dlrr dlrr;
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddDlrr(dlrr));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithDlrr(dlrr));
rtc::Buffer packet = xr.Build();
@ -219,11 +219,11 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
Dlrr dlrr;
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddDlrr(dlrr));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithDlrr(dlrr));
rtc::Buffer packet = xr.Build();
@ -237,13 +237,13 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoDlrrBlocks) {
Dlrr dlrr1;
EXPECT_TRUE(dlrr1.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr1.WithDlrrItem(Rand<ReceiveTimeInfo>()));
Dlrr dlrr2;
EXPECT_TRUE(dlrr2.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr2.WithDlrrItem(Rand<ReceiveTimeInfo>()));
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddDlrr(dlrr1));
EXPECT_TRUE(xr.AddDlrr(dlrr2));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithDlrr(dlrr1));
EXPECT_TRUE(xr.WithDlrr(dlrr2));
rtc::Buffer packet = xr.Build();
@ -259,8 +259,8 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) {
VoipMetric voip_metric = Rand<VoipMetric>();
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddVoipMetric(voip_metric));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithVoipMetric(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.AddDlrrItem(Rand<ReceiveTimeInfo>()));
EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
VoipMetric metric = Rand<VoipMetric>();
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddRrtr(rrtr));
EXPECT_TRUE(xr.AddDlrr(dlrr));
EXPECT_TRUE(xr.AddVoipMetric(metric));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithRrtr(rrtr));
EXPECT_TRUE(xr.WithDlrr(dlrr));
EXPECT_TRUE(xr.WithVoipMetric(metric));
rtc::Buffer packet = xr.Build();
@ -300,10 +300,10 @@ TEST_F(RtcpPacketExtendedReportsTest, DlrrWithoutItemNotIncludedInPacket) {
Dlrr dlrr;
VoipMetric metric = Rand<VoipMetric>();
ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(xr.AddRrtr(rrtr));
EXPECT_TRUE(xr.AddDlrr(dlrr));
EXPECT_TRUE(xr.AddVoipMetric(metric));
xr.From(kSenderSsrc);
EXPECT_TRUE(xr.WithRrtr(rrtr));
EXPECT_TRUE(xr.WithDlrr(dlrr));
EXPECT_TRUE(xr.WithVoipMetric(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.AddRrtr(rrtr));
EXPECT_FALSE(xr.AddRrtr(rrtr));
EXPECT_TRUE(xr.WithRrtr(rrtr));
EXPECT_FALSE(xr.WithRrtr(rrtr));
Dlrr dlrr;
for (size_t i = 0; i < kMaxBlocks; ++i)
EXPECT_TRUE(xr.AddDlrr(dlrr));
EXPECT_FALSE(xr.AddDlrr(dlrr));
EXPECT_TRUE(xr.WithDlrr(dlrr));
EXPECT_FALSE(xr.WithDlrr(dlrr));
VoipMetric voip_metric = Rand<VoipMetric>();
for (size_t i = 0; i < kMaxBlocks; ++i)
EXPECT_TRUE(xr.AddVoipMetric(voip_metric));
EXPECT_FALSE(xr.AddVoipMetric(voip_metric));
EXPECT_TRUE(xr.WithVoipMetric(voip_metric));
EXPECT_FALSE(xr.WithVoipMetric(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 AddRequestTo(uint32_t ssrc, uint8_t seq_num) {
items_.emplace_back(ssrc, seq_num);
void WithRequestTo(uint32_t ssrc, uint8_t seq_num) {
items_.push_back(Request(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 SetMediaSsrc(uint32_t ssrc);
void To(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.SetSenderSsrc(kSenderSsrc);
fir.AddRequestTo(kRemoteSsrc, kSeqNr);
fir.From(kSenderSsrc);
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
rtc::Buffer packet = fir.Build();
@ -60,9 +60,9 @@ TEST(RtcpPacketFirTest, Create) {
TEST(RtcpPacketFirTest, TwoFciEntries) {
Fir fir;
fir.SetSenderSsrc(kSenderSsrc);
fir.AddRequestTo(kRemoteSsrc, kSeqNr);
fir.AddRequestTo(kRemoteSsrc + 1, kSeqNr + 1);
fir.From(kSenderSsrc);
fir.WithRequestTo(kRemoteSsrc, kSeqNr);
fir.WithRequestTo(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::SetPacketIds(const uint16_t* nack_list, size_t length) {
void Nack::WithList(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 SetPacketIds(const uint16_t* nack_list, size_t length);
void WithList(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 SetPacketIds).
void Pack(); // Fills packed_ using packed_ids_. (used in WithList).
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.SetSenderSsrc(kSenderSsrc);
nack.SetMediaSsrc(kRemoteSsrc);
nack.SetPacketIds(kList, kListLength);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
rtc::Buffer packet = nack.Build();
@ -79,9 +79,9 @@ TEST(RtcpPacketNackTest, Parse) {
TEST(RtcpPacketNackTest, CreateWrap) {
Nack nack;
nack.SetSenderSsrc(kSenderSsrc);
nack.SetMediaSsrc(kRemoteSsrc);
nack.SetPacketIds(kWrapList, kWrapListLength);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(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.SetSenderSsrc(kSenderSsrc);
nack.SetMediaSsrc(kRemoteSsrc);
nack.SetPacketIds(kUnorderedList, kUnorderedListLength);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(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.SetSenderSsrc(kSenderSsrc);
nack.SetMediaSsrc(kRemoteSsrc);
nack.SetPacketIds(kList, kListLength);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(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.SetSenderSsrc(kSenderSsrc);
nack.SetMediaSsrc(kRemoteSsrc);
nack.SetPacketIds(kList, 1);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(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.SetSenderSsrc(kSenderSsrc);
pli.SetMediaSsrc(kRemoteSsrc);
pli.From(kSenderSsrc);
pli.To(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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; }
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void To(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.SetSenderSsrc(kSenderSsrc);
rrr.SetMediaSsrc(kRemoteSsrc);
rrr.From(kSenderSsrc);
rrr.To(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::AddReportBlock(const ReportBlock& block) {
bool ReceiverReport::WithReportBlock(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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
bool AddReportBlock(const ReportBlock& block);
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
bool WithReportBlock(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.SetSenderSsrc(kSenderSsrc);
rr.From(kSenderSsrc);
ReportBlock 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);
rb.To(kRemoteSsrc);
rb.WithFractionLost(kFractionLost);
rb.WithCumulativeLost(kCumulativeLost);
rb.WithExtHighestSeqNum(kExtHighestSeqNum);
rb.WithJitter(kJitter);
rb.WithLastSr(kLastSr);
rb.WithDelayLastSr(kDelayLastSr);
rr.WithReportBlock(rb);
rtc::Buffer raw = rr.Build();
@ -83,7 +83,7 @@ TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) {
TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) {
ReceiverReport rr;
rr.SetSenderSsrc(kSenderSsrc);
rr.From(kSenderSsrc);
rtc::Buffer raw = rr.Build();
ReceiverReport parsed;
@ -96,13 +96,13 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) {
TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) {
ReceiverReport rr;
ReportBlock rb1;
rb1.SetMediaSsrc(kRemoteSsrc);
rb1.To(kRemoteSsrc);
ReportBlock rb2;
rb2.SetMediaSsrc(kRemoteSsrc + 1);
rb2.To(kRemoteSsrc + 1);
rr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(rr.AddReportBlock(rb1));
EXPECT_TRUE(rr.AddReportBlock(rb2));
rr.From(kSenderSsrc);
EXPECT_TRUE(rr.WithReportBlock(rb1));
EXPECT_TRUE(rr.WithReportBlock(rb2));
rtc::Buffer raw = rr.Build();
ReceiverReport parsed;
@ -116,15 +116,15 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) {
TEST(RtcpPacketReceiverReportTest, CreateWithTooManyReportBlocks) {
ReceiverReport rr;
rr.SetSenderSsrc(kSenderSsrc);
rr.From(kSenderSsrc);
const size_t kMaxReportBlocks = (1 << 5) - 1;
ReportBlock rb;
for (size_t i = 0; i < kMaxReportBlocks; ++i) {
rb.SetMediaSsrc(kRemoteSsrc + i);
EXPECT_TRUE(rr.AddReportBlock(rb));
rb.To(kRemoteSsrc + i);
EXPECT_TRUE(rr.WithReportBlock(rb));
}
rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks);
EXPECT_FALSE(rr.AddReportBlock(rb));
rb.To(kRemoteSsrc + kMaxReportBlocks);
EXPECT_FALSE(rr.WithReportBlock(rb));
}
} // namespace webrtc

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

@ -10,8 +10,6 @@
#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"
@ -83,12 +81,22 @@ bool Remb::Parse(const CommonHeader& packet) {
return true;
}
bool Remb::SetSsrcs(std::vector<uint32_t> ssrcs) {
if (ssrcs.size() > kMaxNumberOfSsrcs) {
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) {
LOG(LS_WARNING) << "Not enough space for all given SSRCs.";
return false;
}
ssrcs_ = std::move(ssrcs);
// Append.
ssrcs_.insert(ssrcs_.end(), ssrcs.begin(), ssrcs.end());
return true;
}

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

@ -25,7 +25,6 @@ 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 {}
@ -33,8 +32,9 @@ class Remb : public Psfb {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
bool SetSsrcs(std::vector<uint32_t> ssrcs);
void SetBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; }
bool AppliesTo(uint32_t ssrc);
bool AppliesToMany(const std::vector<uint32_t>& ssrcs);
void WithBitrateBps(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,10 +50,11 @@ 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 SetMediaSsrc(uint32_t);
void To(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,10 +34,11 @@ const size_t kPacketLength = sizeof(kPacket);
TEST(RtcpPacketRembTest, Create) {
Remb remb;
remb.SetSenderSsrc(kSenderSsrc);
remb.SetSsrcs(
std::vector<uint32_t>(std::begin(kRemoteSsrcs), std::end(kRemoteSsrcs)));
remb.SetBitrateBps(kBitrateBps);
remb.From(kSenderSsrc);
remb.AppliesTo(kRemoteSsrcs[0]);
remb.AppliesTo(kRemoteSsrcs[1]);
remb.AppliesTo(kRemoteSsrcs[2]);
remb.WithBitrateBps(kBitrateBps);
rtc::Buffer packet = remb.Build();
@ -57,8 +58,8 @@ TEST(RtcpPacketRembTest, Parse) {
TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) {
Remb remb;
remb.SetSenderSsrc(kSenderSsrc);
remb.SetBitrateBps(kBitrateBps);
remb.From(kSenderSsrc);
remb.WithBitrateBps(kBitrateBps);
rtc::Buffer packet = remb.Build();
Remb parsed;
@ -70,7 +71,7 @@ TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) {
TEST(RtcpPacketRembTest, CreateAndParse64bitBitrate) {
Remb remb;
remb.SetBitrateBps(kBitrateBps64bit);
remb.WithBitrateBps(kBitrateBps64bit);
rtc::Buffer packet = remb.Build();
Remb parsed;
@ -118,11 +119,27 @@ TEST(RtcpPacketRembTest, ParseFailsWhenSsrcCountMismatchLength) {
}
TEST(RtcpPacketRembTest, TooManySsrcs) {
const size_t kMax = 0xff;
Remb remb;
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])));
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));
}
} // 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::SetCumulativeLost(uint32_t cumulative_lost) {
bool ReportBlock::WithCumulativeLost(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 SetMediaSsrc(uint32_t ssrc) { source_ssrc_ = ssrc; }
void SetFractionLost(uint8_t fraction_lost) {
void To(uint32_t ssrc) { source_ssrc_ = ssrc; }
void WithFractionLost(uint8_t fraction_lost) {
fraction_lost_ = fraction_lost;
}
bool SetCumulativeLost(uint32_t cumulative_lost);
void SetExtHighestSeqNum(uint32_t ext_highest_seq_num) {
bool WithCumulativeLost(uint32_t cumulative_lost);
void WithExtHighestSeqNum(uint32_t ext_highest_seq_num) {
extended_high_seq_num_ = ext_highest_seq_num;
}
void SetJitter(uint32_t jitter) { jitter_ = jitter; }
void SetLastSr(uint32_t last_sr) { last_sr_ = last_sr; }
void SetDelayLastSr(uint32_t delay_last_sr) {
void WithJitter(uint32_t jitter) { jitter_ = jitter; }
void WithLastSr(uint32_t last_sr) { last_sr_ = last_sr; }
void WithDelayLastSr(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.SetMediaSsrc(kRemoteSsrc);
rb.SetFractionLost(kFractionLost);
rb.SetCumulativeLost(kCumulativeLost);
rb.SetExtHighestSeqNum(kExtHighestSeqNum);
rb.SetJitter(kJitter);
rb.SetLastSr(kLastSr);
rb.SetDelayLastSr(kDelayLastSr);
rb.To(kRemoteSsrc);
rb.WithFractionLost(kFractionLost);
rb.WithCumulativeLost(kCumulativeLost);
rb.WithExtHighestSeqNum(kExtHighestSeqNum);
rb.WithJitter(kJitter);
rb.WithLastSr(kLastSr);
rb.WithDelayLastSr(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.SetCumulativeLost(kMaxCumulativeLost + 1));
EXPECT_TRUE(rb.SetCumulativeLost(kMaxCumulativeLost));
EXPECT_FALSE(rb.WithCumulativeLost(kMaxCumulativeLost + 1));
EXPECT_TRUE(rb.WithCumulativeLost(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::SetPayloadType(uint8_t payload) {
void Rpsi::WithPayloadType(uint8_t payload) {
RTC_DCHECK_LE(payload, 0x7f);
payload_type_ = payload;
}
void Rpsi::SetPictureId(uint64_t picture_id) {
void Rpsi::WithPictureId(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 SetPayloadType(uint8_t payload);
void SetPictureId(uint64_t picture_id);
void WithPayloadType(uint8_t payload);
void WithPictureId(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.SetSenderSsrc(kSenderSsrc);
rpsi.SetMediaSsrc(kRemoteSsrc);
rpsi.SetPayloadType(kPayloadType);
rpsi.SetPictureId(kPictureId);
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rpsi.WithPayloadType(kPayloadType);
rpsi.WithPictureId(kPictureId);
rtc::Buffer packet = rpsi.Build();
@ -59,8 +59,8 @@ TEST(RtcpPacketRpsiTest, Create) {
TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) {
Rpsi rpsi;
rpsi.SetSenderSsrc(kSenderSsrc);
rpsi.SetMediaSsrc(kRemoteSsrc);
rpsi.From(kSenderSsrc);
rpsi.To(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.SetSenderSsrc(kSenderSsrc);
rpsi.SetMediaSsrc(kRemoteSsrc);
rpsi.SetPictureId(kPictureId);
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rpsi.WithPictureId(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.SetSenderSsrc(kSenderSsrc);
rpsi.SetMediaSsrc(kRemoteSsrc);
rpsi.SetPictureId(1); // Small picture id that occupy just 1 byte.
rpsi.From(kSenderSsrc);
rpsi.To(kRemoteSsrc);
rpsi.WithPictureId(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.SetPictureId(kPictureId);
rpsi.WithPictureId(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.SetPictureId(kPictureId);
rpsi.WithPictureId(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.SetPictureId(kPictureId);
rpsi.WithPictureId(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.SetPictureId(kPictureId);
rpsi.WithPictureId(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.SetPictureId(kPictureId);
rpsi.WithPictureId(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 SetNtp(NtpTime ntp) { ntp_ = ntp; }
void WithNtp(const 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.SetNtp(NtpTime(kNtpSec, kNtpFrac));
rrtr.WithNtp(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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; }
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void To(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,8 +10,6 @@
#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"
@ -139,7 +137,7 @@ bool Sdes::Parse(const CommonHeader& packet) {
return true;
}
bool Sdes::AddCName(uint32_t ssrc, std::string cname) {
bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) {
RTC_DCHECK_LE(cname.length(), 0xffu);
if (chunks_.size() >= kMaxNumberOfChunks) {
LOG(LS_WARNING) << "Max SDES chunks reached.";
@ -147,7 +145,7 @@ bool Sdes::AddCName(uint32_t ssrc, std::string cname) {
}
Chunk chunk;
chunk.ssrc = ssrc;
chunk.cname = std::move(cname);
chunk.cname = 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 AddCName(uint32_t ssrc, std::string cname);
bool WithCName(uint32_t ssrc, const 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.AddCName(kSenderSsrc, kCname));
EXPECT_TRUE(sdes.WithCName(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.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"));
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"));
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.AddCName(ssrc, oss.str()));
EXPECT_TRUE(sdes.WithCName(ssrc, oss.str()));
}
EXPECT_FALSE(sdes.AddCName(kSenderSsrc + kMaxChunks, "foo"));
EXPECT_FALSE(sdes.WithCName(kSenderSsrc + kMaxChunks, "foo"));
}
TEST(RtcpPacketSdesTest, CreateAndParseCnameItemWithEmptyString) {
Sdes sdes;
EXPECT_TRUE(sdes.AddCName(kSenderSsrc, ""));
EXPECT_TRUE(sdes.WithCName(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.AddCName(kSenderSsrc, kAlice);
source.WithCName(kSenderSsrc, kAlice);
rtc::Buffer packet1 = source.Build();
Sdes middle;
@ -232,7 +232,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
EXPECT_EQ(source.BlockLength(), middle.BlockLength());
middle.AddCName(kSenderSsrc + 1, kBob);
middle.WithCName(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::AddReportBlock(const ReportBlock& block) {
bool SenderReport::WithReportBlock(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 SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void SetNtp(NtpTime ntp) { ntp_ = ntp; }
void SetRtpTimestamp(uint32_t rtp_timestamp) {
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void WithNtp(NtpTime ntp) { ntp_ = ntp; }
void WithRtpTimestamp(uint32_t rtp_timestamp) {
rtp_timestamp_ = rtp_timestamp;
}
void SetPacketCount(uint32_t packet_count) {
void WithPacketCount(uint32_t packet_count) {
sender_packet_count_ = packet_count;
}
void SetOctetCount(uint32_t octet_count) {
void WithOctetCount(uint32_t octet_count) {
sender_octet_count_ = octet_count;
}
bool AddReportBlock(const ReportBlock& block);
bool WithReportBlock(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.SetSenderSsrc(kSenderSsrc);
sr.SetNtp(kNtp);
sr.SetRtpTimestamp(kRtpTimestamp);
sr.SetPacketCount(kPacketCount);
sr.SetOctetCount(kOctetCount);
sr.From(kSenderSsrc);
sr.WithNtp(kNtp);
sr.WithRtpTimestamp(kRtpTimestamp);
sr.WithPacketCount(kPacketCount);
sr.WithOctetCount(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.SetMediaSsrc(kRemoteSsrc);
rb.To(kRemoteSsrc);
SenderReport sr;
sr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(sr.AddReportBlock(rb));
sr.From(kSenderSsrc);
EXPECT_TRUE(sr.WithReportBlock(rb));
rtc::Buffer raw = sr.Build();
SenderReport parsed;
@ -80,14 +80,14 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithOneReportBlock) {
TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) {
ReportBlock rb1;
rb1.SetMediaSsrc(kRemoteSsrc);
rb1.To(kRemoteSsrc);
ReportBlock rb2;
rb2.SetMediaSsrc(kRemoteSsrc + 1);
rb2.To(kRemoteSsrc + 1);
SenderReport sr;
sr.SetSenderSsrc(kSenderSsrc);
EXPECT_TRUE(sr.AddReportBlock(rb1));
EXPECT_TRUE(sr.AddReportBlock(rb2));
sr.From(kSenderSsrc);
EXPECT_TRUE(sr.WithReportBlock(rb1));
EXPECT_TRUE(sr.WithReportBlock(rb2));
rtc::Buffer raw = sr.Build();
SenderReport parsed;
@ -101,15 +101,15 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) {
TEST(RtcpPacketSenderReportTest, CreateWithTooManyReportBlocks) {
SenderReport sr;
sr.SetSenderSsrc(kSenderSsrc);
sr.From(kSenderSsrc);
const size_t kMaxReportBlocks = (1 << 5) - 1;
ReportBlock rb;
for (size_t i = 0; i < kMaxReportBlocks; ++i) {
rb.SetMediaSsrc(kRemoteSsrc + i);
EXPECT_TRUE(sr.AddReportBlock(rb));
rb.To(kRemoteSsrc + i);
EXPECT_TRUE(sr.WithReportBlock(rb));
}
rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks);
EXPECT_FALSE(sr.AddReportBlock(rb));
rb.To(kRemoteSsrc + kMaxReportBlocks);
EXPECT_FALSE(sr.WithReportBlock(rb));
}
} // namespace webrtc

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

@ -49,13 +49,11 @@ class Sli : public Psfb {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
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);
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));
}
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.SetSenderSsrc(kSenderSsrc);
sli.SetMediaSsrc(kRemoteSsrc);
sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb);
sli.From(kSenderSsrc);
sli.To(kRemoteSsrc);
sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb);
rtc::Buffer packet = sli.Build();
@ -67,9 +67,9 @@ TEST(RtcpPacketSliTest, Parse) {
TEST(RtcpPacketSliTest, ParseFailsOnTooSmallPacket) {
Sli sli;
sli.SetSenderSsrc(kSenderSsrc);
sli.SetMediaSsrc(kRemoteSsrc);
sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb);
sli.From(kSenderSsrc);
sli.To(kRemoteSsrc);
sli.WithPictureId(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::AddTmmbr(const TmmbItem& item) {
void Tmmbn::WithTmmbr(const TmmbItem& item) {
items_.push_back(item);
}

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

@ -34,7 +34,10 @@ class Tmmbn : public Rtpfb {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void AddTmmbr(const TmmbItem& item);
void WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead) {
WithTmmbr(TmmbItem(ssrc, bitrate_kbps * 1000, overhead));
}
void WithTmmbr(const TmmbItem& item);
const std::vector<TmmbItem>& items() const { return items_; }
@ -51,7 +54,7 @@ class Tmmbn : public Rtpfb {
}
// Media ssrc is unused, shadow base class setter and getter.
void SetMediaSsrc(uint32_t ssrc);
void To(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.SetSenderSsrc(kSenderSsrc);
tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbn.From(kSenderSsrc);
tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
rtc::Buffer packet = tmmbn.Build();
@ -59,7 +59,7 @@ TEST(RtcpPacketTmmbnTest, Parse) {
TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
Tmmbn tmmbn;
tmmbn.SetSenderSsrc(kSenderSsrc);
tmmbn.From(kSenderSsrc);
rtc::Buffer packet = tmmbn.Build();
Tmmbn parsed;
@ -71,9 +71,9 @@ TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
TEST(RtcpPacketTmmbnTest, CreateAndParseWithTwoItems) {
Tmmbn tmmbn;
tmmbn.SetSenderSsrc(kSenderSsrc);
tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40));
tmmbn.From(kSenderSsrc);
tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbn.WithTmmbr(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::AddTmmbr(const TmmbItem& item) {
void Tmmbr::WithTmmbr(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 AddTmmbr(const TmmbItem& item);
void WithTmmbr(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 SetMediaSsrc(uint32_t ssrc);
void To(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.SetSenderSsrc(kSenderSsrc);
tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbr.From(kSenderSsrc);
tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
rtc::Buffer packet = tmmbr.Build();
@ -58,9 +58,9 @@ TEST(RtcpPacketTmmbrTest, Parse) {
TEST(RtcpPacketTmmbrTest, CreateAndParseWithTwoEntries) {
Tmmbr tmmbr;
tmmbr.SetSenderSsrc(kSenderSsrc);
tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1));
tmmbr.From(kSenderSsrc);
tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
tmmbr.WithTmmbr(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::SetBase(uint16_t base_sequence,
int64_t ref_timestamp_us) {
void TransportFeedback::WithBase(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::SetBase(uint16_t base_sequence,
last_timestamp_ = base_time_ * kBaseScaleFactor;
}
void TransportFeedback::SetFeedbackSequenceNumber(uint8_t feedback_sequence) {
void TransportFeedback::WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
feedback_seq_ = feedback_sequence;
}
bool TransportFeedback::AddReceivedPacket(uint16_t sequence_number,
int64_t timestamp) {
bool TransportFeedback::WithReceivedPacket(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,7 +16,6 @@
#include <vector>
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/deprecation.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
namespace webrtc {
@ -34,11 +33,13 @@ class TransportFeedback : public Rtpfb {
TransportFeedback();
~TransportFeedback() override;
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);
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);
// NOTE: This method requires increasing sequence numbers (excepting wraps).
bool AddReceivedPacket(uint16_t sequence_number, int64_t timestamp_us);
bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us);
enum class StatusSymbol {
kNotReceived,
@ -56,27 +57,13 @@ 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_->SetBase(received_seq[0], received_ts[0]);
feedback_->WithBase(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_->AddReceivedPacket(received_seq[i], time));
EXPECT_TRUE(feedback_->WithReceivedPacket(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.SetBase(0, 0);
feedback.WithBase(0, 0);
const int kSamples = 100;
const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3;
for (int i = 0; i < kSamples; ++i)
feedback.AddReceivedPacket(i, i * kTooSmallDelta);
feedback.WithReceivedPacket(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->SetBase(0, 0);
EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000));
packet->WithBase(0, 0);
EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
packet.reset(new TransportFeedback());
packet->SetBase(0, 0);
EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, 1000));
packet->WithBase(0, 0);
EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000));
// Packet status count max 0xFFFF.
packet.reset(new TransportFeedback());
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));
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));
// Too large delta.
packet.reset(new TransportFeedback());
packet->SetBase(0, 0);
packet->WithBase(0, 0);
int64_t kMaxPositiveTimeDelta = std::numeric_limits<int16_t>::max() *
TransportFeedback::kDeltaScaleFactor;
EXPECT_FALSE(packet->AddReceivedPacket(
EXPECT_FALSE(packet->WithReceivedPacket(
1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor));
EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxPositiveTimeDelta));
EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxPositiveTimeDelta));
// Too large negative delta.
packet.reset(new TransportFeedback());
packet->SetBase(0, 0);
packet->WithBase(0, 0);
int64_t kMaxNegativeTimeDelta = std::numeric_limits<int16_t>::min() *
TransportFeedback::kDeltaScaleFactor;
EXPECT_FALSE(packet->AddReceivedPacket(
EXPECT_FALSE(packet->WithReceivedPacket(
1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor));
EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxNegativeTimeDelta));
EXPECT_TRUE(packet->WithReceivedPacket(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->SetBase(0, kMaxBaseTime);
packet->AddReceivedPacket(0, kMaxBaseTime);
packet->WithBase(0, kMaxBaseTime);
packet->WithReceivedPacket(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->SetBase(0, kTooLargeBaseTime);
packet->AddReceivedPacket(0, kTooLargeBaseTime);
packet->WithBase(0, kTooLargeBaseTime);
packet->WithReceivedPacket(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.SetBase(0, 0);
EXPECT_TRUE(feedback.AddReceivedPacket(0, 0));
feedback.WithBase(0, 0);
EXPECT_TRUE(feedback.WithReceivedPacket(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.SetBase(0, 0);
feedback.WithBase(0, 0);
for (int i = 0; i < deltas; ++i)
feedback.AddReceivedPacket(i, i * 1000);
feedback.AddReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
feedback.WithReceivedPacket(i, i * 1000);
feedback.WithReceivedPacket(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 SetMediaSsrc(uint32_t ssrc) { ssrc_ = ssrc; }
void SetVoipMetric(const RTCPVoIPMetric& voip_metric) {
void To(uint32_t ssrc) { ssrc_ = ssrc; }
void WithVoipMetric(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.SetMediaSsrc(kRemoteSsrc);
metric_block.SetVoipMetric(metric);
metric_block.To(kRemoteSsrc);
metric_block.WithVoipMetric(metric);
metric_block.Create(buffer);
EXPECT_EQ(0, memcmp(buffer, kBlock, kBlockSizeBytes));