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

Replace virtual RtcpPacket::SetSenderSsrc with base member

Browse Source 
to slightly improve binary size.

Bug: None
Change-Id: I894c7d67a72f4a8077963d2ba0a7bb471a2e7e4d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/156300
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29428}
This commit is contained in:
Danil Chapovalov
2019-10-10 09:56:29 +02:00
committed by Commit Bot
parent 907f1548af
commit cbbfd08423
19 changed files with 39 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/rtp_rtcp/source/rtcp_packet.h
View File

@ -56,7 +56,10 @@ class RtcpPacket {
using PacketReadyCallback =
rtc::FunctionView<void(rtc::ArrayView<const uint8_t> packet)>;
virtual ~RtcpPacket() {}
virtual ~RtcpPacket() = default;
void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
uint32_t sender_ssrc() const { return sender_ssrc_; }
// Convenience method mostly used for test. Creates packet without
// fragmentation using BlockLength() to allocate big enough buffer.
@ -76,8 +79,6 @@ class RtcpPacket {
size_t max_length,
PacketReadyCallback callback) const = 0;
virtual void SetSenderSsrc(uint32_t ssrc) = 0;
protected:
// Size of the rtcp common header.
static constexpr size_t kHeaderLength = 4;
@ -101,6 +102,9 @@ class RtcpPacket {
PacketReadyCallback callback) const;
// Size of the rtcp packet as written in header.
size_t HeaderLength() const;
private:
uint32_t sender_ssrc_ = 0;
};
} // namespace rtcp
} // namespace webrtc

6
modules/rtp_rtcp/source/rtcp_packet/app.cc
View File

@ -37,7 +37,7 @@ constexpr size_t App::kMaxDataSize;
// 8 | application-dependent data ...
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
App::App() : sub_type_(0), ssrc_(0), name_(0) {}
App::App() : sub_type_(0), name_(0) {}
App::~App() = default;
@ -53,7 +53,7 @@ bool App::Parse(const CommonHeader& packet) {
return false;
}
sub_type_ = packet.fmt();
ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&packet.payload()[0]);
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(&packet.payload()[0]));
name_ = ByteReader<uint32_t>::ReadBigEndian(&packet.payload()[4]);
data_.SetData(packet.payload() + kAppBaseLength,
packet.payload_size_bytes() - kAppBaseLength);
@ -89,7 +89,7 @@ bool App::Create(uint8_t* packet,
const size_t index_end = *index + BlockLength();
CreateHeader(sub_type_, kPacketType, HeaderLength(), packet, index);
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 0], ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 0], sender_ssrc());
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 4], name_);
memcpy(&packet[*index + 8], data_.data(), data_.size());
*index += (8 + data_.size());

3
modules/rtp_rtcp/source/rtcp_packet/app.h
View File

@ -31,13 +31,11 @@ class App : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void SetSenderSsrc(uint32_t ssrc) override { 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_; }
uint32_t name() const { return name_; }
size_t data_size() const { return data_.size(); }
const uint8_t* data() const { return data_.data(); }
@ -60,7 +58,6 @@ class App : public RtcpPacket {
static constexpr size_t kMaxDataSize = 0xffff * 4 - kAppBaseLength;
uint8_t sub_type_;
uint32_t ssrc_;
uint32_t name_;
rtc::Buffer data_;
};

4
modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc
View File

