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

Remove sequence_number from RtpPacketInfo.

Browse Source 
This change removes sequence_number from RtpPacketInfo since it's currently not used.

Bug: webrtc:10668
Change-Id: I9b45c7476457df1d18173f37c421374108678931
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/141873
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Chen Xing <chxg@google.com>
Cr-Commit-Position: refs/heads/master@{#28281}
This commit is contained in:
Chen Xing
2019-06-13 20:36:12 +02:00
committed by Commit Bot
parent ad82e8e1a6
commit 12d64deb6c
5 changed files with 40 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/rtp_packet_info.cc
View File

@ -16,17 +16,15 @@
namespace webrtc { namespace webrtc {
RtpPacketInfo::RtpPacketInfo() RtpPacketInfo::RtpPacketInfo()
: ssrc_(0), sequence_number_(0), rtp_timestamp_(0), receive_time_ms_(-1) {} : ssrc_(0), rtp_timestamp_(0), receive_time_ms_(-1) {}
RtpPacketInfo::RtpPacketInfo(uint32_t ssrc, RtpPacketInfo::RtpPacketInfo(uint32_t ssrc,
std::vector<uint32_t> csrcs, std::vector<uint32_t> csrcs,
uint16_t sequence_number,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
absl::optional<uint8_t> audio_level, absl::optional<uint8_t> audio_level,
int64_t receive_time_ms) int64_t receive_time_ms)
: ssrc_(ssrc), : ssrc_(ssrc),
csrcs_(std::move(csrcs)), csrcs_(std::move(csrcs)),
sequence_number_(sequence_number),
rtp_timestamp_(rtp_timestamp), rtp_timestamp_(rtp_timestamp),
audio_level_(audio_level), audio_level_(audio_level),
receive_time_ms_(receive_time_ms) {} receive_time_ms_(receive_time_ms) {}
@ -34,7 +32,6 @@ RtpPacketInfo::RtpPacketInfo(uint32_t ssrc,
RtpPacketInfo::RtpPacketInfo(const RTPHeader& rtp_header, RtpPacketInfo::RtpPacketInfo(const RTPHeader& rtp_header,
int64_t receive_time_ms) int64_t receive_time_ms)
: ssrc_(rtp_header.ssrc), : ssrc_(rtp_header.ssrc),
sequence_number_(rtp_header.sequenceNumber),
rtp_timestamp_(rtp_header.timestamp), rtp_timestamp_(rtp_header.timestamp),
receive_time_ms_(receive_time_ms) { receive_time_ms_(receive_time_ms) {
const auto& extension = rtp_header.extension; const auto& extension = rtp_header.extension;
@ -49,7 +46,6 @@ RtpPacketInfo::RtpPacketInfo(const RTPHeader& rtp_header,
bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) { bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) {
return (lhs.ssrc() == rhs.ssrc()) && (lhs.csrcs() == rhs.csrcs()) && return (lhs.ssrc() == rhs.ssrc()) && (lhs.csrcs() == rhs.csrcs()) &&
(lhs.sequence_number() == rhs.sequence_number()) &&
(lhs.rtp_timestamp() == rhs.rtp_timestamp()) && (lhs.rtp_timestamp() == rhs.rtp_timestamp()) &&
(lhs.audio_level() == rhs.audio_level()) && (lhs.audio_level() == rhs.audio_level()) &&
(lhs.receive_time_ms() == rhs.receive_time_ms()); (lhs.receive_time_ms() == rhs.receive_time_ms());

11
api/rtp_packet_info.h
View File

@ -20,14 +20,17 @@
namespace webrtc { namespace webrtc {
// Structure to hold information about a received |RtpPacket|. //
// Structure to hold information about a received |RtpPacket|. It is primarily
// used to carry per-packet information from when a packet is received until
// the information is passed to |SourceTracker|.
//
class RtpPacketInfo { class RtpPacketInfo {
public: public:
RtpPacketInfo(); RtpPacketInfo();
RtpPacketInfo(uint32_t ssrc, RtpPacketInfo(uint32_t ssrc,
std::vector<uint32_t> csrcs, std::vector<uint32_t> csrcs,
uint16_t sequence_number,
uint32_t rtp_timestamp, uint32_t rtp_timestamp,
absl::optional<uint8_t> audio_level, absl::optional<uint8_t> audio_level,
int64_t receive_time_ms); int64_t receive_time_ms);
@ -45,9 +48,6 @@ class RtpPacketInfo {
const std::vector<uint32_t>& csrcs() const { return csrcs_; } const std::vector<uint32_t>& csrcs() const { return csrcs_; }
void set_csrcs(std::vector<uint32_t> value) { csrcs_ = std::move(value); } void set_csrcs(std::vector<uint32_t> value) { csrcs_ = std::move(value); }
uint16_t sequence_number() const { return sequence_number_; }
void set_sequence_number(uint16_t value) { sequence_number_ = value; }
uint32_t rtp_timestamp() const { return rtp_timestamp_; } uint32_t rtp_timestamp() const { return rtp_timestamp_; }
void set_rtp_timestamp(uint32_t value) { rtp_timestamp_ = value; } void set_rtp_timestamp(uint32_t value) { rtp_timestamp_ = value; }
@ -62,7 +62,6 @@ class RtpPacketInfo {
// https://tools.ietf.org/html/rfc3550#section-5.1 // https://tools.ietf.org/html/rfc3550#section-5.1
uint32_t ssrc_; uint32_t ssrc_;
std::vector<uint32_t> csrcs_; std::vector<uint32_t> csrcs_;
uint16_t sequence_number_;
uint32_t rtp_timestamp_; uint32_t rtp_timestamp_;
// Fields from the Audio Level header extension: // Fields from the Audio Level header extension:

37
api/rtp_packet_info_unittest.cc
View File

@ -38,7 +38,7 @@ TEST(RtpPacketInfoTest, Ssrc) {
rhs = RtpPacketInfo(); rhs = RtpPacketInfo();
EXPECT_NE(rhs.ssrc(), value); EXPECT_NE(rhs.ssrc(), value);
rhs = RtpPacketInfo(value, {}, {}, {}, {}, {}); rhs = RtpPacketInfo(value, {}, {}, {}, {});
EXPECT_EQ(rhs.ssrc(), value); EXPECT_EQ(rhs.ssrc(), value);
} }
@ -65,37 +65,10 @@ TEST(RtpPacketInfoTest, Csrcs) {
rhs = RtpPacketInfo(); rhs = RtpPacketInfo();
EXPECT_NE(rhs.csrcs(), value); EXPECT_NE(rhs.csrcs(), value);
rhs = RtpPacketInfo({}, value, {}, {}, {}, {}); rhs = RtpPacketInfo({}, value, {}, {}, {});
EXPECT_EQ(rhs.csrcs(), value); EXPECT_EQ(rhs.csrcs(), value);
} }
TEST(RtpPacketInfoTest, SequenceNumber) {
const uint16_t value = 20238;
RtpPacketInfo lhs;
RtpPacketInfo rhs;
EXPECT_TRUE(lhs == rhs);
EXPECT_FALSE(lhs != rhs);
rhs.set_sequence_number(value);
EXPECT_EQ(rhs.sequence_number(), value);
EXPECT_FALSE(lhs == rhs);
EXPECT_TRUE(lhs != rhs);
lhs = rhs;
EXPECT_TRUE(lhs == rhs);
EXPECT_FALSE(lhs != rhs);
rhs = RtpPacketInfo();
EXPECT_NE(rhs.sequence_number(), value);
rhs = RtpPacketInfo({}, {}, value, {}, {}, {});
EXPECT_EQ(rhs.sequence_number(), value);
}
TEST(RtpPacketInfoTest, RtpTimestamp) { TEST(RtpPacketInfoTest, RtpTimestamp) {
const uint32_t value = 4038189233; const uint32_t value = 4038189233;
@ -119,7 +92,7 @@ TEST(RtpPacketInfoTest, RtpTimestamp) {
rhs = RtpPacketInfo(); rhs = RtpPacketInfo();
EXPECT_NE(rhs.rtp_timestamp(), value); EXPECT_NE(rhs.rtp_timestamp(), value);
rhs = RtpPacketInfo({}, {}, {}, value, {}, {}); rhs = RtpPacketInfo({}, {}, value, {}, {});
EXPECT_EQ(rhs.rtp_timestamp(), value); EXPECT_EQ(rhs.rtp_timestamp(), value);
} }
@ -146,7 +119,7 @@ TEST(RtpPacketInfoTest, AudioLevel) {
rhs = RtpPacketInfo(); rhs = RtpPacketInfo();
EXPECT_NE(rhs.audio_level(), value); EXPECT_NE(rhs.audio_level(), value);
rhs = RtpPacketInfo({}, {}, {}, {}, value, {}); rhs = RtpPacketInfo({}, {}, {}, value, {});
EXPECT_EQ(rhs.audio_level(), value); EXPECT_EQ(rhs.audio_level(), value);
} }
@ -173,7 +146,7 @@ TEST(RtpPacketInfoTest, ReceiveTimeMs) {
rhs = RtpPacketInfo(); rhs = RtpPacketInfo();
EXPECT_NE(rhs.receive_time_ms(), value); EXPECT_NE(rhs.receive_time_ms(), value);
rhs = RtpPacketInfo({}, {}, {}, {}, {}, value); rhs = RtpPacketInfo({}, {}, {}, {}, value);
EXPECT_EQ(rhs.receive_time_ms(), value); EXPECT_EQ(rhs.receive_time_ms(), value);
} }

12
api/rtp_packet_infos_unittest.cc
View File

@ -27,9 +27,9 @@ RtpPacketInfos::vector_type ToVector(Iterator begin, Iterator end) {
} // namespace } // namespace
TEST(RtpPacketInfosTest, BasicFunctionality) { TEST(RtpPacketInfosTest, BasicFunctionality) {
RtpPacketInfo p0(123, {1, 2}, 42, 89, 5, 7); RtpPacketInfo p0(123, {1, 2}, 89, 5, 7);
RtpPacketInfo p1(456, {3, 4}, 37, 89, 4, 1); RtpPacketInfo p1(456, {3, 4}, 89, 4, 1);
RtpPacketInfo p2(789, {5, 6}, 91, 88, 1, 7); RtpPacketInfo p2(789, {5, 6}, 88, 1, 7);
RtpPacketInfos x({p0, p1, p2}); RtpPacketInfos x({p0, p1, p2});
@ -52,9 +52,9 @@ TEST(RtpPacketInfosTest, BasicFunctionality) {
} }
TEST(RtpPacketInfosTest, CopyShareData) { TEST(RtpPacketInfosTest, CopyShareData) {
RtpPacketInfo p0(123, {1, 2}, 42, 89, 5, 7); RtpPacketInfo p0(123, {1, 2}, 89, 5, 7);
RtpPacketInfo p1(456, {3, 4}, 37, 89, 4, 1); RtpPacketInfo p1(456, {3, 4}, 89, 4, 1);
RtpPacketInfo p2(789, {5, 6}, 91, 88, 1, 7); RtpPacketInfo p2(789, {5, 6}, 88, 1, 7);
RtpPacketInfos lhs({p0, p1, p2}); RtpPacketInfos lhs({p0, p1, p2});
RtpPacketInfos rhs = lhs; RtpPacketInfos rhs = lhs;

49
modules/rtp_rtcp/source/source_tracker_unittest.cc
View File

@ -108,7 +108,6 @@ class SourceTrackerRandomTest
RtpPacketInfos::vector_type packet_infos; RtpPacketInfos::vector_type packet_infos;
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
packet_infos.emplace_back(GenerateSsrc(), GenerateCsrcs(), packet_infos.emplace_back(GenerateSsrc(), GenerateCsrcs(),
GenerateSequenceNumber(),
GenerateRtpTimestamp(), GenerateAudioLevel(), GenerateRtpTimestamp(), GenerateAudioLevel(),
GenerateReceiveTimeMs()); GenerateReceiveTimeMs());
} }
@ -157,10 +156,6 @@ class SourceTrackerRandomTest
return csrcs; return csrcs;
} }
uint16_t GenerateSequenceNumber() {
return std::uniform_int_distribution<uint16_t>()(generator_);
}
uint32_t GenerateRtpTimestamp() { uint32_t GenerateRtpTimestamp() {
return std::uniform_int_distribution<uint32_t>()(generator_); return std::uniform_int_distribution<uint32_t>()(generator_);
} }
@ -224,8 +219,8 @@ TEST(SourceTrackerTest, StartEmpty) {
TEST(SourceTrackerTest, OnFrameDeliveredRecordsSources) { TEST(SourceTrackerTest, OnFrameDeliveredRecordsSources) {
constexpr uint32_t kSsrc = 10; constexpr uint32_t kSsrc = 10;
constexpr uint32_t kCsrcs[] = {20, 21}; constexpr uint32_t kCsrcs0 = 20;
constexpr uint16_t kSequenceNumber = 30; constexpr uint32_t kCsrcs1 = 21;
constexpr uint32_t kRtpTimestamp = 40; constexpr uint32_t kRtpTimestamp = 40;
constexpr absl::optional<uint8_t> kAudioLevel = 50; constexpr absl::optional<uint8_t> kAudioLevel = 50;
constexpr int64_t kReceiveTimeMs = 60; constexpr int64_t kReceiveTimeMs = 60;
@ -233,19 +228,17 @@ TEST(SourceTrackerTest, OnFrameDeliveredRecordsSources) {
SimulatedClock clock(1000000000000ULL); SimulatedClock clock(1000000000000ULL);
SourceTracker tracker(&clock); SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos( tracker.OnFrameDelivered(RtpPacketInfos({RtpPacketInfo(
{RtpPacketInfo(kSsrc, {kCsrcs[0], kCsrcs[1]}, kSequenceNumber, kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp, kAudioLevel, kReceiveTimeMs)}));
kRtpTimestamp, kAudioLevel, kReceiveTimeMs)}));
int64_t timestamp_ms = clock.TimeInMilliseconds(); int64_t timestamp_ms = clock.TimeInMilliseconds();
EXPECT_THAT( EXPECT_THAT(tracker.GetSources(),
tracker.GetSources(),
ElementsAre(RtpSource(timestamp_ms, kSsrc, RtpSourceType::SSRC, ElementsAre(RtpSource(timestamp_ms, kSsrc, RtpSourceType::SSRC,
kAudioLevel, kRtpTimestamp), kAudioLevel, kRtpTimestamp),
RtpSource(timestamp_ms, kCsrcs[1], RtpSourceType::CSRC, RtpSource(timestamp_ms, kCsrcs1, RtpSourceType::CSRC,
kAudioLevel, kRtpTimestamp), kAudioLevel, kRtpTimestamp),
RtpSource(timestamp_ms, kCsrcs[0], RtpSourceType::CSRC, RtpSource(timestamp_ms, kCsrcs0, RtpSourceType::CSRC,
kAudioLevel, kRtpTimestamp))); kAudioLevel, kRtpTimestamp)));
} }
@ -254,8 +247,6 @@ TEST(SourceTrackerTest, OnFrameDeliveredUpdatesSources) {
constexpr uint32_t kCsrcs0 = 20; constexpr uint32_t kCsrcs0 = 20;
constexpr uint32_t kCsrcs1 = 21; constexpr uint32_t kCsrcs1 = 21;
constexpr uint32_t kCsrcs2 = 22; constexpr uint32_t kCsrcs2 = 22;
constexpr uint16_t kSequenceNumber0 = 30;
constexpr uint16_t kSequenceNumber1 = 31;
constexpr uint32_t kRtpTimestamp0 = 40; constexpr uint32_t kRtpTimestamp0 = 40;
constexpr uint32_t kRtpTimestamp1 = 41; constexpr uint32_t kRtpTimestamp1 = 41;
constexpr absl::optional<uint8_t> kAudioLevel0 = 50; constexpr absl::optional<uint8_t> kAudioLevel0 = 50;
@ -266,17 +257,17 @@ TEST(SourceTrackerTest, OnFrameDeliveredUpdatesSources) {
SimulatedClock clock(1000000000000ULL); SimulatedClock clock(1000000000000ULL);
SourceTracker tracker(&clock); SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos( tracker.OnFrameDelivered(
{RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kSequenceNumber0, RtpPacketInfos({RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0,
kRtpTimestamp0, kAudioLevel0, kReceiveTimeMs0)})); kAudioLevel0, kReceiveTimeMs0)}));
int64_t timestamp_ms_0 = clock.TimeInMilliseconds(); int64_t timestamp_ms_0 = clock.TimeInMilliseconds();
clock.AdvanceTimeMilliseconds(17); clock.AdvanceTimeMilliseconds(17);
tracker.OnFrameDelivered(RtpPacketInfos( tracker.OnFrameDelivered(
{RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kSequenceNumber1, RtpPacketInfos({RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kRtpTimestamp1,
kRtpTimestamp1, kAudioLevel1, kReceiveTimeMs1)})); kAudioLevel1, kReceiveTimeMs1)}));
int64_t timestamp_ms_1 = clock.TimeInMilliseconds(); int64_t timestamp_ms_1 = clock.TimeInMilliseconds();
@ -297,8 +288,6 @@ TEST(SourceTrackerTest, TimedOutSourcesAreRemoved) {
constexpr uint32_t kCsrcs0 = 20; constexpr uint32_t kCsrcs0 = 20;
constexpr uint32_t kCsrcs1 = 21; constexpr uint32_t kCsrcs1 = 21;
constexpr uint32_t kCsrcs2 = 22; constexpr uint32_t kCsrcs2 = 22;
constexpr uint16_t kSequenceNumber0 = 30;
constexpr uint16_t kSequenceNumber1 = 31;
constexpr uint32_t kRtpTimestamp0 = 40; constexpr uint32_t kRtpTimestamp0 = 40;
constexpr uint32_t kRtpTimestamp1 = 41; constexpr uint32_t kRtpTimestamp1 = 41;
constexpr absl::optional<uint8_t> kAudioLevel0 = 50; constexpr absl::optional<uint8_t> kAudioLevel0 = 50;
@ -309,15 +298,15 @@ TEST(SourceTrackerTest, TimedOutSourcesAreRemoved) {
SimulatedClock clock(1000000000000ULL); SimulatedClock clock(1000000000000ULL);
SourceTracker tracker(&clock); SourceTracker tracker(&clock);
tracker.OnFrameDelivered(RtpPacketInfos( tracker.OnFrameDelivered(
{RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kSequenceNumber0, RtpPacketInfos({RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs1}, kRtpTimestamp0,
kRtpTimestamp0, kAudioLevel0, kReceiveTimeMs0)})); kAudioLevel0, kReceiveTimeMs0)}));
clock.AdvanceTimeMilliseconds(17); clock.AdvanceTimeMilliseconds(17);
tracker.OnFrameDelivered(RtpPacketInfos( tracker.OnFrameDelivered(
{RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kSequenceNumber1, RtpPacketInfos({RtpPacketInfo(kSsrc, {kCsrcs0, kCsrcs2}, kRtpTimestamp1,
kRtpTimestamp1, kAudioLevel1, kReceiveTimeMs1)})); kAudioLevel1, kReceiveTimeMs1)}));
int64_t timestamp_ms_1 = clock.TimeInMilliseconds(); int64_t timestamp_ms_1 = clock.TimeInMilliseconds();