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

Replace RTCPUtility RtcpParser with Test RtcpParser

Browse Source 
making code cleaner

BUG=webrtc:5565

Review-Url: https://codereview.webrtc.org/2372113005
Cr-Commit-Position: refs/heads/master@{#14893}
This commit is contained in:
danilchap 2016-11-02 08:21:59 -07:00 committed by Commit bot
parent 5881d552c5
commit 3dc929ea56
5 changed files with 90 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/call/call_perf_tests.cc
View File

@ -22,7 +22,6 @@
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/audio_coding/include/audio_coding_module.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/metrics_default.h"
#include "webrtc/system_wrappers/include/rtp_to_ntp.h"

28
webrtc/test/rtcp_packet_parser.cc
View File

@ -36,10 +36,10 @@ bool RtcpPacketParser::Parse(const void* data, size_t length) {
app_.Parse(header);
break;
case rtcp::Bye::kPacketType:
bye_.Parse(header);
bye_.Parse(header, &sender_ssrc_);
break;
case rtcp::ExtendedReports::kPacketType:
xr_.Parse(header);
xr_.Parse(header, &sender_ssrc_);
break;
case rtcp::ExtendedJitterReport::kPacketType:
ij_.Parse(header);
@ -47,19 +47,19 @@ bool RtcpPacketParser::Parse(const void* data, size_t length) {
case rtcp::Psfb::kPacketType:
switch (header.fmt()) {
case rtcp::Fir::kFeedbackMessageType:
fir_.Parse(header);
fir_.Parse(header, &sender_ssrc_);
break;
case rtcp::Pli::kFeedbackMessageType:
pli_.Parse(header);
pli_.Parse(header, &sender_ssrc_);
break;
case rtcp::Remb::kFeedbackMessageType:
remb_.Parse(header);
remb_.Parse(header, &sender_ssrc_);
break;
case rtcp::Rpsi::kFeedbackMessageType:
rpsi_.Parse(header);
rpsi_.Parse(header, &sender_ssrc_);
break;
case rtcp::Sli::kFeedbackMessageType:
sli_.Parse(header);
sli_.Parse(header, &sender_ssrc_);
break;
default:
LOG(LS_WARNING) << "Unknown rtcp payload specific feedback type "
@ -68,24 +68,24 @@ bool RtcpPacketParser::Parse(const void* data, size_t length) {
}
break;
case rtcp::ReceiverReport::kPacketType:
receiver_report_.Parse(header);
receiver_report_.Parse(header, &sender_ssrc_);
break;
case rtcp::Rtpfb::kPacketType:
switch (header.fmt()) {
case rtcp::Nack::kFeedbackMessageType:
nack_.Parse(header);
nack_.Parse(header, &sender_ssrc_);
break;
case rtcp::RapidResyncRequest::kFeedbackMessageType:
rrr_.Parse(header);
rrr_.Parse(header, &sender_ssrc_);
break;
case rtcp::Tmmbn::kFeedbackMessageType:
tmmbn_.Parse(header);
tmmbn_.Parse(header, &sender_ssrc_);
break;
case rtcp::Tmmbr::kFeedbackMessageType:
tmmbr_.Parse(header);
tmmbr_.Parse(header, &sender_ssrc_);
break;
case rtcp::TransportFeedback::kFeedbackMessageType:
transport_feedback_.Parse(header);
transport_feedback_.Parse(header, &sender_ssrc_);
break;
default:
LOG(LS_WARNING) << "Unknown rtcp transport feedback type "
@ -97,7 +97,7 @@ bool RtcpPacketParser::Parse(const void* data, size_t length) {
sdes_.Parse(header);
break;
case rtcp::SenderReport::kPacketType:
sender_report_.Parse(header);
sender_report_.Parse(header, &sender_ssrc_);
break;
default:
LOG(LS_WARNING) << "Unknown rtcp packet type " << header.type();

9
webrtc/test/rtcp_packet_parser.h
View File

@ -61,6 +61,13 @@ class RtcpPacketParser {
if (TypedRtcpPacket::Parse(header))
++num_packets_;
}
void Parse(const rtcp::CommonHeader& header, uint32_t* sender_ssrc) {
if (TypedRtcpPacket::Parse(header)) {
++num_packets_;
if (*sender_ssrc == 0) // Use first sender ssrc in compound packet.
*sender_ssrc = TypedRtcpPacket::sender_ssrc();
}
}
private:
int num_packets_ = 0;
@ -92,6 +99,7 @@ class RtcpPacketParser {
PacketCounter<rtcp::TransportFeedback>* transport_feedback() {
return &transport_feedback_;
}
uint32_t sender_ssrc() const { return sender_ssrc_; }
private:
PacketCounter<rtcp::App> app_;
@ -111,6 +119,7 @@ class RtcpPacketParser {
PacketCounter<rtcp::Tmmbn> tmmbn_;
PacketCounter<rtcp::Tmmbr> tmmbr_;
PacketCounter<rtcp::TransportFeedback> transport_feedback_;
uint32_t sender_ssrc_ = 0;
};
} // namespace test

154
webrtc/video/end_to_end_tests.cc
View File

@ -30,7 +30,6 @@
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
@ -400,14 +399,9 @@ TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
uint32_t ssrc = 0;
ssrc |= static_cast<uint32_t>(packet[4]) << 24;
ssrc |= static_cast<uint32_t>(packet[5]) << 16;
ssrc |= static_cast<uint32_t>(packet[6]) << 8;
ssrc |= static_cast<uint32_t>(packet[7]) << 0;
EXPECT_EQ(kReceiverLocalVideoSsrc, ssrc);
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc());
observation_complete_.Set();
return SEND_PACKET;
@ -473,17 +467,9 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kRtpfbNack) {
--nacks_left_;
break;
}
packet_type = parser.Iterate();
}
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
nacks_left_ -= parser.nack()->num_packets();
return SEND_PACKET;
}
@ -1031,20 +1017,12 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
packet_type = parser.Iterate()) {
if (!nack_enabled_)
EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kRtpfbNack);
if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbPli) {
received_pli_ = true;
break;
}
}
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
if (!nack_enabled_)
EXPECT_EQ(0, parser.nack()->num_packets());
if (parser.pli()->num_packets() > 0)
received_pli_ = true;
return SEND_PACKET;
}
@ -1171,23 +1149,14 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
++sent_rtcp_;
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
bool has_report_block = false;
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
EXPECT_NE(RTCPUtility::RTCPPacketTypes::kSr, packet_type);
if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
has_report_block = true;
break;
}
packet_type = parser.Iterate();
}
EXPECT_EQ(0, parser.sender_report()->num_packets());
switch (rtcp_mode_) {
case RtcpMode::kCompound:
if (!has_report_block) {
if (parser.receiver_report()->num_packets() == 0) {
ADD_FAILURE() << "Received RTCP packet without receiver report for "
"RtcpMode::kCompound.";
observation_complete_.Set();
@ -1198,7 +1167,7 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
break;
case RtcpMode::kReducedSize:
if (!has_report_block)
if (parser.receiver_report()->num_packets() == 0)
observation_complete_.Set();
break;
case RtcpMode::kOff:
@ -1643,17 +1612,9 @@ class TransportFeedbackTester : public test::EndToEndTest {
}
bool HasTransportFeedback(const uint8_t* data, size_t length) const {
RTCPUtility::RTCPParserV2 parser(data, length, true);
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback)
return true;
packet_type = parser.Iterate();
}
return false;
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(data, length));
return parser.transport_feedback()->num_packets() > 0;
}
void PerformTest() override {
@ -1807,28 +1768,17 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
bool received_psfb = false;
bool received_remb = false;
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRemb) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalVideoSsrc);
received_psfb = true;
} else if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRembItem) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
EXPECT_GT(packet.REMBItem.BitRate, 0u);
EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
EXPECT_EQ(packet.REMBItem.SSRCs[0], kVideoSendSsrcs[0]);
received_remb = true;
}
packet_type = parser.Iterate();
}
if (received_psfb && received_remb)
if (parser.remb()->num_packets() > 0) {
EXPECT_EQ(kReceiverLocalVideoSsrc, parser.remb()->sender_ssrc());
EXPECT_LT(0U, parser.remb()->bitrate_bps());
EXPECT_EQ(1U, parser.remb()->ssrcs().size());
EXPECT_EQ(kVideoSendSsrcs[0], parser.remb()->ssrcs()[0]);
observation_complete_.Set();
}
return SEND_PACKET;
}
void PerformTest() override {
@ -2391,47 +2341,39 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
// Receive stream should send RR packets (and RRTR packets if enabled).
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
++sent_rtcp_rr_;
} else if (packet_type ==
RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime) {
sent_rtcp_rr_ += parser.receiver_report()->num_packets();
EXPECT_EQ(0, parser.sender_report()->num_packets());
EXPECT_GE(1, parser.xr()->num_packets());
if (parser.xr()->num_packets() > 0) {
if (parser.xr()->rrtr())
++sent_rtcp_rrtr_;
}
EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kSr);
EXPECT_NE(packet_type,
RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem);
packet_type = parser.Iterate();
EXPECT_FALSE(parser.xr()->dlrr());
}
return SEND_PACKET;
}
// Send stream should send SR packets (and DLRR packets if enabled).
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
++sent_rtcp_sr_;
} else if (packet_type ==
RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem) {
sent_rtcp_sr_ += parser.sender_report()->num_packets();
EXPECT_GE(1, parser.xr()->num_packets());
if (parser.xr()->num_packets() > 0) {
EXPECT_FALSE(parser.xr()->rrtr());
if (parser.xr()->dlrr())
++sent_rtcp_dlrr_;
}
EXPECT_NE(packet_type,
RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime);
packet_type = parser.Iterate();
}
if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
if (enable_rrtr_) {
EXPECT_GT(sent_rtcp_rrtr_, 0);
EXPECT_GT(sent_rtcp_dlrr_, 0);
EXPECT_LT(0, sent_rtcp_rrtr_);
EXPECT_LT(0, sent_rtcp_dlrr_);
} else {
EXPECT_EQ(0, sent_rtcp_rrtr_);
EXPECT_EQ(0, sent_rtcp_dlrr_);

44
webrtc/video/video_send_stream_tests.cc
View File

@ -24,7 +24,6 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
#include "webrtc/system_wrappers/include/sleep.h"
@ -35,6 +34,7 @@
#include "webrtc/test/frame_utils.h"
#include "webrtc/test/gtest.h"
#include "webrtc/test/null_transport.h"
#include "webrtc/test/rtcp_packet_parser.h"
#include "webrtc/test/testsupport/perf_test.h"
#include "webrtc/video/send_statistics_proxy.h"
@ -91,17 +91,13 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
if (parser.sdes()->num_packets() > 0) {
EXPECT_EQ(1u, parser.sdes()->chunks().size());
EXPECT_EQ(kCName, parser.sdes()->chunks()[0].cname);
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
EXPECT_EQ(parser.Packet().CName.CName, kCName);
observation_complete_.Set();
}
packet_type = parser.Iterate();
observation_complete_.Set();
}
return SEND_PACKET;
@ -2125,22 +2121,20 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
rtc::CritScope lock(&crit_);
RTCPUtility::RTCPParserV2 parser(packet, length, true);
EXPECT_TRUE(parser.IsValid());
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
// Only compare sent media bytes if SenderPacketCount matches the
// number of sent rtp packets (a new rtp packet could be sent before
// the rtcp packet).
if (parser.Packet().SR.SenderOctetCount > 0 &&
parser.Packet().SR.SenderPacketCount == rtp_packets_sent_) {
EXPECT_EQ(media_bytes_sent_, parser.Packet().SR.SenderOctetCount);
observation_complete_.Set();
}
if (parser.sender_report()->num_packets() > 0) {
// Only compare sent media bytes if SenderPacketCount matches the
// number of sent rtp packets (a new rtp packet could be sent before
// the rtcp packet).
if (parser.sender_report()->sender_octet_count() > 0 &&
parser.sender_report()->sender_packet_count() ==
rtp_packets_sent_) {
EXPECT_EQ(media_bytes_sent_,
parser.sender_report()->sender_octet_count());
observation_complete_.Set();
}
packet_type = parser.Iterate();
}
return SEND_PACKET;