Add packetization and coding/decoding of feedback message format.
BUG=webrtc:4312
R=stefan@webrtc.org
Review URL: https://codereview.webrtc.org/1175263002 .
Cr-Commit-Position: refs/heads/master@{#9651}
diff --git a/webrtc/modules/modules.gyp b/webrtc/modules/modules.gyp
index 232ba31..7774da8 100644
--- a/webrtc/modules/modules.gyp
+++ b/webrtc/modules/modules.gyp
@@ -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',
diff --git a/webrtc/modules/rtp_rtcp/BUILD.gn b/webrtc/modules/rtp_rtcp/BUILD.gn
index 48c4921..b83faae 100644
--- a/webrtc/modules/rtp_rtcp/BUILD.gn
+++ b/webrtc/modules/rtp_rtcp/BUILD.gn
@@ -44,6 +44,8 @@
"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",
diff --git a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
index 2846ed6..a927bd0 100644
--- a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
+++ b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi
@@ -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',
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
index 7038532..8cb6fb0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc
@@ -92,34 +92,6 @@
*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 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 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 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 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 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 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 @@
// 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 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 @@
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 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 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 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 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 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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
index d212497..c5432de 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h
@@ -92,18 +92,27 @@
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 @@
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 @@
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
+ size_t BlockLength() const override;
+
private:
DISALLOW_COPY_AND_ASSIGN(Empty);
};
@@ -651,6 +664,8 @@
size_t max_length,
RtcpPacket::PacketReadyCallback* callback) const override;
+ size_t BlockLength() const override;
+
private:
RTCPUtility::RTCPPacketRTPFBNACK nack_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
new file mode 100644
index 0000000..b426887
--- /dev/null
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
@@ -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
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
new file mode 100644
index 0000000..6e51fb8
--- /dev/null
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
@@ -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_
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc
new file mode 100644
index 0000000..6a26d1c
--- /dev/null
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc
@@ -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
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
index 0097159..77520b6 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
@@ -1084,4 +1084,5 @@
EXPECT_TRUE(xr.WithVoipMetric(&voip_metric));
EXPECT_FALSE(xr.WithVoipMetric(&voip_metric));
}
+
} // namespace webrtc
