diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc index 030f9f81fa..fc3a810aac 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc @@ -13,13 +13,11 @@ #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/modules/rtp_rtcp/source/byte_io.h" -#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" - -using webrtc::RTCPUtility::RtcpCommonHeader; +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h" namespace webrtc { namespace rtcp { - +constexpr uint8_t ExtendedJitterReport::kPacketType; // Transmission Time Offsets in RTP Streams (RFC 5450). // // 0 1 2 3 @@ -39,22 +37,20 @@ namespace rtcp { // (inside a compound RTCP packet), and MUST have the same value for RC // (reception report count) as the receiver report. -bool ExtendedJitterReport::Parse(const RtcpCommonHeader& header, - const uint8_t* payload) { - RTC_DCHECK(header.packet_type == kPacketType); +bool ExtendedJitterReport::Parse(const CommonHeader& packet) { + RTC_DCHECK_EQ(packet.type(), kPacketType); - const uint8_t jitters_count = header.count_or_format; - const size_t kJitterSizeBytes = 4u; + const uint8_t number_of_jitters = packet.count(); - if (header.payload_size_bytes < jitters_count * kJitterSizeBytes) { + if (packet.payload_size_bytes() < number_of_jitters * kJitterSizeBytes) { LOG(LS_WARNING) << "Packet is too small to contain all the jitter."; return false; } - inter_arrival_jitters_.resize(jitters_count); - for (size_t index = 0; index < jitters_count; ++index) { - inter_arrival_jitters_[index] = - ByteReader::ReadBigEndian(&payload[index * kJitterSizeBytes]); + inter_arrival_jitters_.resize(number_of_jitters); + for (size_t index = 0; index < number_of_jitters; ++index) { + inter_arrival_jitters_[index] = ByteReader::ReadBigEndian( + &packet.payload()[index * kJitterSizeBytes]); } return true; @@ -84,7 +80,7 @@ bool ExtendedJitterReport::Create( for (uint32_t jitter : inter_arrival_jitters_) { ByteWriter::WriteBigEndian(packet + *index, jitter); - *index += sizeof(uint32_t); + *index += kJitterSizeBytes; } // Sanity check. RTC_DCHECK_EQ(index_end, *index); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h index 34eb57f348..7731988df4 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h @@ -13,33 +13,26 @@ #include -#include "webrtc/base/checks.h" #include "webrtc/base/constructormagic.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" -#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" namespace webrtc { namespace rtcp { +class CommonHeader; class ExtendedJitterReport : public RtcpPacket { public: - static const uint8_t kPacketType = 195; + static constexpr uint8_t kPacketType = 195; - ExtendedJitterReport() : RtcpPacket() {} - - virtual ~ExtendedJitterReport() {} + ExtendedJitterReport() {} + ~ExtendedJitterReport() override {} // Parse assumes header is already parsed and validated. - bool Parse(const RTCPUtility::RtcpCommonHeader& header, - const uint8_t* payload); // Size of the payload is in the header. + bool Parse(const CommonHeader& packet); bool WithJitter(uint32_t jitter); - size_t jitters_count() const { return inter_arrival_jitters_.size(); } - uint32_t jitter(size_t index) const { - RTC_DCHECK_LT(index, jitters_count()); - return inter_arrival_jitters_[index]; - } + const std::vector& jitters() { return inter_arrival_jitters_; } protected: bool Create(uint8_t* packet, @@ -48,10 +41,11 @@ class ExtendedJitterReport : public RtcpPacket { RtcpPacket::PacketReadyCallback* callback) const override; private: - static const int kMaxNumberOfJitters = 0x1f; + static constexpr size_t kMaxNumberOfJitters = 0x1f; + static constexpr size_t kJitterSizeBytes = 4; size_t BlockLength() const override { - return kHeaderLength + 4 * inter_arrival_jitters_.size(); + return kHeaderLength + kJitterSizeBytes * inter_arrival_jitters_.size(); } std::vector inter_arrival_jitters_; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc index 43a4fed0a4..c9e01aadd0 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc @@ -10,68 +10,55 @@ #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" -#include - +#include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" +#include "webrtc/test/rtcp_packet_parser.h" +using testing::ElementsAre; +using testing::IsEmpty; using webrtc::rtcp::ExtendedJitterReport; -using webrtc::RTCPUtility::RtcpCommonHeader; -using webrtc::RTCPUtility::RtcpParseCommonHeader; namespace webrtc { namespace { +constexpr uint32_t kJitter1 = 0x11121314; +constexpr uint32_t kJitter2 = 0x22242628; +} // namespace -class RtcpPacketExtendedJitterReportTest : public ::testing::Test { - protected: - void BuildPacket() { packet = ij.Build(); } - void ParsePacket() { - RtcpCommonHeader header; - EXPECT_TRUE(RtcpParseCommonHeader(packet.data(), packet.size(), &header)); - EXPECT_EQ(header.BlockSize(), packet.size()); - EXPECT_TRUE(parsed_.Parse( - header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes)); - } - +TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithoutItems) { ExtendedJitterReport ij; - rtc::Buffer packet; - const ExtendedJitterReport& parsed() { return parsed_; } + rtc::Buffer raw = ij.Build(); - private: - ExtendedJitterReport parsed_; -}; + ExtendedJitterReport parsed; + EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); -TEST_F(RtcpPacketExtendedJitterReportTest, NoItem) { - // No initialization because packet is empty. - BuildPacket(); - ParsePacket(); - - EXPECT_EQ(0u, parsed().jitters_count()); + EXPECT_THAT(parsed.jitters(), IsEmpty()); } -TEST_F(RtcpPacketExtendedJitterReportTest, OneItem) { - EXPECT_TRUE(ij.WithJitter(0x11121314)); +TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithOneItem) { + ExtendedJitterReport ij; + EXPECT_TRUE(ij.WithJitter(kJitter1)); + rtc::Buffer raw = ij.Build(); - BuildPacket(); - ParsePacket(); + ExtendedJitterReport parsed; + EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); - EXPECT_EQ(1u, parsed().jitters_count()); - EXPECT_EQ(0x11121314U, parsed().jitter(0)); + EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1)); } -TEST_F(RtcpPacketExtendedJitterReportTest, TwoItems) { - EXPECT_TRUE(ij.WithJitter(0x11121418)); - EXPECT_TRUE(ij.WithJitter(0x22242628)); +TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithTwoItems) { + ExtendedJitterReport ij; + EXPECT_TRUE(ij.WithJitter(kJitter1)); + EXPECT_TRUE(ij.WithJitter(kJitter2)); + rtc::Buffer raw = ij.Build(); - BuildPacket(); - ParsePacket(); + ExtendedJitterReport parsed; + EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed)); - EXPECT_EQ(2u, parsed().jitters_count()); - EXPECT_EQ(0x11121418U, parsed().jitter(0)); - EXPECT_EQ(0x22242628U, parsed().jitter(1)); + EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1, kJitter2)); } -TEST_F(RtcpPacketExtendedJitterReportTest, TooManyItems) { +TEST(RtcpPacketExtendedJitterReportTest, CreateWithTooManyItems) { + ExtendedJitterReport ij; const int kMaxIjItems = (1 << 5) - 1; for (int i = 0; i < kMaxIjItems; ++i) { EXPECT_TRUE(ij.WithJitter(i)); @@ -79,18 +66,13 @@ TEST_F(RtcpPacketExtendedJitterReportTest, TooManyItems) { EXPECT_FALSE(ij.WithJitter(kMaxIjItems)); } -TEST_F(RtcpPacketExtendedJitterReportTest, ParseFailWithTooManyItems) { - ij.WithJitter(0x11121418); - BuildPacket(); - RtcpCommonHeader header; - RtcpParseCommonHeader(packet.data(), packet.size(), &header); - header.count_or_format++; // Damage package. - +TEST(RtcpPacketExtendedJitterReportTest, ParseFailsWithTooManyItems) { + ExtendedJitterReport ij; + ij.WithJitter(kJitter1); + rtc::Buffer raw = ij.Build(); + raw[0]++; // Damage packet: increase jitter count by 1. ExtendedJitterReport parsed; - - EXPECT_FALSE(parsed.Parse( - header, packet.data() + RtcpCommonHeader::kHeaderSizeBytes)); + EXPECT_FALSE(test::ParseSinglePacket(raw, &parsed)); } -} // namespace } // namespace webrtc