From a3b8769860bdb0a45dbff6d1e0092486fa59aaa4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Spr=C3=A5ng?= Date: Wed, 29 Jul 2015 10:46:54 +0200 Subject: [PATCH] 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} --- webrtc/modules/modules.gyp | 1 + webrtc/modules/rtp_rtcp/BUILD.gn | 2 + webrtc/modules/rtp_rtcp/rtp_rtcp.gypi | 2 + webrtc/modules/rtp_rtcp/source/rtcp_packet.cc | 167 ++-- webrtc/modules/rtp_rtcp/source/rtcp_packet.h | 19 +- .../source/rtcp_packet/transport_feedback.cc | 802 ++++++++++++++++++ .../source/rtcp_packet/transport_feedback.h | 104 +++ .../transport_feedback_unittest.cc | 434 ++++++++++ .../rtp_rtcp/source/rtcp_packet_unittest.cc | 1 + 9 files changed, 1442 insertions(+), 90 deletions(-) create mode 100644 webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc create mode 100644 webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h create mode 100644 webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc diff --git a/webrtc/modules/modules.gyp b/webrtc/modules/modules.gyp index 232ba319e2..7774da8209 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 48c4921ca5..b83faae8d6 100644 --- a/webrtc/modules/rtp_rtcp/BUILD.gn +++ b/webrtc/modules/rtp_rtcp/BUILD.gn @@ -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", diff --git a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi index 2846ed666b..a927bd0046 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 7038532f2e..8cb6fb0833 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc @@ -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& blocks, void CreateIj(const std::vector& ij_items, uint8_t* buffer, size_t* pos) { - size_t length = ij_items.size(); - CreateHeader(length, PT_IJ, length, buffer, pos); - for (std::vector::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& ij_items, // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ void CreateSdes(const std::vector& 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::const_iterator it = chunks.begin(); it != chunks.end(); ++it) { @@ -286,10 +248,8 @@ void CreateSdes(const std::vector& chunks, void CreateBye(const RTCPPacketBYE& bye, const std::vector& 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& 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& 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); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h index d212497edd..c5432de9d6 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h @@ -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 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_; 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 0000000000..b426887d06 --- /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* 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* 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* 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* 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* 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* 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(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(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(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(base_time_ & 0x00FFFFFF); +} + +int64_t TransportFeedback::GetBaseTimeUs() const { + return GetBaseTime() * kBaseScaleFactor; +} + +std::vector +TransportFeedback::GetStatusVector() const { + std::vector 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 TransportFeedback::GetReceiveDeltas() const { + return receive_deltas_; +} + +std::vector TransportFeedback::GetReceiveDeltasUs() const { + if (receive_deltas_.empty()) + return std::vector(); + + std::vector us_deltas; + for (int16_t delta : receive_deltas_) + us_deltas.push_back(static_cast(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::WriteBigEndian(&packet[*position], packet_sender_ssrc_); + *position += 4; + ByteWriter::WriteBigEndian(&packet[*position], media_source_ssrc_); + *position += 4; + + DCHECK_LE(base_seq_, 0xFFFF); + ByteWriter::WriteBigEndian(&packet[*position], base_seq_); + *position += 2; + + int64_t status_count = last_seq_ - base_seq_ + 1; + DCHECK_LE(status_count, 0xFFFF); + ByteWriter::WriteBigEndian(&packet[*position], status_count); + *position += 2; + + ByteWriter::WriteBigEndian(&packet[*position], + static_cast(base_time_)); + *position += 3; + + packet[(*position)++] = feedback_seq_; + + // TODO(sprang): Get rid of this cast. + const_cast(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::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::ParseFrom( + const uint8_t* buffer, + size_t length) { + rtc::scoped_ptr 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::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::ReadBigEndian(&buffer[4]); + packet->media_source_ssrc_ = ByteReader::ReadBigEndian(&buffer[8]); + packet->base_seq_ = ByteReader::ReadBigEndian(&buffer[12]); + uint16_t num_packets = ByteReader::ReadBigEndian(&buffer[14]); + packet->base_time_ = ByteReader::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 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::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 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 0000000000..6e51fb88b6 --- /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 +#include + +#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 GetStatusVector() const; + std::vector 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 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 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 status_chunks_; + std::vector receive_deltas_; + + int64_t last_seq_; + int64_t last_timestamp_; + std::deque 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 0000000000..6a26d1cfad --- /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 + +#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 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(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 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 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 expected_seq_; + std::vector expected_deltas_; + size_t expected_size_; + int64_t default_delta_; + rtc::scoped_ptr feedback_; + rtc::scoped_ptr 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 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 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::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::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 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::WriteBigEndian( + &mod_buffer[2], ByteReader::ReadBigEndian(&mod_buffer[2]) + + ((kPaddingBytes + 3) / 4)); + + rtc::scoped_ptr 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 0097159644..77520b633b 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 @@ TEST(RtcpPacketTest, XrWithTooManyBlocks) { EXPECT_TRUE(xr.WithVoipMetric(&voip_metric)); EXPECT_FALSE(xr.WithVoipMetric(&voip_metric)); } + } // namespace webrtc