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

[rtcp] ExtendedJitterReports::Parse updated not to use RTCPUtility

Browse Source 
BUG=webrtc:5260
R=åsapersson

Review-Url: https://codereview.webrtc.org/2025843002
Cr-Commit-Position: refs/heads/master@{#13016}
This commit is contained in:
danilchap
2016-06-02 05:06:53 -07:00
committed by Commit bot
parent dc0dbad5e5
commit b684bd10be
3 changed files with 55 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
View File

@ -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<uint32_t>::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<uint32_t>::ReadBigEndian(
&packet.payload()[index * kJitterSizeBytes]);
}
return true;
@ -84,7 +80,7 @@ bool ExtendedJitterReport::Create(
for (uint32_t jitter : inter_arrival_jitters_) {
ByteWriter<uint32_t>::WriteBigEndian(packet + *index, jitter);
*index += sizeof(uint32_t);
*index += kJitterSizeBytes;
}
// Sanity check.
RTC_DCHECK_EQ(index_end, *index);

24
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
View File

@ -13,33 +13,26 @@
#include <vector>
#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<uint32_t>& 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<uint32_t> inter_arrival_jitters_;

88
webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc
View File

@ -10,68 +10,55 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
#include <limits>
#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