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

Add packetization and coding/decoding of feedback message format.

Browse Source 
BUG=webrtc:4312
R=stefan@webrtc.org

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

Cr-Commit-Position: refs/heads/master@{#9651}
This commit is contained in:
Erik Språng 2015-07-29 10:46:54 +02:00
parent f1828e8ed9
commit a3b8769860
9 changed files with 1442 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/modules.gyp
View File

@ -238,6 +238,7 @@
'rtp_rtcp/source/remote_ntp_time_estimator_unittest.cc',
'rtp_rtcp/source/rtcp_format_remb_unittest.cc',
'rtp_rtcp/source/rtcp_packet_unittest.cc',
'rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc',
'rtp_rtcp/source/rtcp_receiver_unittest.cc',
'rtp_rtcp/source/rtcp_sender_unittest.cc',
'rtp_rtcp/source/rtcp_utility_unittest.cc',

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

@ -44,6 +44,8 @@ source_set("rtp_rtcp") {
"source/remote_ntp_time_estimator.cc",
"source/rtcp_packet.cc",
"source/rtcp_packet.h",
"source/rtcp_packet/transport_feedback.cc",
"source/rtcp_packet/transport_feedback.h",
"source/rtcp_receiver.cc",
"source/rtcp_receiver.h",
"source/rtcp_receiver_help.cc",

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

@ -42,6 +42,8 @@
'source/rtp_rtcp_impl.h',
'source/rtcp_packet.cc',
'source/rtcp_packet.h',
'source/rtcp_packet/transport_feedback.cc',
'source/rtcp_packet/transport_feedback.h',
'source/rtcp_receiver.cc',
'source/rtcp_receiver.h',
'source/rtcp_receiver_help.cc',

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

@ -92,34 +92,6 @@ void ComputeMantissaAnd6bitBase2Exponent(uint32_t input_base10,
*mantissa = (input_base10 >> exponent);
}
size_t BlockToHeaderLength(size_t length_in_bytes) {
// Length in 32-bit words minus 1.
assert(length_in_bytes > 0);
assert(length_in_bytes % 4 == 0);
return (length_in_bytes / 4) - 1;
}
// From RFC 3550, RTP: A Transport Protocol for Real-Time Applications.
//
// RTP header 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| RC/FMT | PT | length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
void CreateHeader(uint8_t count_or_format, // Depends on packet type.
uint8_t packet_type,
size_t length,
uint8_t* buffer,
size_t* pos) {
assert(length <= 0xffff);
const uint8_t kVersion = 2;
AssignUWord8(buffer, pos, (kVersion << 6) + count_or_format);
AssignUWord8(buffer, pos, packet_type);
AssignUWord16(buffer, pos, length);
}
// Sender report (SR) (RFC 3550).
// 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
@ -140,10 +112,8 @@ void CreateHeader(uint8_t count_or_format, // Depends on packet type.
// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
void CreateSenderReport(const RTCPPacketSR& sr,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(sr.NumberOfReportBlocks, PT_SR, length, buffer, pos);
AssignUWord32(buffer, pos, sr.SenderSSRC);
AssignUWord32(buffer, pos, sr.NTPMostSignificant);
AssignUWord32(buffer, pos, sr.NTPLeastSignificant);
@ -162,10 +132,8 @@ void CreateSenderReport(const RTCPPacketSR& sr,
// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
void CreateReceiverReport(const RTCPPacketRR& rr,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(rr.NumberOfReportBlocks, PT_RR, length, buffer, pos);
AssignUWord32(buffer, pos, rr.SenderSSRC);
}
@ -219,12 +187,8 @@ void CreateReportBlocks(const std::vector<RTCPPacketReportBlockItem>& blocks,
void CreateIj(const std::vector<uint32_t>& ij_items,
uint8_t* buffer,
size_t* pos) {
size_t length = ij_items.size();
CreateHeader(length, PT_IJ, length, buffer, pos);
for (std::vector<uint32_t>::const_iterator it = ij_items.begin();
it != ij_items.end(); ++it) {
AssignUWord32(buffer, pos, *it);
}
for (uint32_t item : ij_items)
AssignUWord32(buffer, pos, item);
}
// Source Description (SDES) (RFC 3550).
@ -254,10 +218,8 @@ void CreateIj(const std::vector<uint32_t>& ij_items,
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
void CreateSdes(const std::vector<Sdes::Chunk>& chunks,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(chunks.size(), PT_SDES, length, buffer, pos);
const uint8_t kSdesItemType = 1;
for (std::vector<Sdes::Chunk>::const_iterator it = chunks.begin();
it != chunks.end(); ++it) {
@ -286,10 +248,8 @@ void CreateSdes(const std::vector<Sdes::Chunk>& chunks,
void CreateBye(const RTCPPacketBYE& bye,
const std::vector<uint32_t>& csrcs,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(length, PT_BYE, length, buffer, pos);
AssignUWord32(buffer, pos, bye.SenderSSRC);
for (uint32_t csrc : csrcs)
AssignUWord32(buffer, pos, csrc);
@ -311,10 +271,8 @@ void CreateBye(const RTCPPacketBYE& bye,
void CreateApp(const RTCPPacketAPP& app,
uint32_t ssrc,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(app.SubType, PT_APP, length, buffer, pos);
AssignUWord32(buffer, pos, ssrc);
AssignUWord32(buffer, pos, app.Name);
memcpy(buffer + *pos, app.Data, app.Size);
@ -343,11 +301,8 @@ void CreateApp(const RTCPPacketAPP& app,
// FCI: no feedback control information.
void CreatePli(const RTCPPacketPSFBPLI& pli,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 1;
CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
AssignUWord32(buffer, pos, pli.SenderSSRC);
AssignUWord32(buffer, pos, pli.MediaSSRC);
}
@ -364,11 +319,8 @@ void CreatePli(const RTCPPacketPSFBPLI& pli,
void CreateSli(const RTCPPacketPSFBSLI& sli,
const RTCPPacketPSFBSLIItem& sli_item,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 2;
CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
AssignUWord32(buffer, pos, sli.SenderSSRC);
AssignUWord32(buffer, pos, sli.MediaSSRC);
@ -393,11 +345,8 @@ void CreateNack(const RTCPPacketRTPFBNACK& nack,
const std::vector<RTCPPacketRTPFBNACKItem>& nack_fields,
size_t start_index,
size_t end_index,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 1;
CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
AssignUWord32(buffer, pos, nack.SenderSSRC);
AssignUWord32(buffer, pos, nack.MediaSSRC);
for (size_t i = start_index; i < end_index; ++i) {
@ -421,13 +370,10 @@ void CreateNack(const RTCPPacketRTPFBNACK& nack,
void CreateRpsi(const RTCPPacketPSFBRPSI& rpsi,
uint8_t padding_bytes,
size_t length,
uint8_t* buffer,
size_t* pos) {
// Native bit string should be a multiple of 8 bits.
assert(rpsi.NumberOfValidBits % 8 == 0);
const uint8_t kFmt = 3;
CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
AssignUWord32(buffer, pos, rpsi.SenderSSRC);
AssignUWord32(buffer, pos, rpsi.MediaSSRC);
AssignUWord8(buffer, pos, padding_bytes * 8);
@ -452,11 +398,8 @@ void CreateRpsi(const RTCPPacketPSFBRPSI& rpsi,
void CreateFir(const RTCPPacketPSFBFIR& fir,
const RTCPPacketPSFBFIRItem& fir_item,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 4;
CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
AssignUWord32(buffer, pos, fir.SenderSSRC);
AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
AssignUWord32(buffer, pos, fir_item.SSRC);
@ -494,11 +437,8 @@ void CreateTmmbrItem(const RTCPPacketRTPFBTMMBRItem& tmmbr_item,
void CreateTmmbr(const RTCPPacketRTPFBTMMBR& tmmbr,
const RTCPPacketRTPFBTMMBRItem& tmmbr_item,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 3;
CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
AssignUWord32(buffer, pos, tmmbr.SenderSSRC);
AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
CreateTmmbrItem(tmmbr_item, buffer, pos);
@ -518,11 +458,8 @@ void CreateTmmbr(const RTCPPacketRTPFBTMMBR& tmmbr,
void CreateTmmbn(const RTCPPacketRTPFBTMMBN& tmmbn,
const std::vector<RTCPPacketRTPFBTMMBRItem>& tmmbn_items,
size_t length,
uint8_t* buffer,
size_t* pos) {
const uint8_t kFmt = 4;
CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
AssignUWord32(buffer, pos, tmmbn.SenderSSRC);
AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
for (uint8_t i = 0; i < tmmbn_items.size(); ++i) {
@ -551,15 +488,12 @@ void CreateTmmbn(const RTCPPacketRTPFBTMMBN& tmmbn,
void CreateRemb(const RTCPPacketPSFBAPP& remb,
const RTCPPacketPSFBREMBItem& remb_item,
size_t length,
uint8_t* buffer,
size_t* pos) {
uint32_t mantissa = 0;
uint8_t exp = 0;
ComputeMantissaAnd6bitBase2Exponent(remb_item.BitRate, 18, &mantissa, &exp);
const uint8_t kFmt = 15;
CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
AssignUWord32(buffer, pos, remb.SenderSSRC);
AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
AssignUWord8(buffer, pos, 'R');
@ -590,10 +524,8 @@ void CreateRemb(const RTCPPacketPSFBAPP& remb,
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
void CreateXrHeader(const RTCPPacketXR& header,
size_t length,
uint8_t* buffer,
size_t* pos) {
CreateHeader(0U, PT_XR, length, buffer, pos);
AssignUWord32(buffer, pos, header.OriginatorSSRC);
}
@ -790,6 +722,35 @@ bool RtcpPacket::OnBufferFull(uint8_t* packet,
return true;
}
size_t RtcpPacket::HeaderLength() const {
size_t length_in_bytes = BlockLength();
// Length in 32-bit words minus 1.
assert(length_in_bytes > 0);
return ((length_in_bytes + 3) / 4) - 1;
}
// From RFC 3550, RTP: A Transport Protocol for Real-Time Applications.
//
// RTP header 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| RC/FMT | PT | length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
void RtcpPacket::CreateHeader(
uint8_t count_or_format, // Depends on packet type.
uint8_t packet_type,
size_t length,
uint8_t* buffer,
size_t* pos) const {
assert(length <= 0xffff);
const uint8_t kVersion = 2;
AssignUWord8(buffer, pos, (kVersion << 6) + count_or_format);
AssignUWord8(buffer, pos, packet_type);
AssignUWord16(buffer, pos, length);
}
bool Empty::Create(uint8_t* packet,
size_t* index,
size_t max_length,
@ -797,6 +758,10 @@ bool Empty::Create(uint8_t* packet,
return true;
}
size_t Empty::BlockLength() const {
return 0;
}
bool SenderReport::Create(uint8_t* packet,
size_t* index,
size_t max_length,
@ -805,7 +770,8 @@ bool SenderReport::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateSenderReport(sr_, BlockToHeaderLength(BlockLength()), packet, index);
CreateHeader(sr_.NumberOfReportBlocks, PT_SR, HeaderLength(), packet, index);
CreateSenderReport(sr_, packet, index);
CreateReportBlocks(report_blocks_, packet, index);
return true;
}
@ -828,7 +794,8 @@ bool ReceiverReport::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateReceiverReport(rr_, BlockToHeaderLength(BlockLength()), packet, index);
CreateHeader(rr_.NumberOfReportBlocks, PT_RR, HeaderLength(), packet, index);
CreateReceiverReport(rr_, packet, index);
CreateReportBlocks(report_blocks_, packet, index);
return true;
}
@ -851,6 +818,8 @@ bool Ij::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
size_t length = ij_items_.size();
CreateHeader(length, PT_IJ, length, packet, index);
CreateIj(ij_items_, packet, index);
return true;
}
@ -873,7 +842,8 @@ bool Sdes::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateSdes(chunks_, BlockToHeaderLength(BlockLength()), packet, index);
CreateHeader(chunks_.size(), PT_SDES, HeaderLength(), packet, index);
CreateSdes(chunks_, packet, index);
return true;
}
@ -914,7 +884,9 @@ bool Bye::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateBye(bye_, csrcs_, BlockToHeaderLength(BlockLength()), packet, index);
size_t length = HeaderLength();
CreateHeader(length, PT_BYE, length, packet, index);
CreateBye(bye_, csrcs_, packet, index);
return true;
}
@ -935,7 +907,8 @@ bool App::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateApp(app_, ssrc_, BlockToHeaderLength(BlockLength()), packet, index);
CreateHeader(app_.SubType, PT_APP, HeaderLength(), packet, index);
CreateApp(app_, ssrc_, packet, index);
return true;
}
@ -947,7 +920,9 @@ bool Pli::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreatePli(pli_, BlockToHeaderLength(BlockLength()), packet, index);
const uint8_t kFmt = 1;
CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
CreatePli(pli_, packet, index);
return true;
}
@ -959,7 +934,9 @@ bool Sli::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateSli(sli_, sli_item_, BlockToHeaderLength(BlockLength()), packet, index);
const uint8_t kFmt = 2;
CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
CreateSli(sli_, sli_item_, packet, index);
return true;
}
@ -981,8 +958,11 @@ bool Nack::Create(uint8_t* packet,
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,
BlockToHeaderLength((num_nack_fields * 4) + kCommonFbFmtLength),
packet, index);
nack_index += num_nack_fields;
@ -991,6 +971,10 @@ bool Nack::Create(uint8_t* packet,
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());
@ -1024,8 +1008,9 @@ bool Rpsi::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateRpsi(rpsi_, padding_bytes_, BlockToHeaderLength(BlockLength()), packet,
index);
const uint8_t kFmt = 3;
CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
CreateRpsi(rpsi_, padding_bytes_, packet, index);
return true;
}
@ -1064,7 +1049,9 @@ bool Fir::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateFir(fir_, fir_item_, BlockToHeaderLength(BlockLength()), packet, index);
const uint8_t kFmt = 4;
CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
CreateFir(fir_, fir_item_, packet, index);
return true;
}
@ -1076,8 +1063,9 @@ bool Remb::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateRemb(remb_, remb_item_, BlockToHeaderLength(BlockLength()), packet,
index);
const uint8_t kFmt = 15;
CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
CreateRemb(remb_, remb_item_, packet, index);
return true;
}
@ -1097,8 +1085,9 @@ bool Tmmbr::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateTmmbr(tmmbr_, tmmbr_item_, BlockToHeaderLength(BlockLength()), packet,
index);
const uint8_t kFmt = 3;
CreateHeader(kFmt, PT_RTPFB, HeaderLength(), packet, index);
CreateTmmbr(tmmbr_, tmmbr_item_, packet, index);
return true;
}
@ -1124,8 +1113,9 @@ bool Tmmbn::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateTmmbn(tmmbn_, tmmbn_items_, BlockToHeaderLength(BlockLength()), packet,
index);
const uint8_t kFmt = 4;
CreateHeader(kFmt, PT_RTPFB, HeaderLength(), packet, index);
CreateTmmbn(tmmbn_, tmmbn_items_, packet, index);
return true;
}
@ -1137,7 +1127,8 @@ bool Xr::Create(uint8_t* packet,
if (!OnBufferFull(packet, index, callback))
return false;
}
CreateXrHeader(xr_header_, BlockToHeaderLength(BlockLength()), packet, index);
CreateHeader(0U, PT_XR, HeaderLength(), packet, index);
CreateXrHeader(xr_header_, packet, index);
CreateRrtr(rrtr_blocks_, packet, index);
CreateDlrr(dlrr_blocks_, packet, index);
CreateVoipMetric(voip_metric_blocks_, packet, index);

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

@ -92,18 +92,27 @@ class RtcpPacket {
PacketReadyCallback* callback) const;
protected:
RtcpPacket() : kHeaderLength(4) {}
RtcpPacket() {}
virtual bool Create(uint8_t* packet,
size_t* index,
size_t max_length,
PacketReadyCallback* callback) const = 0;
void CreateHeader(uint8_t count_or_format,
uint8_t packet_type,
size_t length,
uint8_t* buffer,
size_t* pos) const;
bool OnBufferFull(uint8_t* packet,
size_t* index,
RtcpPacket::PacketReadyCallback* callback) const;
const size_t kHeaderLength;
virtual size_t BlockLength() const = 0;
size_t HeaderLength() const;
static const size_t kHeaderLength = 4;
private:
bool CreateAndAddAppended(uint8_t* packet,
@ -114,6 +123,8 @@ class RtcpPacket {
std::vector<RtcpPacket*> appended_packets_;
};
// TODO(sprang): Move RtcpPacket subclasses out to separate files.
class Empty : public RtcpPacket {
public:
Empty() : RtcpPacket() {}
@ -126,6 +137,8 @@ class Empty : public RtcpPacket {
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
size_t BlockLength() const override;
private:
DISALLOW_COPY_AND_ASSIGN(Empty);
};
@ -651,6 +664,8 @@ class Nack : public RtcpPacket {
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
size_t BlockLength() const override;
private:
RTCPUtility::RTCPPacketRTPFBNACK nack_;

802
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc Normal file
View File

@ -0,0 +1,802 @@
/*
* 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/transport_feedback.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
namespace webrtc {
namespace rtcp {
// Header size:
// * 12 bytes Common Packet Format for RTCP Feedback Messages
// * 8 bytes FeedbackPacket header
static const uint32_t kHeaderSizeBytes = 12 + 8;
static const uint32_t kChunkSizeBytes = 2;
static const uint32_t kOneBitVectorCapacity = 14;
static const uint32_t kTwoBitVectorCapacity = 7;
static const uint32_t kRunLengthCapacity = 0x1FFF;
// TODO(sprang): Add support for dynamic max size for easier fragmentation,
// eg. set it to what's left in the buffer or IP_PACKET_SIZE.
// Size constraint imposed by RTCP common header: 16bit size field interpreted
// as number of four byte words minus the first header word.
static const uint32_t kMaxSizeBytes = (1 << 16) * 4;
static const uint32_t kMinSizeBytes = kHeaderSizeBytes + kChunkSizeBytes;
static const uint32_t kBaseScaleFactor =
TransportFeedback::kDeltaScaleFactor * (1 << 8);
class PacketStatusChunk {
public:
virtual ~PacketStatusChunk() {}
virtual uint16_t NumSymbols() const = 0;
virtual void AppendSymbolsTo(
std::vector<TransportFeedback::StatusSymbol>* vec) const = 0;
virtual void WriteTo(uint8_t* buffer) const = 0;
};
uint8_t EncodeSymbol(TransportFeedback::StatusSymbol symbol) {
switch (symbol) {
case TransportFeedback::StatusSymbol::kNotReceived:
return 0;
case TransportFeedback::StatusSymbol::kReceivedSmallDelta:
return 1;
case TransportFeedback::StatusSymbol::kReceivedLargeDelta:
return 2;
default:
RTC_NOTREACHED();
return 0;
}
}
TransportFeedback::StatusSymbol DecodeSymbol(uint8_t value) {
switch (value) {
case 0:
return TransportFeedback::StatusSymbol::kNotReceived;
case 1:
return TransportFeedback::StatusSymbol::kReceivedSmallDelta;
case 2:
return TransportFeedback::StatusSymbol::kReceivedLargeDelta;
default:
RTC_NOTREACHED();
return TransportFeedback::StatusSymbol::kNotReceived;
}
}
TransportFeedback::TransportFeedback()
: packet_sender_ssrc_(0),
media_source_ssrc_(0),
base_seq_(-1),
base_time_(-1),
feedback_seq_(0),
last_seq_(-1),
last_timestamp_(-1),
first_symbol_cardinality_(0),
vec_needs_two_bit_symbols_(false),
size_bytes_(kHeaderSizeBytes) {
}
TransportFeedback::~TransportFeedback() {
for (PacketStatusChunk* chunk : status_chunks_)
delete chunk;
}
// One Bit Status Vector Chunk
//
// 0 1
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |T|S| symbol list |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// T = 1
// S = 0
// symbol list = 14 entries where 0 = not received, 1 = received
class OneBitVectorChunk : public PacketStatusChunk {
public:
static const int kCapacity = 14;
explicit OneBitVectorChunk(
std::deque<TransportFeedback::StatusSymbol>* symbols) {
size_t input_size = symbols->size();
for (size_t i = 0; i < kCapacity; ++i) {
if (i < input_size) {
symbols_[i] = symbols->front();
symbols->pop_front();
} else {
symbols_[i] = TransportFeedback::StatusSymbol::kNotReceived;
}
}
}
virtual ~OneBitVectorChunk() {}
uint16_t NumSymbols() const override { return kCapacity; }
void AppendSymbolsTo(
std::vector<TransportFeedback::StatusSymbol>* vec) const override {
vec->insert(vec->end(), &symbols_[0], &symbols_[kCapacity]);
}
void WriteTo(uint8_t* buffer) const override {
const int kSymbolsInFirstByte = 6;
const int kSymbolsInSecondByte = 8;
buffer[0] = 0x80u;
for (int i = 0; i < kSymbolsInFirstByte; ++i) {
uint8_t encoded_symbol = EncodeSymbol(symbols_[i]);
DCHECK_LE(encoded_symbol, 1u);
buffer[0] |= encoded_symbol << (kSymbolsInFirstByte - (i + 1));
}
buffer[1] = 0x00u;
for (int i = 0; i < kSymbolsInSecondByte; ++i) {
uint8_t encoded_symbol = EncodeSymbol(symbols_[i + kSymbolsInFirstByte]);
DCHECK_LE(encoded_symbol, 1u);
buffer[1] |= encoded_symbol << (kSymbolsInSecondByte - (i + 1));
}
}
static OneBitVectorChunk* ParseFrom(const uint8_t* data) {
OneBitVectorChunk* chunk = new OneBitVectorChunk();
size_t index = 0;
for (int i = 5; i >= 0; --i) // Last 5 bits from first byte.
chunk->symbols_[index++] = DecodeSymbol((data[0] >> i) & 0x01);
for (int i = 7; i >= 0; --i) // 8 bits from the last byte.
chunk->symbols_[index++] = DecodeSymbol((data[1] >> i) & 0x01);
return chunk;
}
private:
OneBitVectorChunk() {}
TransportFeedback::StatusSymbol symbols_[kCapacity];
};
// Two Bit Status Vector Chunk
//
// 0 1
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |T|S| symbol list |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// T = 1
// S = 1
// symbol list = 7 entries of two bits each, see (Encode|Decode)Symbol
class TwoBitVectorChunk : public PacketStatusChunk {
public:
static const int kCapacity = 7;
explicit TwoBitVectorChunk(
std::deque<TransportFeedback::StatusSymbol>* symbols) {
size_t input_size = symbols->size();
for (size_t i = 0; i < kCapacity; ++i) {
if (i < input_size) {
symbols_[i] = symbols->front();
symbols->pop_front();
} else {
symbols_[i] = TransportFeedback::StatusSymbol::kNotReceived;
}
}
}
virtual ~TwoBitVectorChunk() {}
uint16_t NumSymbols() const override { return kCapacity; }
void AppendSymbolsTo(
std::vector<TransportFeedback::StatusSymbol>* vec) const override {
vec->insert(vec->end(), &symbols_[0], &symbols_[kCapacity]);
}
void WriteTo(uint8_t* buffer) const override {
buffer[0] = 0xC0;
buffer[0] |= EncodeSymbol(symbols_[0]) << 4;
buffer[0] |= EncodeSymbol(symbols_[1]) << 2;
buffer[0] |= EncodeSymbol(symbols_[2]);
buffer[1] = EncodeSymbol(symbols_[3]) << 6;
buffer[1] |= EncodeSymbol(symbols_[4]) << 4;
buffer[1] |= EncodeSymbol(symbols_[5]) << 2;
buffer[1] |= EncodeSymbol(symbols_[6]);
}
static TwoBitVectorChunk* ParseFrom(const uint8_t* buffer) {
TwoBitVectorChunk* chunk = new TwoBitVectorChunk();
chunk->symbols_[0] = DecodeSymbol((buffer[0] >> 4) & 0x03);
chunk->symbols_[1] = DecodeSymbol((buffer[0] >> 2) & 0x03);
chunk->symbols_[2] = DecodeSymbol(buffer[0] & 0x03);
chunk->symbols_[3] = DecodeSymbol((buffer[1] >> 6) & 0x03);
chunk->symbols_[4] = DecodeSymbol((buffer[1] >> 4) & 0x03);
chunk->symbols_[5] = DecodeSymbol((buffer[1] >> 2) & 0x03);
chunk->symbols_[6] = DecodeSymbol(buffer[1] & 0x03);
return chunk;
}
private:
TwoBitVectorChunk() {}
TransportFeedback::StatusSymbol symbols_[kCapacity];
};
// Two Bit Status Vector Chunk
//
// 0 1
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |T| S | Run Length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// T = 0
// S = symbol, see (Encode|Decode)Symbol
// Run Length = Unsigned integer denoting the run length of the symbol
class RunLengthChunk : public PacketStatusChunk {
public:
RunLengthChunk(TransportFeedback::StatusSymbol symbol, size_t size)
: symbol_(symbol), size_(size) {
DCHECK_LE(size, 0x1FFFu);
}
virtual ~RunLengthChunk() {}
uint16_t NumSymbols() const override { return size_; }
void AppendSymbolsTo(
std::vector<TransportFeedback::StatusSymbol>* vec) const override {
vec->insert(vec->end(), size_, symbol_);
}
void WriteTo(uint8_t* buffer) const override {
buffer[0] = EncodeSymbol(symbol_) << 5; // Write S (T = 0 implicitly)
buffer[0] |= (size_ >> 8) & 0x1F; // 5 most significant bits of run length.
buffer[1] = size_ & 0xFF; // 8 least significant bits of run length.
}
static RunLengthChunk* ParseFrom(const uint8_t* buffer) {
DCHECK_EQ(0, buffer[0] & 0x80);
TransportFeedback::StatusSymbol symbol =
DecodeSymbol((buffer[0] >> 5) & 0x03);
uint16_t count = (static_cast<uint16_t>(buffer[0] & 0x1F) << 8) | buffer[1];
return new RunLengthChunk(symbol, count);
}
private:
const TransportFeedback::StatusSymbol symbol_;
const size_t size_;
};
// Unwrap to a larger type, for easier handling of wraps.
int64_t TransportFeedback::Unwrap(uint16_t sequence_number) {
if (last_seq_ == -1)
return sequence_number;
int64_t delta = sequence_number - last_seq_;
if (IsNewerSequenceNumber(sequence_number,
static_cast<uint16_t>(last_seq_))) {
if (delta < 0)
delta += (1 << 16);
} else if (delta > 0) {
delta -= (1 << 16);
}
return last_seq_ + delta;
}
void TransportFeedback::WithPacketSenderSsrc(uint32_t ssrc) {
packet_sender_ssrc_ = ssrc;
}
void TransportFeedback::WithMediaSourceSsrc(uint32_t ssrc) {
media_source_ssrc_ = ssrc;
}
void TransportFeedback::WithBase(uint16_t base_sequence,
int64_t ref_timestamp_us) {
DCHECK_EQ(-1, base_seq_);
DCHECK_NE(-1, ref_timestamp_us);
base_seq_ = base_sequence;
last_seq_ = base_sequence;
base_time_ = ref_timestamp_us / kBaseScaleFactor;
last_timestamp_ = base_time_ * kBaseScaleFactor;
}
void TransportFeedback::WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
feedback_seq_ = feedback_sequence;
}
bool TransportFeedback::WithReceivedPacket(uint16_t sequence_number,
int64_t timestamp) {
DCHECK_NE(-1, base_seq_);
int64_t seq = Unwrap(sequence_number);
if (seq != base_seq_ && seq <= last_seq_)
return false;
// Convert to ticks and round.
int64_t delta_full = timestamp - last_timestamp_;
delta_full +=
delta_full < 0 ? -(kDeltaScaleFactor / 2) : kDeltaScaleFactor / 2;
delta_full /= kDeltaScaleFactor;
int16_t delta = static_cast<int16_t>(delta_full);
// If larger than 16bit signed, we can't represent it - need new fb packet.
if (delta != delta_full) {
LOG(LS_WARNING) << "Delta value too large ( >= 2^16 ticks )";
return false;
}
StatusSymbol symbol;
if (delta >= 0 && delta <= 0xFF) {
symbol = StatusSymbol::kReceivedSmallDelta;
} else {
symbol = StatusSymbol::kReceivedLargeDelta;
}
if (!AddSymbol(symbol, seq))
return false;
receive_deltas_.push_back(delta);
last_timestamp_ += delta * kDeltaScaleFactor;
return true;
}
// Add a symbol for a received packet, with the given sequence number. This
// method will add any "packet not received" symbols needed before this one.
bool TransportFeedback::AddSymbol(StatusSymbol symbol, int64_t seq) {
while (last_seq_ < seq - 1) {
if (!Encode(StatusSymbol::kNotReceived))
return false;
++last_seq_;
}
if (!Encode(symbol))
return false;
last_seq_ = seq;
return true;
}
// Append a symbol to the internal symbol vector. If the new state cannot be
// represented using a single status chunk, a chunk will first be emitted and
// the associated symbols removed from the internal symbol vector.
bool TransportFeedback::Encode(StatusSymbol symbol) {
if (last_seq_ - base_seq_ + 1 > 0xFFFF) {
LOG(LS_WARNING) << "Packet status count too large ( >= 2^16 )";
return false;
}
bool is_two_bit;
int delta_size;
switch (symbol) {
case StatusSymbol::kReceivedSmallDelta:
delta_size = 1;
is_two_bit = false;
break;
case StatusSymbol::kReceivedLargeDelta:
delta_size = 2;
is_two_bit = true;
break;
case StatusSymbol::kNotReceived:
is_two_bit = false;
delta_size = 0;
break;
default:
RTC_NOTREACHED();
return false;
}
if (symbol_vec_.empty()) {
if (size_bytes_ + delta_size + kChunkSizeBytes > kMaxSizeBytes)
return false;
symbol_vec_.push_back(symbol);
vec_needs_two_bit_symbols_ = is_two_bit;
first_symbol_cardinality_ = 1;
size_bytes_ += delta_size + kChunkSizeBytes;
return true;
}
if (size_bytes_ + delta_size > kMaxSizeBytes)
return false;
// Capacity, in number of symbols, that a vector chunk could hold.
size_t capacity = vec_needs_two_bit_symbols_ ? kTwoBitVectorCapacity
: kOneBitVectorCapacity;
// first_symbol_cardinality_ is the number of times the first symbol in
// symbol_vec is repeated. So if that is equal to the size of symbol_vec,
// there is only one kind of symbol - we can potentially RLE encode it.
// If we have less than (capacity) symbols in symbol_vec, we can't know
// for certain this will be RLE-encoded; if a different symbol is added
// these symbols will be needed to emit a vector chunk instead. However,
// if first_symbol_cardinality_ > capacity, then we cannot encode the
// current state as a vector chunk - we must first emit symbol_vec as an
// RLE-chunk and then add the new symbol.
bool rle_candidate = symbol_vec_.size() == first_symbol_cardinality_ ||
first_symbol_cardinality_ > capacity;
if (rle_candidate) {
if (symbol_vec_.back() == symbol) {
++first_symbol_cardinality_;
if (first_symbol_cardinality_ <= capacity) {
symbol_vec_.push_back(symbol);
} else if (first_symbol_cardinality_ == kRunLengthCapacity) {
// Max length for an RLE-chunk reached.
EmitRunLengthChunk();
}
size_bytes_ += delta_size;
return true;
} else {
// New symbol does not match what's already in symbol_vec.
if (first_symbol_cardinality_ > capacity) {
// Symbols in symbol_vec can only be RLE-encoded. Emit the RLE-chunk
// and re-add input. symbol_vec is then guaranteed to have room for the
// symbol, so recursion cannot continue.
EmitRunLengthChunk();
return Encode(symbol);
}
// Fall through and treat state as non RLE-candidate.
}
}
// If this code point is reached, symbols in symbol_vec cannot be RLE-encoded.
if (is_two_bit && !vec_needs_two_bit_symbols_) {
// If the symbols in symbol_vec can be encoded using a one-bit chunk but
// the input symbol cannot, first check if we can simply change target type.
vec_needs_two_bit_symbols_ = true;
if (symbol_vec_.size() >= kTwoBitVectorCapacity) {
// symbol_vec contains more symbols than we can encode in a single
// two-bit chunk. Emit a new vector append to the remains, if any.
if (size_bytes_ + delta_size + kChunkSizeBytes > kMaxSizeBytes)
return false;
EmitVectorChunk();
// If symbol_vec isn't empty after emitting a vector chunk, we need to
// account for chunk size (otherwise handled by Encode method).
if (!symbol_vec_.empty())
size_bytes_ += kChunkSizeBytes;
return Encode(symbol);
}
// symbol_vec symbols fit within a single two-bit vector chunk.
capacity = kTwoBitVectorCapacity;
}
symbol_vec_.push_back(symbol);
if (symbol_vec_.size() == capacity)
EmitVectorChunk();
size_bytes_ += delta_size;
return true;
}
// Upon packet completion, emit any remaining symbols in symbol_vec that have
// not yet been emitted in a status chunk.
void TransportFeedback::EmitRemaining() {
if (symbol_vec_.empty())
return;
size_t capacity = vec_needs_two_bit_symbols_ ? kTwoBitVectorCapacity
: kOneBitVectorCapacity;
if (first_symbol_cardinality_ > capacity) {
EmitRunLengthChunk();
} else {
EmitVectorChunk();
}
}
void TransportFeedback::EmitVectorChunk() {
if (vec_needs_two_bit_symbols_) {
status_chunks_.push_back(new TwoBitVectorChunk(&symbol_vec_));
} else {
status_chunks_.push_back(new OneBitVectorChunk(&symbol_vec_));
}
// Update first symbol cardinality to match what is potentially left in in
// symbol_vec.
first_symbol_cardinality_ = 1;
for (size_t i = 1; i < symbol_vec_.size(); ++i) {
if (symbol_vec_[i] != symbol_vec_[0])
break;
++first_symbol_cardinality_;
}
}
void TransportFeedback::EmitRunLengthChunk() {
DCHECK_GE(first_symbol_cardinality_, symbol_vec_.size());
status_chunks_.push_back(
new RunLengthChunk(symbol_vec_.front(), first_symbol_cardinality_));
symbol_vec_.clear();
}
size_t TransportFeedback::BlockLength() const {
return size_bytes_;
}
uint16_t TransportFeedback::GetBaseSequence() const {
return base_seq_;
}
int32_t TransportFeedback::GetBaseTime() const {
return static_cast<int32_t>(base_time_ & 0x00FFFFFF);
}
int64_t TransportFeedback::GetBaseTimeUs() const {
return GetBaseTime() * kBaseScaleFactor;
}
std::vector<TransportFeedback::StatusSymbol>
TransportFeedback::GetStatusVector() const {
std::vector<TransportFeedback::StatusSymbol> symbols;
for (PacketStatusChunk* chunk : status_chunks_)
chunk->AppendSymbolsTo(&symbols);
int64_t status_count = last_seq_ - base_seq_ + 1;
// If packet ends with a vector chunk, it may contain extraneous "packet not
// received"-symbols at the end. Crop any such symbols.
symbols.erase(symbols.begin() + status_count, symbols.end());
return symbols;
}
std::vector<int16_t> TransportFeedback::GetReceiveDeltas() const {
return receive_deltas_;
}
std::vector<int64_t> TransportFeedback::GetReceiveDeltasUs() const {
if (receive_deltas_.empty())
return std::vector<int64_t>();
std::vector<int64_t> us_deltas;
for (int16_t delta : receive_deltas_)
us_deltas.push_back(static_cast<int64_t>(delta) * kDeltaScaleFactor);
return us_deltas;
}
// Serialize packet.
bool TransportFeedback::Create(uint8_t* packet,
size_t* position,
size_t max_length,
PacketReadyCallback* callback) const {
if (base_seq_ == -1)
return false;
while (*position + size_bytes_ > max_length) {
if (!OnBufferFull(packet, position, callback))
return false;
}
CreateHeader(kFeedbackMessageType, kPayloadType, HeaderLength(), packet,
position);
ByteWriter<uint32_t>::WriteBigEndian(&packet[*position], packet_sender_ssrc_);
*position += 4;
ByteWriter<uint32_t>::WriteBigEndian(&packet[*position], media_source_ssrc_);
*position += 4;
DCHECK_LE(base_seq_, 0xFFFF);
ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], base_seq_);
*position += 2;
int64_t status_count = last_seq_ - base_seq_ + 1;
DCHECK_LE(status_count, 0xFFFF);
ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], status_count);
*position += 2;
ByteWriter<int32_t, 3>::WriteBigEndian(&packet[*position],
static_cast<int16_t>(base_time_));
*position += 3;
packet[(*position)++] = feedback_seq_;
// TODO(sprang): Get rid of this cast.
const_cast<TransportFeedback*>(this)->EmitRemaining();
for (PacketStatusChunk* chunk : status_chunks_) {
chunk->WriteTo(&packet[*position]);
*position += 2;
}
for (int16_t delta : receive_deltas_) {
if (delta >= 0 && delta <= 0xFF) {
packet[(*position)++] = delta;
} else {
ByteWriter<int16_t>::WriteBigEndian(&packet[*position], delta);
*position += 2;
}
}
while ((*position % 4) != 0)
packet[(*position)++] = 0;
return true;
}
// Message 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=15 | PT=205 | length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | SSRC of packet sender |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | SSRC of media source |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | base sequence number | packet status count |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | reference time | fb pkt. count |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | packet chunk | packet chunk |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// . .
// . .
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | packet chunk | recv delta | recv delta |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// . .
// . .
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | recv delta | recv delta | zero padding |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// De-serialize packet.
rtc::scoped_ptr<TransportFeedback> TransportFeedback::ParseFrom(
const uint8_t* buffer,
size_t length) {
rtc::scoped_ptr<TransportFeedback> packet(new TransportFeedback());
if (length < kMinSizeBytes) {
LOG(LS_WARNING) << "Buffer too small (" << length
<< " bytes) to fit a "
"FeedbackPacket. Minimum size = " << kMinSizeBytes;
return nullptr;
}
size_t packet_size_words =
ByteReader<uint16_t>::ReadBigEndian(&buffer[2]) + 1;
if (length < packet_size_words * 4) {
LOG(LS_WARNING) << "Buffer too small (" << length
<< " bytes) to fit a FeedbackPacket of "
<< packet_size_words << " 32bit words.";
return nullptr;
}
// TODO(sprang): Break this out and generalize when implementing parsing of
// other RtcpPacket subclasses.
const uint8_t kRtcpVersion = 2;
uint8_t version = buffer[0] >> 6;
if (version != kRtcpVersion) {
LOG(LS_WARNING) << "Invalid RTCP header: Version must be " << kRtcpVersion
<< " but was " << version;
return nullptr;
}
bool has_padding = (buffer[0] & 0x20) != 0;
uint8_t format = buffer[0] & 0x1F;
if (format != kFeedbackMessageType) {
LOG(LS_WARNING) << "Invalid RTCP header: FMT must be "
<< kFeedbackMessageType << " but was " << format;
return nullptr;
}
uint8_t payload_type = buffer[1];
if (payload_type != kPayloadType) {
LOG(LS_WARNING) << "Invalid RTCP header: PT must be " << kPayloadType
<< " but was " << payload_type;
return nullptr;
}
size_t payload_size = packet_size_words * 4;
if (has_padding) {
uint8_t padding_bytes = buffer[payload_size - 1];
if (payload_size < kMinSizeBytes + padding_bytes) {
LOG(LS_WARNING) << "Invalid RTCP header: Too many padding bytes ("
<< padding_bytes << ") for a packet size of "
<< payload_size << "bytes.";
return nullptr;
}
payload_size -= padding_bytes;
}
packet->packet_sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[4]);
packet->media_source_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[8]);
packet->base_seq_ = ByteReader<uint16_t>::ReadBigEndian(&buffer[12]);
uint16_t num_packets = ByteReader<uint16_t>::ReadBigEndian(&buffer[14]);
packet->base_time_ = ByteReader<int32_t, 3>::ReadBigEndian(&buffer[16]);
packet->feedback_seq_ = buffer[19];
size_t index = 20;
if (num_packets == 0) {
LOG(LS_WARNING) << "Empty feedback messages not allowed.";
return nullptr;
}
packet->last_seq_ = packet->base_seq_ + num_packets - 1;
size_t packets_read = 0;
while (packets_read < num_packets) {
if (index + 2 > payload_size) {
LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
return nullptr;
}
PacketStatusChunk* chunk =
ParseChunk(&buffer[index], num_packets - packets_read);
if (chunk == nullptr)
return nullptr;
index += 2;
packet->status_chunks_.push_back(chunk);
packets_read += chunk->NumSymbols();
}
std::vector<StatusSymbol> symbols = packet->GetStatusVector();
DCHECK_EQ(num_packets, symbols.size());
for (StatusSymbol symbol : symbols) {
switch (symbol) {
case StatusSymbol::kReceivedSmallDelta:
if (index + 1 > payload_size) {
LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
return nullptr;
}
packet->receive_deltas_.push_back(buffer[index]);
++index;
break;
case StatusSymbol::kReceivedLargeDelta:
if (index + 2 > payload_size) {
LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
return nullptr;
}
packet->receive_deltas_.push_back(
ByteReader<int16_t>::ReadBigEndian(&buffer[index]));
index += 2;
break;
default:
continue;
}
}
DCHECK_GE(index, payload_size - 3);
DCHECK_LE(index, payload_size);
return packet;
}
PacketStatusChunk* TransportFeedback::ParseChunk(const uint8_t* buffer,
size_t max_size) {
if (buffer[0] & 0x80) {
// First bit set => vector chunk.
std::deque<StatusSymbol> symbols;
if (buffer[0] & 0x40) {
// Second bit set => two bits per symbol vector.
return TwoBitVectorChunk::ParseFrom(buffer);
}
// Second bit not set => one bit per symbol vector.
return OneBitVectorChunk::ParseFrom(buffer);
}
// First bit not set => RLE chunk.
RunLengthChunk* rle_chunk = RunLengthChunk::ParseFrom(buffer);
if (rle_chunk->NumSymbols() > max_size) {
LOG(LS_WARNING) << "Header/body mismatch. "
"RLE block of size " << rle_chunk->NumSymbols()
<< " but only " << max_size << " left to read.";
delete rle_chunk;
return nullptr;
}
return rle_chunk;
}
} // namespace rtcp
} // namespace webrtc

104
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h Normal file
View File

@ -0,0 +1,104 @@
/*
* 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_TRANSPORT_FEEDBACK_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_TRANSPORT_FEEDBACK_H_
#include <deque>
#include <vector>
#include "webrtc/base/constructormagic.h"
#include "webrtc/modules/interface/module_common_types.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
namespace webrtc {
namespace rtcp {
class PacketStatusChunk;
class TransportFeedback : public RtcpPacket {
public:
TransportFeedback();
virtual ~TransportFeedback();
void WithPacketSenderSsrc(uint32_t ssrc);
void WithMediaSourceSsrc(uint32_t ssrc);
void WithBase(uint16_t base_sequence, // Seq# of first packet in this msg.
int64_t ref_timestamp_us); // Reference timestamp for this msg.
void WithFeedbackSequenceNumber(uint8_t feedback_sequence);
// NOTE: This method requires increasing sequence numbers (excepting wraps).
bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us);
enum class StatusSymbol {
kNotReceived,
kReceivedSmallDelta,
kReceivedLargeDelta,
};
uint16_t GetBaseSequence() const;
int32_t GetBaseTime() const;
std::vector<TransportFeedback::StatusSymbol> GetStatusVector() const;
std::vector<int16_t> GetReceiveDeltas() const;
// Get the reference time in microseconds, including any precision loss.
int64_t GetBaseTimeUs() const;
// Convenience method for getting all deltas as microseconds. The first delta
// is relative the base time.
std::vector<int64_t> GetReceiveDeltasUs() const;
static const int kDeltaScaleFactor = 250; // Convert to multiples of 0.25ms.
static const uint8_t kFeedbackMessageType = 15; // TODO(sprang): IANA reg?
static const uint8_t kPayloadType = 205; // RTPFB, see RFC4585.
static rtc::scoped_ptr<TransportFeedback> ParseFrom(const uint8_t* buffer,
size_t length);
protected:
bool Create(uint8_t* packet,
size_t* position,
size_t max_length,
PacketReadyCallback* callback) const override;
size_t BlockLength() const override;
private:
static PacketStatusChunk* ParseChunk(const uint8_t* buffer, size_t max_size);
int64_t Unwrap(uint16_t sequence_number);
bool AddSymbol(StatusSymbol symbol, int64_t seq);
bool Encode(StatusSymbol symbol);
bool HandleRleCandidate(StatusSymbol symbol,
int current_capacity,
int delta_size);
void EmitRemaining();
void EmitVectorChunk();
void EmitRunLengthChunk();
uint32_t packet_sender_ssrc_;
uint32_t media_source_ssrc_;
int32_t base_seq_;
int64_t base_time_;
uint8_t feedback_seq_;
std::vector<PacketStatusChunk*> status_chunks_;
std::vector<int16_t> receive_deltas_;
int64_t last_seq_;
int64_t last_timestamp_;
std::deque<StatusSymbol> symbol_vec_;
uint16_t first_symbol_cardinality_;
bool vec_needs_two_bit_symbols_;
uint32_t size_bytes_;
DISALLOW_COPY_AND_ASSIGN(TransportFeedback);
};
} // namespace rtcp
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_TRANSPORT_FEEDBACK_H_

434
webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc Normal file
View File

@ -0,0 +1,434 @@
/*
* 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/transport_feedback.h"
#include <limits>
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
using webrtc::rtcp::TransportFeedback;
namespace webrtc {
namespace {
static const int kHeaderSize = 20;
static const int kStatusChunkSize = 2;
static const int kSmallDeltaSize = 1;
static const int kLargeDeltaSize = 2;
static const int64_t kDeltaLimit = 0xFF * TransportFeedback::kDeltaScaleFactor;
class FeedbackTester {
public:
FeedbackTester()
: expected_size_(kAnySize),
default_delta_(TransportFeedback::kDeltaScaleFactor * 4) {}
void WithExpectedSize(size_t expected_size) {
expected_size_ = expected_size;
}
void WithDefaultDelta(int64_t delta) { default_delta_ = delta; }
void WithInput(const uint16_t received_seq[],
const int64_t received_ts[],
uint16_t length) {
rtc::scoped_ptr<int64_t[]> temp_deltas;
if (received_ts == nullptr) {
temp_deltas.reset(new int64_t[length]);
GenerateDeltas(received_seq, length, temp_deltas.get());
received_ts = temp_deltas.get();
}
expected_seq_.clear();
expected_deltas_.clear();
feedback_.reset(new TransportFeedback());
feedback_->WithBase(received_seq[0], received_ts[0]);
int64_t last_time = feedback_->GetBaseTimeUs();
for (int i = 0; i < length; ++i) {
int64_t time = received_ts[i];
EXPECT_TRUE(feedback_->WithReceivedPacket(received_seq[i], time));
if (last_time != -1) {
int64_t delta = time - last_time;
expected_deltas_.push_back(delta);
}
last_time = time;
}
expected_seq_.insert(expected_seq_.begin(), &received_seq[0],
&received_seq[length]);
}
void VerifyPacket() {
serialized_ = feedback_->Build();
VerifyInternal();
feedback_ = TransportFeedback::ParseFrom(serialized_->Buffer(),
serialized_->Length());
ASSERT_NE(nullptr, feedback_.get());
VerifyInternal();
}
static const size_t kAnySize = static_cast<size_t>(0) - 1;
private:
void VerifyInternal() {
if (expected_size_ != kAnySize) {
// Round up to whole 32-bit words.
size_t expected_size_words = (expected_size_ + 3) / 4;
size_t expected_size_bytes = expected_size_words * 4;
EXPECT_EQ(expected_size_bytes, serialized_->Length());
}
std::vector<TransportFeedback::StatusSymbol> symbols =
feedback_->GetStatusVector();
uint16_t seq = feedback_->GetBaseSequence();
auto seq_it = expected_seq_.begin();
for (TransportFeedback::StatusSymbol symbol : symbols) {
bool received =
(symbol == TransportFeedback::StatusSymbol::kReceivedSmallDelta ||
symbol == TransportFeedback::StatusSymbol::kReceivedLargeDelta);
if (seq_it != expected_seq_.end()) {
if (seq == *seq_it) {
ASSERT_NE(expected_seq_.end(), seq_it);
ASSERT_TRUE(received) << "Expected received packet @ " << seq;
++seq_it;
} else {
ASSERT_FALSE(received) << "Did not expect received packet @ " << seq;
}
}
++seq;
}
ASSERT_EQ(expected_seq_.end(), seq_it);
std::vector<int64_t> deltas = feedback_->GetReceiveDeltasUs();
ASSERT_EQ(expected_deltas_.size(), deltas.size());
for (size_t i = 0; i < expected_deltas_.size(); ++i)
EXPECT_EQ(expected_deltas_[i], deltas[i]) << "Delta mismatch @ " << i;
}
void GenerateDeltas(const uint16_t seq[],
const size_t length,
int64_t* deltas) {
uint16_t last_seq = seq[0];
int64_t offset = 0;
for (size_t i = 0; i < length; ++i) {
if (seq[i] < last_seq)
offset += 0x10000 * default_delta_;
last_seq = seq[i];
deltas[i] = offset + (last_seq * default_delta_);
}
}
std::vector<uint16_t> expected_seq_;
std::vector<int64_t> expected_deltas_;
size_t expected_size_;
int64_t default_delta_;
rtc::scoped_ptr<TransportFeedback> feedback_;
rtc::scoped_ptr<rtcp::RawPacket> serialized_;
};
TEST(RtcpPacketTest, TransportFeedback_OneBitVector) {
const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_FullOneBitVector) {
const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13, 14};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_OneBitVector_WrapReceived) {
const uint16_t kMax = 0xFFFF;
const uint16_t kReceived[] = {kMax - 2, kMax - 1, kMax, 0, 1, 2};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_OneBitVector_WrapMissing) {
const uint16_t kMax = 0xFFFF;
const uint16_t kReceived[] = {kMax - 2, kMax - 1, 1, 2};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_TwoBitVector) {
const uint16_t kReceived[] = {1, 2, 6, 7};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (kLength * kLargeDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithDefaultDelta(kDeltaLimit + TransportFeedback::kDeltaScaleFactor);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_TwoBitVectorFull) {
const uint16_t kReceived[] = {1, 2, 6, 7, 8};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + (2 * kStatusChunkSize) + (kLength * kLargeDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithDefaultDelta(kDeltaLimit + TransportFeedback::kDeltaScaleFactor);
test.WithInput(kReceived, nullptr, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_LargeAndNegativeDeltas) {
const uint16_t kReceived[] = {1, 2, 6, 7, 8};
const int64_t kReceiveTimes[] = {
2000,
1000,
4000,
3000,
3000 + TransportFeedback::kDeltaScaleFactor * (1 << 8)};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + (3 * kLargeDeltaSize) + kSmallDeltaSize;
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_MaxRle) {
// Expected chunks created:
// * 1-bit vector chunk (1xreceived + 13xdropped)
// * RLE chunk of max length for dropped symbol
// * 1-bit vector chunk (1xreceived + 13xdropped)
const size_t kPacketCount = (1 << 13) - 1 + 14;
const uint16_t kReceived[] = {0, kPacketCount};
const int64_t kReceiveTimes[] = {1000, 2000};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + (3 * kStatusChunkSize) + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_MinRle) {
// Expected chunks created:
// * 1-bit vector chunk (1xreceived + 13xdropped)
// * RLE chunk of length 15 for dropped symbol
// * 1-bit vector chunk (1xreceived + 13xdropped)
const uint16_t kReceived[] = {0, (14 * 2) + 1};
const int64_t kReceiveTimes[] = {1000, 2000};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + (3 * kStatusChunkSize) + (kLength * kSmallDeltaSize);
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_OneToTwoBitVector) {
const size_t kTwoBitVectorCapacity = 7;
const uint16_t kReceived[] = {0, kTwoBitVectorCapacity - 1};
const int64_t kReceiveTimes[] = {
0, kDeltaLimit + TransportFeedback::kDeltaScaleFactor};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + kSmallDeltaSize + kLargeDeltaSize;
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_OneToTwoBitVectorSimpleSplit) {
const size_t kTwoBitVectorCapacity = 7;
const uint16_t kReceived[] = {0, kTwoBitVectorCapacity};
const int64_t kReceiveTimes[] = {
0, kDeltaLimit + TransportFeedback::kDeltaScaleFactor};
const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
const size_t kExpectedSizeBytes =
kHeaderSize + (kStatusChunkSize * 2) + kSmallDeltaSize + kLargeDeltaSize;
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kLength);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_OneToTwoBitVectorSplit) {
// With received small delta = S, received large delta = L, use input
// SSSSSSSSLSSSSSSSSSSSS. This will cause a 1:2 split at the L.
// After split there will be two symbols in symbol_vec: SL.
const int64_t kLargeDelta = TransportFeedback::kDeltaScaleFactor * (1 << 8);
const size_t kNumPackets = (3 * 7) + 1;
const size_t kExpectedSizeBytes = kHeaderSize + (kStatusChunkSize * 3) +
(kSmallDeltaSize * (kNumPackets - 1)) +
(kLargeDeltaSize * 1);
uint16_t kReceived[kNumPackets];
for (size_t i = 0; i < kNumPackets; ++i)
kReceived[i] = i;
int64_t kReceiveTimes[kNumPackets];
kReceiveTimes[0] = 1000;
for (size_t i = 1; i < kNumPackets; ++i) {
int delta = (i == 8) ? kLargeDelta : 1000;
kReceiveTimes[i] = kReceiveTimes[i - 1] + delta;
}
FeedbackTester test;
test.WithExpectedSize(kExpectedSizeBytes);
test.WithInput(kReceived, kReceiveTimes, kNumPackets);
test.VerifyPacket();
}
TEST(RtcpPacketTest, TransportFeedback_Aliasing) {
TransportFeedback feedback;
feedback.WithBase(0, 0);
const int kSamples = 100;
const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3;
for (int i = 0; i < kSamples; ++i)
feedback.WithReceivedPacket(i, i * kTooSmallDelta);
feedback.Build();
std::vector<int64_t> deltas = feedback.GetReceiveDeltasUs();
int64_t accumulated_delta = 0;
int num_samples = 0;
for (int64_t delta : deltas) {
accumulated_delta += delta;
int64_t expected_time = num_samples * kTooSmallDelta;
++num_samples;
EXPECT_NEAR(expected_time, accumulated_delta,
TransportFeedback::kDeltaScaleFactor / 2);
}
}
TEST(RtcpPacketTest, TransportFeedback_Limits) {
// Sequence number wrap above 0x8000.
rtc::scoped_ptr<TransportFeedback> packet(new TransportFeedback());
packet->WithBase(0, 0);
EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
packet.reset(new TransportFeedback());
packet->WithBase(0, 0);
EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000));
// Packet status count max 0xFFFF.
packet.reset(new TransportFeedback());
packet->WithBase(0, 0);
EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
EXPECT_TRUE(packet->WithReceivedPacket(0xFFFF, 2000));
EXPECT_FALSE(packet->WithReceivedPacket(0, 3000));
// Too large delta.
packet.reset(new TransportFeedback());
packet->WithBase(0, 0);
int64_t kMaxPositiveTimeDelta = std::numeric_limits<int16_t>::max() *
TransportFeedback::kDeltaScaleFactor;
EXPECT_FALSE(packet->WithReceivedPacket(
1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor));
EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxPositiveTimeDelta));
// Too large negative delta.
packet.reset(new TransportFeedback());
packet->WithBase(0, 0);
int64_t kMaxNegativeTimeDelta = std::numeric_limits<int16_t>::min() *
TransportFeedback::kDeltaScaleFactor;
EXPECT_FALSE(packet->WithReceivedPacket(
1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor));
EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxNegativeTimeDelta));
// TODO(sprang): Once we support max length lower than RTCP length limit,
// add back test for max size in bytes.
}
TEST(RtcpPacketTest, TransportFeedback_Padding) {
const size_t kExpectedSizeBytes =
kHeaderSize + kStatusChunkSize + kSmallDeltaSize;
const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
TransportFeedback feedback;
feedback.WithBase(0, 0);
EXPECT_TRUE(feedback.WithReceivedPacket(0, 0));
rtc::scoped_ptr<rtcp::RawPacket> packet(feedback.Build());
EXPECT_EQ(kExpectedSizeWords * 4, packet->Length());
ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i)
EXPECT_EQ(0u, packet->Buffer()[i]);
// Modify packet by adding 4 bytes of padding at the end. Not currently used
// when we're sending, but need to be able to handle it when receiving.
const int kPaddingBytes = 4;
const size_t kExpectedSizeWithPadding =
(kExpectedSizeWords * 4) + kPaddingBytes;
uint8_t mod_buffer[kExpectedSizeWithPadding];
memcpy(mod_buffer, packet->Buffer(), kExpectedSizeWords * 4);
memset(&mod_buffer[kExpectedSizeWords * 4], 0, kPaddingBytes - 1);
mod_buffer[kExpectedSizeWithPadding - 1] = kPaddingBytes;
const uint8_t padding_flag = 1 << 5;
mod_buffer[0] |= padding_flag;
ByteWriter<uint16_t>::WriteBigEndian(
&mod_buffer[2], ByteReader<uint16_t>::ReadBigEndian(&mod_buffer[2]) +
((kPaddingBytes + 3) / 4));
rtc::scoped_ptr<TransportFeedback> parsed_packet(
TransportFeedback::ParseFrom(mod_buffer, kExpectedSizeWithPadding));
ASSERT_TRUE(parsed_packet.get() != nullptr);
EXPECT_EQ(kExpectedSizeWords * 4, packet->Length()); // Padding not included.
}
} // namespace
} // namespace webrtc

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

@ -1084,4 +1084,5 @@ TEST(RtcpPacketTest, XrWithTooManyBlocks) {
EXPECT_TRUE(xr.WithVoipMetric(&voip_metric));
EXPECT_FALSE(xr.WithVoipMetric(&voip_metric));
}
} // namespace webrtc