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

rtcp::Nack packet moved into own file and got Parse function

Browse Source 
Review URL: https://codereview.webrtc.org/1461623003

Cr-Commit-Position: refs/heads/master@{#11111}
This commit is contained in:
danilchap
2015-12-22 03:43:04 -08:00
committed by Commit bot
parent 53c317c4b9
commit a8890a57a5
13 changed files with 520 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/modules.gyp
View File

@ -308,6 +308,7 @@
'rtp_rtcp/source/rtcp_packet/bye_unittest.cc',
'rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc',
'rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc',
'rtp_rtcp/source/rtcp_packet/nack_unittest.cc',
'rtp_rtcp/source/rtcp_packet/pli_unittest.cc',
'rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc',
'rtp_rtcp/source/rtcp_packet/report_block_unittest.cc',

4
webrtc/modules/rtp_rtcp/BUILD.gn
View File

@ -54,6 +54,8 @@ source_set("rtp_rtcp") {
"source/rtcp_packet/dlrr.h",
"source/rtcp_packet/extended_jitter_report.cc",
"source/rtcp_packet/extended_jitter_report.h",
"source/rtcp_packet/nack.cc",
"source/rtcp_packet/nack.h",
"source/rtcp_packet/pli.cc",
"source/rtcp_packet/pli.h",
"source/rtcp_packet/psfb.cc",
@ -64,6 +66,8 @@ source_set("rtp_rtcp") {
"source/rtcp_packet/report_block.h",
"source/rtcp_packet/rrtr.cc",
"source/rtcp_packet/rrtr.h",
"source/rtcp_packet/rtpfb.cc",
"source/rtcp_packet/rtpfb.h",
"source/rtcp_packet/transport_feedback.cc",
"source/rtcp_packet/transport_feedback.h",
"source/rtcp_packet/voip_metric.cc",

4
webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
View File

@ -49,6 +49,8 @@
'source/rtcp_packet/dlrr.h',
'source/rtcp_packet/extended_jitter_report.cc',
'source/rtcp_packet/extended_jitter_report.h',
'source/rtcp_packet/nack.cc',
'source/rtcp_packet/nack.h',
'source/rtcp_packet/pli.cc',
'source/rtcp_packet/pli.h',
'source/rtcp_packet/psfb.cc',
@ -59,6 +61,8 @@
'source/rtcp_packet/report_block.h',
'source/rtcp_packet/rrtr.cc',
'source/rtcp_packet/rrtr.h',
'source/rtcp_packet/rtpfb.cc',
'source/rtcp_packet/rtpfb.h',
'source/rtcp_packet/transport_feedback.cc',
'source/rtcp_packet/transport_feedback.h',
'source/rtcp_packet/voip_metric.cc',

84
webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
View File

@ -209,31 +209,6 @@ void CreateSli(const RTCPPacketPSFBSLI& sli,
AssignUWord8(buffer, pos, (sli_item.NumberOfMB << 6) + sli_item.PictureId);
}
// Generic NACK (RFC 4585).
//
// FCI:
//
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | PID | BLP |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
void CreateNack(const RTCPPacketRTPFBNACK& nack,
const std::vector<RTCPPacketRTPFBNACKItem>& nack_fields,
size_t start_index,
size_t end_index,
uint8_t* buffer,
size_t* pos) {
AssignUWord32(buffer, pos, nack.SenderSSRC);
AssignUWord32(buffer, pos, nack.MediaSSRC);
for (size_t i = start_index; i < end_index; ++i) {
const RTCPPacketRTPFBNACKItem& nack_item = nack_fields[i];
AssignUWord16(buffer, pos, nack_item.PacketID);
AssignUWord16(buffer, pos, nack_item.BitMask);
}
}
// Reference picture selection indication (RPSI) (RFC 4585).
//
// FCI:
@ -597,65 +572,6 @@ bool Sli::Create(uint8_t* packet,
return true;
}
bool Nack::Create(uint8_t* packet,
size_t* index,
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const {
assert(!nack_fields_.empty());
// If nack list can't fit in packet, try to fragment.
size_t nack_index = 0;
do {
size_t bytes_left_in_buffer = max_length - *index;
if (bytes_left_in_buffer < kCommonFbFmtLength + 4) {
if (!OnBufferFull(packet, index, callback))
return false;
continue;
}
int64_t num_nack_fields =
std::min((bytes_left_in_buffer - kCommonFbFmtLength) / 4,
nack_fields_.size() - nack_index);
const uint8_t kFmt = 1;
size_t size_bytes = (num_nack_fields * 4) + kCommonFbFmtLength;
size_t header_length = ((size_bytes + 3) / 4) - 1; // As 32bit words - 1
CreateHeader(kFmt, PT_RTPFB, header_length, packet, index);
CreateNack(nack_, nack_fields_, nack_index, nack_index + num_nack_fields,
packet, index);
nack_index += num_nack_fields;
} while (nack_index < nack_fields_.size());
return true;
}
size_t Nack::BlockLength() const {
return (nack_fields_.size() * 4) + kCommonFbFmtLength;
}
void Nack::WithList(const uint16_t* nack_list, int length) {
assert(nack_list);
assert(nack_fields_.empty());
int i = 0;
while (i < length) {
uint16_t pid = nack_list[i++];
// Bitmask specifies losses in any of the 16 packets following the pid.
uint16_t bitmask = 0;
while (i < length) {
int shift = static_cast<uint16_t>(nack_list[i] - pid) - 1;
if (shift >= 0 && shift <= 15) {
bitmask |= (1 << shift);
++i;
} else {
break;
}
}
RTCPUtility::RTCPPacketRTPFBNACKItem item;
item.PacketID = pid;
item.BitMask = bitmask;
nack_fields_.push_back(item);
}
}
bool Rpsi::Create(uint8_t* packet,
size_t* index,
size_t max_length,

40
webrtc/modules/rtp_rtcp/source/rtcp_packet.h
View File

@ -327,46 +327,6 @@ class Sli : public RtcpPacket {
RTC_DISALLOW_COPY_AND_ASSIGN(Sli);
};
// Generic NACK (RFC 4585).
//
// FCI:
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | PID | BLP |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
class Nack : public RtcpPacket {
public:
Nack() : RtcpPacket() {
memset(&nack_, 0, sizeof(nack_));
}
virtual ~Nack() {}
void From(uint32_t ssrc) {
nack_.SenderSSRC = ssrc;
}
void To(uint32_t ssrc) {
nack_.MediaSSRC = ssrc;
}
void WithList(const uint16_t* nack_list, int length);
protected:
bool Create(uint8_t* packet,
size_t* index,
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
size_t BlockLength() const override;
private:
RTCPUtility::RTCPPacketRTPFBNACK nack_;
std::vector<RTCPUtility::RTCPPacketRTPFBNACKItem> nack_fields_;
RTC_DISALLOW_COPY_AND_ASSIGN(Nack);
};
// Reference picture selection indication (RPSI) (RFC 4585).
//
// FCI:

163
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc Normal file
View File

@ -0,0 +1,163 @@
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include <algorithm>
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
using webrtc::RTCPUtility::RtcpCommonHeader;
namespace webrtc {
namespace rtcp {
// RFC 4585: Feedback format.
//
// Common packet format:
//
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |V=2|P| FMT | PT | length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 0 | SSRC of packet sender |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 4 | SSRC of media source |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// : Feedback Control Information (FCI) :
// : :
//
// Generic NACK (RFC 4585).
//
// FCI:
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | PID | BLP |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
bool Nack::Parse(const RtcpCommonHeader& header, const uint8_t* payload) {
RTC_DCHECK(header.packet_type == kPacketType);
RTC_DCHECK(header.count_or_format == kFeedbackMessageType);
if (header.payload_size_bytes < kCommonFeedbackLength + kNackItemLength) {
LOG(LS_WARNING) << "Payload length " << header.payload_size_bytes
<< " is too small for a Nack.";
return false;
}
size_t nack_items =
(header.payload_size_bytes - kCommonFeedbackLength) / kNackItemLength;
ParseCommonFeedback(payload);
const uint8_t* next_nack = payload + kCommonFeedbackLength;
packet_ids_.clear();
packed_.resize(nack_items);
for (size_t index = 0; index < nack_items; ++index) {
packed_[index].first_pid = ByteReader<uint16_t>::ReadBigEndian(next_nack);
packed_[index].bitmask = ByteReader<uint16_t>::ReadBigEndian(next_nack + 2);
next_nack += kNackItemLength;
}
Unpack();
return true;
}
bool Nack::Create(uint8_t* packet,
size_t* index,
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const {
RTC_DCHECK(!packed_.empty());
// If nack list can't fit in packet, try to fragment.
size_t nack_index = 0;
const size_t kCommonFbFmtLength = kHeaderLength + kCommonFeedbackLength;
do {
size_t bytes_left_in_buffer = max_length - *index;
if (bytes_left_in_buffer < kCommonFbFmtLength + kNackItemLength) {
if (!OnBufferFull(packet, index, callback))
return false;
continue;
}
size_t num_nack_fields =
std::min((bytes_left_in_buffer - kCommonFbFmtLength) / kNackItemLength,
packed_.size() - nack_index);
size_t size_bytes =
(num_nack_fields * kNackItemLength) + kCommonFbFmtLength;
size_t header_length = ((size_bytes + 3) / 4) - 1; // As 32bit words - 1
CreateHeader(kFeedbackMessageType, kPacketType, header_length, packet,
index);
CreateCommonFeedback(packet + *index);
*index += kCommonFeedbackLength;
size_t end_index = nack_index + num_nack_fields;
for (; nack_index < end_index; ++nack_index) {
const auto& item = packed_[nack_index];
ByteWriter<uint16_t>::WriteBigEndian(packet + *index + 0, item.first_pid);
ByteWriter<uint16_t>::WriteBigEndian(packet + *index + 2, item.bitmask);
*index += kNackItemLength;
}
RTC_DCHECK_LE(*index, max_length);
} while (nack_index < packed_.size());
return true;
}
size_t Nack::BlockLength() const {
return (packed_.size() * kNackItemLength) + kCommonFeedbackLength +
kHeaderLength;
}
void Nack::WithList(const uint16_t* nack_list, size_t length) {
RTC_DCHECK(nack_list);
RTC_DCHECK(packet_ids_.empty());
RTC_DCHECK(packed_.empty());
packet_ids_.assign(nack_list, nack_list + length);
Pack();
}
void Nack::Pack() {
RTC_DCHECK(!packet_ids_.empty());
RTC_DCHECK(packed_.empty());
auto it = packet_ids_.begin();
const auto end = packet_ids_.end();
while (it != end) {
PackedNack item;
item.first_pid = *it++;
// Bitmask specifies losses in any of the 16 packets following the pid.
item.bitmask = 0;
while (it != end) {
uint16_t shift = static_cast<uint16_t>(*it - item.first_pid - 1);
if (shift <= 15) {
item.bitmask |= (1 << shift);
++it;
} else {
break;
}
}
packed_.push_back(item);
}
}
void Nack::Unpack() {
RTC_DCHECK(packet_ids_.empty());
RTC_DCHECK(!packed_.empty());
for (const PackedNack& item : packed_) {
packet_ids_.push_back(item.first_pid);
uint16_t pid = item.first_pid + 1;
for (uint16_t bitmask = item.bitmask; bitmask != 0; bitmask >>= 1, ++pid)
if (bitmask & 1)
packet_ids_.push_back(pid);
}
}
} // namespace rtcp
} // namespace webrtc

63
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_
#include <vector>
#include "webrtc/base/basictypes.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
namespace webrtc {
namespace rtcp {
class Nack : public Rtpfb {
public:
const uint8_t kFeedbackMessageType = 1;
Nack() {}
virtual ~Nack() {}
// 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.
void WithList(const uint16_t* nack_list, size_t length);
const std::vector<uint16_t>& packet_ids() const { return packet_ids_; }
protected:
bool Create(uint8_t* packet,
size_t* index,
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
size_t BlockLength() const override;
private:
const size_t kNackItemLength = 4;
struct PackedNack {
uint16_t first_pid;
uint16_t bitmask;
};
void Pack(); // Fills packed_ using packed_ids_. (used in WithList).
void Unpack(); // Fills packet_ids_ using packed_. (used in Parse).
std::vector<PackedNack> packed_;
std::vector<uint16_t> packet_ids_;
RTC_DISALLOW_COPY_AND_ASSIGN(Nack);
};
} // namespace rtcp
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_

190
webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc Normal file
View File

@ -0,0 +1,190 @@
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::_;
using ::testing::ElementsAreArray;
using ::testing::Invoke;
using ::testing::UnorderedElementsAreArray;
using webrtc::rtcp::Nack;
using webrtc::rtcp::RawPacket;
using webrtc::RTCPUtility::RtcpCommonHeader;
using webrtc::RTCPUtility::RtcpParseCommonHeader;
namespace webrtc {
namespace {
const uint32_t kSenderSsrc = 0x12345678;
const uint32_t kRemoteSsrc = 0x23456789;
const uint16_t kList[] = {0, 1, 3, 8, 16};
const size_t kListLength = sizeof(kList) / sizeof(kList[0]);
const uint8_t kPacket[] = {0x81, 205, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78,
0x23, 0x45, 0x67, 0x89, 0x00, 0x00, 0x80, 0x85};
const size_t kPacketLength = sizeof(kPacket);
const uint16_t kWrapList[] = {0xffdc, 0xffec, 0xfffe, 0xffff, 0x0000,
0x0001, 0x0003, 0x0014, 0x0064};
const size_t kWrapListLength = sizeof(kWrapList) / sizeof(kWrapList[0]);
const uint8_t kWrapPacket[] = {0x81, 205, 0x00, 0x06, 0x12, 0x34, 0x56, 0x78,
0x23, 0x45, 0x67, 0x89, 0xff, 0xdc, 0x80, 0x00,
0xff, 0xfe, 0x00, 0x17, 0x00, 0x14, 0x00, 0x00,
0x00, 0x64, 0x00, 0x00};
const size_t kWrapPacketLength = sizeof(kWrapPacket);
TEST(RtcpPacketNackTest, Create) {
Nack nack;
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
EXPECT_EQ(kPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength));
}
TEST(RtcpPacketNackTest, Parse) {
RtcpCommonHeader header;
EXPECT_TRUE(RtcpParseCommonHeader(kPacket, kPacketLength, &header));
EXPECT_EQ(kPacketLength, header.BlockSize());
Nack parsed;
EXPECT_TRUE(
parsed.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes));
const Nack& const_parsed = parsed;
EXPECT_EQ(kSenderSsrc, const_parsed.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, const_parsed.media_ssrc());
EXPECT_THAT(const_parsed.packet_ids(), ElementsAreArray(kList));
}
TEST(RtcpPacketNackTest, CreateWrap) {
Nack nack;
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kWrapList, kWrapListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
EXPECT_EQ(kWrapPacketLength, packet->Length());
EXPECT_EQ(0, memcmp(kWrapPacket, packet->Buffer(), kWrapPacketLength));
}
TEST(RtcpPacketNackTest, ParseWrap) {
RtcpCommonHeader header;
EXPECT_TRUE(RtcpParseCommonHeader(kWrapPacket, kWrapPacketLength, &header));
EXPECT_EQ(kWrapPacketLength, header.BlockSize());
Nack parsed;
EXPECT_TRUE(
parsed.Parse(header, kWrapPacket + RtcpCommonHeader::kHeaderSizeBytes));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc());
EXPECT_THAT(parsed.packet_ids(), ElementsAreArray(kWrapList));
}
TEST(RtcpPacketNackTest, BadOrder) {
// Does not guarantee optimal packing, but should guarantee correctness.
const uint16_t kUnorderedList[] = {1, 25, 13, 12, 9, 27, 29};
const size_t kUnorderedListLength =
sizeof(kUnorderedList) / sizeof(kUnorderedList[0]);
Nack nack;
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kUnorderedList, kUnorderedListLength);
rtc::scoped_ptr<RawPacket> packet = nack.Build();
Nack parsed;
RtcpCommonHeader header;
EXPECT_TRUE(
RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
EXPECT_TRUE(parsed.Parse(
header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc());
EXPECT_THAT(parsed.packet_ids(), UnorderedElementsAreArray(kUnorderedList));
}
TEST(RtcpPacketNackTest, CreateFragmented) {
Nack nack;
const uint16_t kList[] = {1, 100, 200, 300, 400};
const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback {
public:
MOCK_METHOD2(OnPacketReady, void(uint8_t*, size_t));
} verifier;
class NackVerifier {
public:
explicit NackVerifier(std::vector<uint16_t> ids) : ids_(ids) {}
void operator()(uint8_t* data, size_t length) {
RtcpCommonHeader header;
EXPECT_TRUE(RtcpParseCommonHeader(data, length, &header));
EXPECT_EQ(length, header.BlockSize());
Nack nack;
EXPECT_TRUE(
nack.Parse(header, data + RtcpCommonHeader::kHeaderSizeBytes));
EXPECT_EQ(kSenderSsrc, nack.sender_ssrc());
EXPECT_EQ(kRemoteSsrc, nack.media_ssrc());
EXPECT_THAT(nack.packet_ids(), ElementsAreArray(ids_));
}
std::vector<uint16_t> ids_;
} packet1({1, 100, 200}), packet2({300, 400});
EXPECT_CALL(verifier, OnPacketReady(_, _))
.WillOnce(Invoke(packet1))
.WillOnce(Invoke(packet2));
const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items
uint8_t buffer[kBufferSize];
EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier));
}
TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) {
const uint16_t kList[] = {1};
const size_t kMinNackBlockSize = 16;
Nack nack;
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, 1);
class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
public:
void OnPacketReady(uint8_t* data, size_t length) override {
ADD_FAILURE() << "Buffer should be too small.";
}
} verifier;
uint8_t buffer[kMinNackBlockSize - 1];
EXPECT_FALSE(
nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier));
}
TEST(RtcpPacketNackTest, ParseFailsWithTooSmallBuffer) {
RtcpCommonHeader header;
EXPECT_TRUE(RtcpParseCommonHeader(kPacket, kPacketLength, &header));
header.payload_size_bytes--; // Damage the packet
Nack parsed;
EXPECT_FALSE(
parsed.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes));
}
} // namespace
} // namespace webrtc

