diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc index 4a36775f58..340c580a05 100644 --- a/webrtc/call/call_perf_tests.cc +++ b/webrtc/call/call_perf_tests.cc @@ -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" diff --git a/webrtc/test/rtcp_packet_parser.cc b/webrtc/test/rtcp_packet_parser.cc index 2eb48c11a3..b9cf6db1a7 100644 --- a/webrtc/test/rtcp_packet_parser.cc +++ b/webrtc/test/rtcp_packet_parser.cc @@ -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(); diff --git a/webrtc/test/rtcp_packet_parser.h b/webrtc/test/rtcp_packet_parser.h index 4a8eca0d67..163ea41317 100644 --- a/webrtc/test/rtcp_packet_parser.h +++ b/webrtc/test/rtcp_packet_parser.h @@ -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* transport_feedback() { return &transport_feedback_; } + uint32_t sender_ssrc() const { return sender_ssrc_; } private: PacketCounter app_; @@ -111,6 +119,7 @@ class RtcpPacketParser { PacketCounter tmmbn_; PacketCounter tmmbr_; PacketCounter transport_feedback_; + uint32_t sender_ssrc_ = 0; }; } // namespace test diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index 7b796c00b4..2e61375c6e 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -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(packet[4]) << 24; - ssrc |= static_cast(packet[5]) << 16; - ssrc |= static_cast(packet[6]) << 8; - ssrc |= static_cast(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_); diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index 5c836e0f99..d703fc8c8d 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -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;