@ -67,7 +67,7 @@ TEST(RtcpPacketAppTest, ParseWithoutData) {
App parsed;
EXPECT_TRUE(test::ParseSinglePacket(kPacketWithoutData, &parsed));
EXPECT_EQ(kSenderSsrc, parsed.ssrc());
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kSubtype, parsed.sub_type());
EXPECT_EQ(kName, parsed.name());
EXPECT_EQ(0u, parsed.data_size());
@ -90,7 +90,7 @@ TEST(RtcpPacketAppTest, ParseWithData) {
App parsed;
EXPECT_TRUE(test::ParseSinglePacket(kPacketWithData, &parsed));
EXPECT_EQ(kSenderSsrc, parsed.ssrc());
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kSubtype, parsed.sub_type());
EXPECT_EQ(kName, parsed.name());
EXPECT_THAT(make_tuple(parsed.data(), parsed.data_size()),

8
modules/rtp_rtcp/source/rtcp_packet/bye.cc
View File

@ -35,7 +35,7 @@ constexpr uint8_t Bye::kPacketType;
// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// (opt) | length | reason for leaving ...
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Bye::Bye() : sender_ssrc_(0) {}
Bye::Bye() = default;
Bye::~Bye() = default;
@ -61,10 +61,10 @@ bool Bye::Parse(const CommonHeader& packet) {
}
// Once sure packet is valid, copy values.
if (src_count == 0) { // A count value of zero is valid, but useless.
sender_ssrc_ = 0;
SetSenderSsrc(0);
csrcs_.clear();
} else {
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(payload);
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(payload));
csrcs_.resize(src_count - 1);
for (size_t i = 1; i < src_count; ++i)
csrcs_[i - 1] = ByteReader<uint32_t>::ReadBigEndian(&payload[4 * i]);
@ -92,7 +92,7 @@ bool Bye::Create(uint8_t* packet,
CreateHeader(1 + csrcs_.size(), kPacketType, HeaderLength(), packet, index);
// Store srcs of the leaving clients.
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index], sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index], sender_ssrc());
*index += sizeof(uint32_t);
for (uint32_t csrc : csrcs_) {
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index], csrc);

3
modules/rtp_rtcp/source/rtcp_packet/bye.h
View File

@ -31,11 +31,9 @@ class Bye : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void SetSenderSsrc(uint32_t ssrc) override { 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_; }
const std::string& reason() const { return reason_; }
@ -49,7 +47,6 @@ class Bye : public RtcpPacket {
private:
static const int kMaxNumberOfCsrcs = 0x1f - 1; // First item is sender SSRC.
uint32_t sender_ssrc_;
std::vector<uint32_t> csrcs_;
std::string reason_;
};

2
modules/rtp_rtcp/source/rtcp_packet/compound_packet.h
View File

@ -35,8 +35,6 @@ class CompoundPacket : public RtcpPacket {
size_t max_length,
PacketReadyCallback callback) const override;
void SetSenderSsrc(uint32_t /*ssrc*/) override { RTC_NOTREACHED(); }
protected:
std::vector<RtcpPacket*> appended_packets_;

2
modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
View File

@ -43,8 +43,6 @@ class ExtendedJitterReport : public RtcpPacket {
size_t max_length,
PacketReadyCallback callback) const override;
void SetSenderSsrc(uint32_t /*ssrc*/) override {}
private:
static constexpr size_t kJitterSizeBytes = 4;

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

@ -43,7 +43,7 @@ constexpr size_t ExtendedReports::kMaxNumberOfDlrrItems;
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// : type-specific block contents :
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
ExtendedReports::ExtendedReports() : sender_ssrc_(0) {}
ExtendedReports::ExtendedReports() = default;
ExtendedReports::ExtendedReports(const ExtendedReports& xr) = default;
ExtendedReports::~ExtendedReports() = default;
@ -56,7 +56,7 @@ bool ExtendedReports::Parse(const CommonHeader& packet) {
return false;
}
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(packet.payload());
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(packet.payload()));
rrtr_block_.reset();
dlrr_block_.ClearItems();
target_bitrate_ = absl::nullopt;
@ -136,7 +136,7 @@ bool ExtendedReports::Create(uint8_t* packet,
size_t index_end = *index + BlockLength();
const uint8_t kReserved = 0;
CreateHeader(kReserved, kPacketType, HeaderLength(), packet, index);
ByteWriter<uint32_t>::WriteBigEndian(packet + *index, sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(packet + *index, sender_ssrc());
*index += sizeof(uint32_t);
if (rrtr_block_) {
rrtr_block_->Create(packet + *index);

4
modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
View File

@ -36,13 +36,10 @@ class ExtendedReports : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void SetSenderSsrc(uint32_t ssrc) override { sender_ssrc_ = ssrc; }
void SetRrtr(const Rrtr& rrtr);
bool AddDlrrItem(const ReceiveTimeInfo& time_info);
void SetTargetBitrate(const TargetBitrate& target_bitrate);
uint32_t sender_ssrc() const { return sender_ssrc_; }
const absl::optional<Rrtr>& rrtr() const { return rrtr_block_; }
const Dlrr& dlrr() const { return dlrr_block_; }
const absl::optional<TargetBitrate>& target_bitrate() const {
@ -68,7 +65,6 @@ class ExtendedReports : public RtcpPacket {
void ParseVoipMetricBlock(const uint8_t* block, uint16_t block_length);
void ParseTargetBitrateBlock(const uint8_t* block, uint16_t block_length);
uint32_t sender_ssrc_;
absl::optional<Rrtr> rrtr_block_;
Dlrr dlrr_block_; // Dlrr without items treated same as no dlrr block.
absl::optional<TargetBitrate> target_bitrate_;

8
modules/rtp_rtcp/source/rtcp_packet/psfb.cc
View File

@ -34,13 +34,13 @@ constexpr size_t Psfb::kCommonFeedbackLength;
// : :
void Psfb::ParseCommonFeedback(const uint8_t* payload) {
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[0]);
media_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[4]);
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(&payload[0]));
SetMediaSsrc(ByteReader<uint32_t>::ReadBigEndian(&payload[4]));
}
void Psfb::CreateCommonFeedback(uint8_t* payload) const {
ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc());
ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc());
}
} // namespace rtcp