45
webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
namespace webrtc {
namespace rtcp {
// RFC 4585, Section 6.1: Feedback format.
//
// Common packet format:
//
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |V=2|P| FMT | PT | length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 0 | SSRC of packet sender |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 4 | SSRC of media source |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// : Feedback Control Information (FCI) :
// : :
void Rtpfb::ParseCommonFeedback(const uint8_t* payload) {
sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[0]);
media_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[4]);
}
void Rtpfb::CreateCommonFeedback(uint8_t* payload) const {
ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc_);
ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc_);
}
} // namespace rtcp
} // namespace webrtc

48
webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_
#include "webrtc/base/basictypes.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
namespace webrtc {
namespace rtcp {
// RTPFB: Transport layer feedback message.
// RFC4585, Section 6.2
class Rtpfb : public RtcpPacket {
public:
static const uint8_t kPacketType = 205;
Rtpfb() : sender_ssrc_(0), media_ssrc_(0) {}
virtual ~Rtpfb() {}
void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
void To(uint32_t ssrc) { media_ssrc_ = ssrc; }
uint32_t sender_ssrc() const { return sender_ssrc_; }
uint32_t media_ssrc() const { return media_ssrc_; }
protected:
static const size_t kCommonFeedbackLength = 8;
void ParseCommonFeedback(const uint8_t* payload);
void CreateCommonFeedback(uint8_t* payload) const;
private:
uint32_t sender_ssrc_;
uint32_t media_ssrc_;
};
} // namespace rtcp
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_

99
webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
View File

@ -26,7 +26,6 @@ using webrtc::rtcp::Bye;
using webrtc::rtcp::Dlrr;
using webrtc::rtcp::Empty;
using webrtc::rtcp::Fir;
using webrtc::rtcp::Nack;
using webrtc::rtcp::RawPacket;
using webrtc::rtcp::ReceiverReport;
using webrtc::rtcp::Remb;
@ -243,104 +242,6 @@ TEST(RtcpPacketTest, Sli) {
EXPECT_EQ(kPictureId, parser.sli_item()->PictureId());
}
TEST(RtcpPacketTest, Nack) {
Nack nack;
const uint16_t kList[] = {0, 1, 3, 8, 16};
const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
rtc::scoped_ptr<RawPacket> packet(nack.Build());
RtcpPacketParser parser;
parser.Parse(packet->Buffer(), packet->Length());
EXPECT_EQ(1, parser.nack()->num_packets());
EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
EXPECT_EQ(1, parser.nack_item()->num_packets());
std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
EXPECT_EQ(kListLength, seqs.size());
for (size_t i = 0; i < kListLength; ++i) {
EXPECT_EQ(kList[i], seqs[i]);
}
}
TEST(RtcpPacketTest, NackWithWrap) {
Nack nack;
const uint16_t kList[] = {65500, 65516, 65534, 65535, 0, 1, 3, 20, 100};
const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
rtc::scoped_ptr<RawPacket> packet(nack.Build());
RtcpPacketParser parser;
parser.Parse(packet->Buffer(), packet->Length());
EXPECT_EQ(1, parser.nack()->num_packets());
EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
EXPECT_EQ(4, parser.nack_item()->num_packets());
std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
EXPECT_EQ(kListLength, seqs.size());
for (size_t i = 0; i < kListLength; ++i) {
EXPECT_EQ(kList[i], seqs[i]);
}
}
TEST(RtcpPacketTest, NackFragmented) {
Nack nack;
const uint16_t kList[] = {1, 100, 200, 300, 400};
const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, kListLength);
class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
public:
void OnPacketReady(uint8_t* data, size_t length) override {
++packets_created_;
RtcpPacketParser parser;
parser.Parse(data, length);
EXPECT_EQ(1, parser.nack()->num_packets());
EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
switch (packets_created_) {
case 1:
EXPECT_THAT(parser.nack_item()->last_nack_list(),
ElementsAre(1, 100, 200));
break;
case 2:
EXPECT_THAT(parser.nack_item()->last_nack_list(),
ElementsAre(300, 400));
break;
default:
ADD_FAILURE() << "Unexpected packet count: " << packets_created_;
}
}
int packets_created_ = 0;
} verifier;
const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items
uint8_t buffer[kBufferSize];
EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier));
EXPECT_EQ(2, verifier.packets_created_);
}
TEST(RtcpPacketTest, NackWithTooSmallBuffer) {
const uint16_t kList[] = {1};
const size_t kMinNackBlockSize = 16;
Nack nack;
nack.From(kSenderSsrc);
nack.To(kRemoteSsrc);
nack.WithList(kList, 1);
class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
public:
void OnPacketReady(uint8_t* data, size_t length) override {
ADD_FAILURE() << "Buffer should be too small.";
}
} verifier;
uint8_t buffer[kMinNackBlockSize - 1];
EXPECT_FALSE(
nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier));
}
TEST(RtcpPacketTest, Rpsi) {
Rpsi rpsi;
// 1000001 (7 bits = 1 byte in native string).

1
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -24,6 +24,7 @@
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"

1
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -18,6 +18,7 @@
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
#include "webrtc/system_wrappers/include/scoped_vector.h"
#include "webrtc/test/rtcp_packet_parser.h"