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

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

Browse Source 
BUG=webrtc:5260
R=åsapersson

Review URL: https://codereview.webrtc.org/1846433003

Cr-Commit-Position: refs/heads/master@{#12169}
This commit is contained in:
danilchap 2016-03-30 13:34:31 -07:00 committed by Commit bot
parent 82f132c90a
commit 4b9cad86ce
3 changed files with 30 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
View File

@ -13,8 +13,7 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
using webrtc::RTCPUtility::RtcpCommonHeader;
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
namespace webrtc {
namespace rtcp {
@ -60,22 +59,23 @@ Sdes::Sdes() : block_length_(RtcpPacket::kHeaderLength) {}
Sdes::~Sdes() {}
bool Sdes::Parse(const RtcpCommonHeader& header, const uint8_t* payload) {
RTC_CHECK(header.packet_type == kPacketType);
bool Sdes::Parse(const CommonHeader& packet) {
RTC_DCHECK(packet.type() == kPacketType);
uint8_t number_of_chunks = header.count_or_format;
uint8_t number_of_chunks = packet.count();
std::vector<Chunk> chunks; // Read chunk into temporary array, so that in
// case of an error original array would stay
// unchanged.
size_t block_length = kHeaderLength;
if (header.payload_size_bytes % 4 != 0) {
LOG(LS_WARNING) << "Invalid payload size " << header.payload_size_bytes
if (packet.payload_size_bytes() % 4 != 0) {
LOG(LS_WARNING) << "Invalid payload size " << packet.payload_size_bytes()
<< " bytes for a valid Sdes packet. Size should be"
" multiple of 4 bytes";
}
const uint8_t* const payload_end = payload + header.payload_size_bytes;
const uint8_t* looking_at = payload;
const uint8_t* const payload_end =
packet.payload() + packet.payload_size_bytes();
const uint8_t* looking_at = packet.payload();
chunks.resize(number_of_chunks);
for (size_t i = 0; i < number_of_chunks;) {
// Each chunk consumes at least 8 bytes.

5
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h
View File

@ -16,10 +16,10 @@
#include "webrtc/base/basictypes.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;
// Source Description (SDES) (RFC 3550).
class Sdes : public RtcpPacket {
public:
@ -33,8 +33,7 @@ class Sdes : public RtcpPacket {
~Sdes() 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 WithCName(uint32_t ssrc, const std::string& cname);

47
webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc
View File

@ -11,10 +11,9 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/test/rtcp_packet_parser.h"
using webrtc::rtcp::Sdes;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
namespace webrtc {
namespace {
@ -24,27 +23,19 @@ const uint8_t kTerminatorTag = 0;
const uint8_t kCnameTag = 1;
const uint8_t kNameTag = 2;
const uint8_t kEmailTag = 3;
bool Parse(const uint8_t* buffer, size_t length, Sdes* sdes) {
RtcpCommonHeader header;
EXPECT_TRUE(RtcpParseCommonHeader(buffer, length, &header));
// Check that there is exactly one RTCP packet in the buffer.
EXPECT_EQ(length, header.BlockSize());
return sdes->Parse(header, buffer + RtcpCommonHeader::kHeaderSizeBytes);
}
} // namespace
TEST(RtcpPacketSdesTest, WithoutChunks) {
TEST(RtcpPacketSdesTest, CreateAndParseWithoutChunks) {
Sdes sdes;
rtc::Buffer packet = sdes.Build();
Sdes parsed;
EXPECT_TRUE(Parse(packet.data(), packet.size(), &parsed));
EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed));
EXPECT_EQ(0u, parsed.chunks().size());
}
TEST(RtcpPacketSdesTest, WithOneChunk) {
TEST(RtcpPacketSdesTest, CreateAndParseWithOneChunk) {
const std::string kCname = "alice@host";
Sdes sdes;
@ -52,7 +43,7 @@ TEST(RtcpPacketSdesTest, WithOneChunk) {
rtc::Buffer packet = sdes.Build();
Sdes sdes_parsed;
Parse(packet.data(), packet.size(), &sdes_parsed);
EXPECT_TRUE(test::ParseSinglePacket(packet, &sdes_parsed));
const Sdes& parsed = sdes_parsed; // Ensure accessors are const.
EXPECT_EQ(1u, parsed.chunks().size());
@ -60,7 +51,7 @@ TEST(RtcpPacketSdesTest, WithOneChunk) {
EXPECT_EQ(kCname, parsed.chunks()[0].cname);
}
TEST(RtcpPacketSdesTest, WithMultipleChunks) {
TEST(RtcpPacketSdesTest, CreateAndParseWithMultipleChunks) {
Sdes sdes;
EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 0, "a"));
EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 1, "ab"));
@ -71,14 +62,14 @@ TEST(RtcpPacketSdesTest, WithMultipleChunks) {
rtc::Buffer packet = sdes.Build();
Sdes parsed;
Parse(packet.data(), packet.size(), &parsed);
EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed));
EXPECT_EQ(6u, parsed.chunks().size());
EXPECT_EQ(kSenderSsrc + 5, parsed.chunks()[5].ssrc);
EXPECT_EQ("abcdef", parsed.chunks()[5].cname);
}
TEST(RtcpPacketSdesTest, WithTooManyChunks) {
TEST(RtcpPacketSdesTest, CreateWithTooManyChunks) {
const size_t kMaxChunks = (1 << 5) - 1;
Sdes sdes;
for (size_t i = 0; i < kMaxChunks; ++i) {
@ -90,13 +81,13 @@ TEST(RtcpPacketSdesTest, WithTooManyChunks) {
EXPECT_FALSE(sdes.WithCName(kSenderSsrc + kMaxChunks, "foo"));
}
TEST(RtcpPacketSdesTest, CnameItemWithEmptyString) {
TEST(RtcpPacketSdesTest, CreateAndParseCnameItemWithEmptyString) {
Sdes sdes;
EXPECT_TRUE(sdes.WithCName(kSenderSsrc, ""));
rtc::Buffer packet = sdes.Build();
Sdes parsed;
Parse(packet.data(), packet.size(), &parsed);
EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed));
EXPECT_EQ(1u, parsed.chunks().size());
EXPECT_EQ(kSenderSsrc, parsed.chunks()[0].ssrc);
@ -116,7 +107,7 @@ TEST(RtcpPacketSdesTest, ParseSkipsNonCNameField) {
ASSERT_EQ(kValidPacket[3] + 1u, sizeof(kValidPacket) / 4);
Sdes parsed;
EXPECT_TRUE(Parse(kValidPacket, sizeof(kValidPacket), &parsed));
EXPECT_TRUE(test::ParseSinglePacket(kValidPacket, &parsed));
EXPECT_EQ(1u, parsed.chunks().size());
EXPECT_EQ(kSenderSsrc, parsed.chunks()[0].ssrc);
@ -140,7 +131,7 @@ TEST(RtcpPacketSdesTest, ParseSkipsChunksWithoutCName) {
ASSERT_EQ(kPacket[3] + 1u, sizeof(kPacket) / 4);
Sdes parsed;
EXPECT_TRUE(Parse(kPacket, sizeof(kPacket), &parsed));
EXPECT_TRUE(test::ParseSinglePacket(kPacket, &parsed));
ASSERT_EQ(1u, parsed.chunks().size());
EXPECT_EQ(0x23456789u, parsed.chunks()[0].ssrc);
EXPECT_EQ(kCname, parsed.chunks()[0].cname);
@ -159,7 +150,7 @@ TEST(RtcpPacketSdesTest, ParseFailsWithoutChunkItemTerminator) {
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
Sdes parsed;
EXPECT_FALSE(Parse(kInvalidPacket, sizeof(kInvalidPacket), &parsed));
EXPECT_FALSE(test::ParseSinglePacket(kInvalidPacket, &parsed));
}
TEST(RtcpPacketSdesTest, ParseFailsWithDamagedChunkItem) {
@ -176,7 +167,7 @@ TEST(RtcpPacketSdesTest, ParseFailsWithDamagedChunkItem) {
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
Sdes parsed;
EXPECT_FALSE(Parse(kInvalidPacket, sizeof(kInvalidPacket), &parsed));
EXPECT_FALSE(test::ParseSinglePacket(kInvalidPacket, &parsed));
}
TEST(RtcpPacketSdesTest, ParseFailsWithTooLongChunkItem) {
@ -192,7 +183,7 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTooLongChunkItem) {
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
Sdes parsed;
EXPECT_FALSE(Parse(kInvalidPacket, sizeof(kInvalidPacket), &parsed));
EXPECT_FALSE(test::ParseSinglePacket(kInvalidPacket, &parsed));
}
TEST(RtcpPacketSdesTest, ParseFailsWithTwoCNames) {
@ -208,7 +199,7 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTwoCNames) {
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
Sdes parsed;
EXPECT_FALSE(Parse(kInvalidPacket, sizeof(kInvalidPacket), &parsed));
EXPECT_FALSE(test::ParseSinglePacket(kInvalidPacket, &parsed));
}
TEST(RtcpPacketSdesTest, ParseFailsWithTooLittleSpaceForNextChunk) {
@ -226,7 +217,7 @@ TEST(RtcpPacketSdesTest, ParseFailsWithTooLittleSpaceForNextChunk) {
ASSERT_EQ(kInvalidPacket[3] + 1u, sizeof(kInvalidPacket) / 4);
Sdes parsed;
EXPECT_FALSE(Parse(kInvalidPacket, sizeof(kInvalidPacket), &parsed));
EXPECT_FALSE(test::ParseSinglePacket(kInvalidPacket, &parsed));
}
TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
@ -237,7 +228,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
rtc::Buffer packet1 = source.Build();
Sdes middle;
Parse(packet1.data(), packet1.size(), &middle);
test::ParseSinglePacket(packet1, &middle);
EXPECT_EQ(source.BlockLength(), middle.BlockLength());
@ -245,7 +236,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
rtc::Buffer packet2 = middle.Build();
Sdes destination;
Parse(packet2.data(), packet2.size(), &destination);
test::ParseSinglePacket(packet2, &destination);
EXPECT_EQ(middle.BlockLength(), destination.BlockLength());