9
modules/rtp_rtcp/source/rtcp_packet/psfb.h
View File

@ -27,13 +27,11 @@ class Psfb : public RtcpPacket {
static constexpr uint8_t kPacketType = 206;
static constexpr uint8_t kAfbMessageType = 15;
Psfb() : sender_ssrc_(0), media_ssrc_(0) {}
~Psfb() override {}
Psfb() = default;
~Psfb() override = default;
void SetSenderSsrc(uint32_t ssrc) override { 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_; }
protected:
@ -42,8 +40,7 @@ class Psfb : public RtcpPacket {
void CreateCommonFeedback(uint8_t* payload) const;
private:
uint32_t sender_ssrc_;
uint32_t media_ssrc_;
uint32_t media_ssrc_ = 0;
};
} // namespace rtcp

6
modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc
View File

@ -33,7 +33,7 @@ constexpr size_t ReceiverReport::kMaxNumberOfReportBlocks;
// | report block(s) |
// | .... |
ReceiverReport::ReceiverReport() : sender_ssrc_(0) {}
ReceiverReport::ReceiverReport() = default;
ReceiverReport::ReceiverReport(const ReceiverReport& rhs) = default;
@ -50,7 +50,7 @@ bool ReceiverReport::Parse(const CommonHeader& packet) {
return false;
}
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(packet.payload());
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(packet.payload()));
const uint8_t* next_report_block = packet.payload() + kRrBaseLength;
@ -80,7 +80,7 @@ bool ReceiverReport::Create(uint8_t* packet,
}
CreateHeader(report_blocks_.size(), kPacketType, HeaderLength(), packet,
index);
ByteWriter<uint32_t>::WriteBigEndian(packet + *index, sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(packet + *index, sender_ssrc());
*index += kRrBaseLength;
for (const ReportBlock& block : report_blocks_) {
block.Create(packet + *index);

3
modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
View File

@ -35,11 +35,9 @@ class ReceiverReport : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void SetSenderSsrc(uint32_t ssrc) override { sender_ssrc_ = ssrc; }
bool AddReportBlock(const ReportBlock& block);
bool SetReportBlocks(std::vector<ReportBlock> blocks);
uint32_t sender_ssrc() const { return sender_ssrc_; }
const std::vector<ReportBlock>& report_blocks() const {
return report_blocks_;
}
@ -54,7 +52,6 @@ class ReceiverReport : public RtcpPacket {
private:
static const size_t kRrBaseLength = 4;
uint32_t sender_ssrc_;
std::vector<ReportBlock> report_blocks_;
};

8
modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc
View File

@ -32,13 +32,13 @@ constexpr uint8_t Rtpfb::kPacketType;
// : :
void Rtpfb::ParseCommonFeedback(const uint8_t* payload) {
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[0]);
media_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[4]);
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(&payload[0]));
SetMediaSsrc(ByteReader<uint32_t>::ReadBigEndian(&payload[4]));
}
void Rtpfb::CreateCommonFeedback(uint8_t* payload) const {
ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc());
ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc());
}
} // namespace rtcp

9
modules/rtp_rtcp/source/rtcp_packet/rtpfb.h
View File

@ -26,13 +26,11 @@ class Rtpfb : public RtcpPacket {
public:
static constexpr uint8_t kPacketType = 205;
Rtpfb() : sender_ssrc_(0), media_ssrc_(0) {}
~Rtpfb() override {}
Rtpfb() = default;
~Rtpfb() override = default;
void SetSenderSsrc(uint32_t ssrc) override { 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_; }
protected:
@ -41,8 +39,7 @@ class Rtpfb : public RtcpPacket {
void CreateCommonFeedback(uint8_t* payload) const;
private:
uint32_t sender_ssrc_;
uint32_t media_ssrc_;
uint32_t media_ssrc_ = 0;
};
} // namespace rtcp

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

@ -46,8 +46,6 @@ class Sdes : public RtcpPacket {
size_t max_length,
PacketReadyCallback callback) const override;
void SetSenderSsrc(uint32_t /*ssrc*/) override {}
private:
std::vector<Chunk> chunks_;
size_t block_length_;

9
modules/rtp_rtcp/source/rtcp_packet/sender_report.cc
View File

@ -42,10 +42,7 @@ constexpr size_t SenderReport::kSenderBaseLength;
// 24 +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
SenderReport::SenderReport()
: sender_ssrc_(0),
rtp_timestamp_(0),
sender_packet_count_(0),
sender_octet_count_(0) {}
: rtp_timestamp_(0), sender_packet_count_(0), sender_octet_count_(0) {}
SenderReport::SenderReport(const SenderReport&) = default;
SenderReport::SenderReport(SenderReport&&) = default;
@ -64,7 +61,7 @@ bool SenderReport::Parse(const CommonHeader& packet) {
}
// Read SenderReport header.
const uint8_t* const payload = packet.payload();
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[0]);
SetSenderSsrc(ByteReader<uint32_t>::ReadBigEndian(&payload[0]));
uint32_t secs = ByteReader<uint32_t>::ReadBigEndian(&payload[4]);
uint32_t frac = ByteReader<uint32_t>::ReadBigEndian(&payload[8]);
ntp_.Set(secs, frac);
@ -102,7 +99,7 @@ bool SenderReport::Create(uint8_t* packet,
CreateHeader(report_blocks_.size(), kPacketType, HeaderLength(), packet,
index);
// Write SenderReport header.
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 0], sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 0], sender_ssrc());
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 4], ntp_.seconds());
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 8], ntp_.fractions());
ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 12], rtp_timestamp_);

3
modules/rtp_rtcp/source/rtcp_packet/sender_report.h
View File

@ -36,7 +36,6 @@ class SenderReport : public RtcpPacket {
// Parse assumes header is already parsed and validated.
bool Parse(const CommonHeader& packet);
void SetSenderSsrc(uint32_t ssrc) override { sender_ssrc_ = ssrc; }
void SetNtp(NtpTime ntp) { ntp_ = ntp; }
void SetRtpTimestamp(uint32_t rtp_timestamp) {
rtp_timestamp_ = rtp_timestamp;
@ -51,7 +50,6 @@ class SenderReport : public RtcpPacket {
bool SetReportBlocks(std::vector<ReportBlock> blocks);
void ClearReportBlocks() { report_blocks_.clear(); }
uint32_t sender_ssrc() const { return sender_ssrc_; }
NtpTime ntp() const { return ntp_; }
uint32_t rtp_timestamp() const { return rtp_timestamp_; }
uint32_t sender_packet_count() const { return sender_packet_count_; }
@ -71,7 +69,6 @@ class SenderReport : public RtcpPacket {
private:
static constexpr size_t kSenderBaseLength = 24;
uint32_t sender_ssrc_;
NtpTime ntp_;
uint32_t rtp_timestamp_;
uint32_t sender_packet_count_;