diff options
author | danilchap <danilchap@webrtc.org> | 2015-12-22 03:43:04 -0800 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2015-12-22 11:43:10 +0000 |
commit | a8890a57a5d03f942924ff61d3c62244f2bdab10 (patch) | |
tree | 26a95acccd9364b36c62b73450ac1d18fd7e6855 /webrtc/modules | |
parent | 53c317c4b9c8923c642f03b0762a0e2eb9e2bed0 (diff) | |
download | webrtc-a8890a57a5d03f942924ff61d3c62244f2bdab10.tar.gz |
rtcp::Nack packet moved into own file and got Parse function
Review URL: https://codereview.webrtc.org/1461623003
Cr-Commit-Position: refs/heads/master@{#11111}
Diffstat (limited to 'webrtc/modules')
-rw-r--r-- | webrtc/modules/modules.gyp | 1 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/BUILD.gn | 4 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/rtp_rtcp.gypi | 4 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet.cc | 84 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet.h | 40 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc | 163 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h | 63 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc | 190 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc | 45 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h | 48 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc | 99 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtcp_sender.cc | 1 | ||||
-rw-r--r-- | webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc | 1 |
13 files changed, 520 insertions, 223 deletions
diff --git a/webrtc/modules/modules.gyp b/webrtc/modules/modules.gyp index 06a8822f39..d1fcebbffc 100644 --- a/webrtc/modules/modules.gyp +++ b/webrtc/modules/modules.gyp @@ -308,6 +308,7 @@ 'rtp_rtcp/source/rtcp_packet/bye_unittest.cc', 'rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc', 'rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc', + 'rtp_rtcp/source/rtcp_packet/nack_unittest.cc', 'rtp_rtcp/source/rtcp_packet/pli_unittest.cc', 'rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc', 'rtp_rtcp/source/rtcp_packet/report_block_unittest.cc', diff --git a/webrtc/modules/rtp_rtcp/BUILD.gn b/webrtc/modules/rtp_rtcp/BUILD.gn index aa2e9c5800..41d3014f28 100644 --- a/webrtc/modules/rtp_rtcp/BUILD.gn +++ b/webrtc/modules/rtp_rtcp/BUILD.gn @@ -54,6 +54,8 @@ source_set("rtp_rtcp") { "source/rtcp_packet/dlrr.h", "source/rtcp_packet/extended_jitter_report.cc", "source/rtcp_packet/extended_jitter_report.h", + "source/rtcp_packet/nack.cc", + "source/rtcp_packet/nack.h", "source/rtcp_packet/pli.cc", "source/rtcp_packet/pli.h", "source/rtcp_packet/psfb.cc", @@ -64,6 +66,8 @@ source_set("rtp_rtcp") { "source/rtcp_packet/report_block.h", "source/rtcp_packet/rrtr.cc", "source/rtcp_packet/rrtr.h", + "source/rtcp_packet/rtpfb.cc", + "source/rtcp_packet/rtpfb.h", "source/rtcp_packet/transport_feedback.cc", "source/rtcp_packet/transport_feedback.h", "source/rtcp_packet/voip_metric.cc", diff --git a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi index 98b2659c94..3419d7fcd3 100644 --- a/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi +++ b/webrtc/modules/rtp_rtcp/rtp_rtcp.gypi @@ -49,6 +49,8 @@ 'source/rtcp_packet/dlrr.h', 'source/rtcp_packet/extended_jitter_report.cc', 'source/rtcp_packet/extended_jitter_report.h', + 'source/rtcp_packet/nack.cc', + 'source/rtcp_packet/nack.h', 'source/rtcp_packet/pli.cc', 'source/rtcp_packet/pli.h', 'source/rtcp_packet/psfb.cc', @@ -59,6 +61,8 @@ 'source/rtcp_packet/report_block.h', 'source/rtcp_packet/rrtr.cc', 'source/rtcp_packet/rrtr.h', + 'source/rtcp_packet/rtpfb.cc', + 'source/rtcp_packet/rtpfb.h', 'source/rtcp_packet/transport_feedback.cc', 'source/rtcp_packet/transport_feedback.h', 'source/rtcp_packet/voip_metric.cc', diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc index 1508658f5d..7a9fb9b5fd 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.cc @@ -209,31 +209,6 @@ void CreateSli(const RTCPPacketPSFBSLI& sli, AssignUWord8(buffer, pos, (sli_item.NumberOfMB << 6) + sli_item.PictureId); } -// Generic NACK (RFC 4585). -// -// FCI: -// -// 0 1 2 3 -// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ -// | PID | BLP | -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - -void CreateNack(const RTCPPacketRTPFBNACK& nack, - const std::vector<RTCPPacketRTPFBNACKItem>& nack_fields, - size_t start_index, - size_t end_index, - uint8_t* buffer, - size_t* pos) { - AssignUWord32(buffer, pos, nack.SenderSSRC); - AssignUWord32(buffer, pos, nack.MediaSSRC); - for (size_t i = start_index; i < end_index; ++i) { - const RTCPPacketRTPFBNACKItem& nack_item = nack_fields[i]; - AssignUWord16(buffer, pos, nack_item.PacketID); - AssignUWord16(buffer, pos, nack_item.BitMask); - } -} - // Reference picture selection indication (RPSI) (RFC 4585). // // FCI: @@ -597,65 +572,6 @@ bool Sli::Create(uint8_t* packet, return true; } -bool Nack::Create(uint8_t* packet, - size_t* index, - size_t max_length, - RtcpPacket::PacketReadyCallback* callback) const { - assert(!nack_fields_.empty()); - // If nack list can't fit in packet, try to fragment. - size_t nack_index = 0; - do { - size_t bytes_left_in_buffer = max_length - *index; - if (bytes_left_in_buffer < kCommonFbFmtLength + 4) { - if (!OnBufferFull(packet, index, callback)) - return false; - continue; - } - int64_t num_nack_fields = - std::min((bytes_left_in_buffer - kCommonFbFmtLength) / 4, - nack_fields_.size() - nack_index); - - const uint8_t kFmt = 1; - size_t size_bytes = (num_nack_fields * 4) + kCommonFbFmtLength; - size_t header_length = ((size_bytes + 3) / 4) - 1; // As 32bit words - 1 - CreateHeader(kFmt, PT_RTPFB, header_length, packet, index); - CreateNack(nack_, nack_fields_, nack_index, nack_index + num_nack_fields, - packet, index); - - nack_index += num_nack_fields; - } while (nack_index < nack_fields_.size()); - - return true; -} - -size_t Nack::BlockLength() const { - return (nack_fields_.size() * 4) + kCommonFbFmtLength; -} - -void Nack::WithList(const uint16_t* nack_list, int length) { - assert(nack_list); - assert(nack_fields_.empty()); - int i = 0; - while (i < length) { - uint16_t pid = nack_list[i++]; - // Bitmask specifies losses in any of the 16 packets following the pid. - uint16_t bitmask = 0; - while (i < length) { - int shift = static_cast<uint16_t>(nack_list[i] - pid) - 1; - if (shift >= 0 && shift <= 15) { - bitmask |= (1 << shift); - ++i; - } else { - break; - } - } - RTCPUtility::RTCPPacketRTPFBNACKItem item; - item.PacketID = pid; - item.BitMask = bitmask; - nack_fields_.push_back(item); - } -} - bool Rpsi::Create(uint8_t* packet, size_t* index, size_t max_length, diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h index 3adcc9a759..5aa3340d00 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet.h @@ -327,46 +327,6 @@ class Sli : public RtcpPacket { RTC_DISALLOW_COPY_AND_ASSIGN(Sli); }; -// Generic NACK (RFC 4585). -// -// FCI: -// 0 1 2 3 -// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ -// | PID | BLP | -// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - -class Nack : public RtcpPacket { - public: - Nack() : RtcpPacket() { - memset(&nack_, 0, sizeof(nack_)); - } - - virtual ~Nack() {} - - void From(uint32_t ssrc) { - nack_.SenderSSRC = ssrc; - } - void To(uint32_t ssrc) { - nack_.MediaSSRC = ssrc; - } - void WithList(const uint16_t* nack_list, int length); - - protected: - bool Create(uint8_t* packet, - size_t* index, - size_t max_length, - RtcpPacket::PacketReadyCallback* callback) const override; - - size_t BlockLength() const override; - - private: - RTCPUtility::RTCPPacketRTPFBNACK nack_; - std::vector<RTCPUtility::RTCPPacketRTPFBNACKItem> nack_fields_; - - RTC_DISALLOW_COPY_AND_ASSIGN(Nack); -}; - // Reference picture selection indication (RPSI) (RFC 4585). // // FCI: diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc new file mode 100644 index 0000000000..8b9b354a06 --- /dev/null +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" + +#include <algorithm> + +#include "webrtc/base/checks.h" +#include "webrtc/base/logging.h" +#include "webrtc/modules/rtp_rtcp/source/byte_io.h" + +using webrtc::RTCPUtility::RtcpCommonHeader; + +namespace webrtc { +namespace rtcp { + +// RFC 4585: Feedback format. +// +// Common packet format: +// +// 0 1 2 3 +// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// |V=2|P| FMT | PT | length | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// 0 | SSRC of packet sender | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// 4 | SSRC of media source | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// : Feedback Control Information (FCI) : +// : : +// +// Generic NACK (RFC 4585). +// +// FCI: +// 0 1 2 3 +// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// | PID | BLP | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +bool Nack::Parse(const RtcpCommonHeader& header, const uint8_t* payload) { + RTC_DCHECK(header.packet_type == kPacketType); + RTC_DCHECK(header.count_or_format == kFeedbackMessageType); + + if (header.payload_size_bytes < kCommonFeedbackLength + kNackItemLength) { + LOG(LS_WARNING) << "Payload length " << header.payload_size_bytes + << " is too small for a Nack."; + return false; + } + size_t nack_items = + (header.payload_size_bytes - kCommonFeedbackLength) / kNackItemLength; + + ParseCommonFeedback(payload); + const uint8_t* next_nack = payload + kCommonFeedbackLength; + + packet_ids_.clear(); + packed_.resize(nack_items); + for (size_t index = 0; index < nack_items; ++index) { + packed_[index].first_pid = ByteReader<uint16_t>::ReadBigEndian(next_nack); + packed_[index].bitmask = ByteReader<uint16_t>::ReadBigEndian(next_nack + 2); + next_nack += kNackItemLength; + } + Unpack(); + + return true; +} + +bool Nack::Create(uint8_t* packet, + size_t* index, + size_t max_length, + RtcpPacket::PacketReadyCallback* callback) const { + RTC_DCHECK(!packed_.empty()); + // If nack list can't fit in packet, try to fragment. + size_t nack_index = 0; + const size_t kCommonFbFmtLength = kHeaderLength + kCommonFeedbackLength; + do { + size_t bytes_left_in_buffer = max_length - *index; + if (bytes_left_in_buffer < kCommonFbFmtLength + kNackItemLength) { + if (!OnBufferFull(packet, index, callback)) + return false; + continue; + } + size_t num_nack_fields = + std::min((bytes_left_in_buffer - kCommonFbFmtLength) / kNackItemLength, + packed_.size() - nack_index); + + size_t size_bytes = + (num_nack_fields * kNackItemLength) + kCommonFbFmtLength; + size_t header_length = ((size_bytes + 3) / 4) - 1; // As 32bit words - 1 + CreateHeader(kFeedbackMessageType, kPacketType, header_length, packet, + index); + CreateCommonFeedback(packet + *index); + *index += kCommonFeedbackLength; + size_t end_index = nack_index + num_nack_fields; + for (; nack_index < end_index; ++nack_index) { + const auto& item = packed_[nack_index]; + ByteWriter<uint16_t>::WriteBigEndian(packet + *index + 0, item.first_pid); + ByteWriter<uint16_t>::WriteBigEndian(packet + *index + 2, item.bitmask); + *index += kNackItemLength; + } + RTC_DCHECK_LE(*index, max_length); + } while (nack_index < packed_.size()); + + return true; +} + +size_t Nack::BlockLength() const { + return (packed_.size() * kNackItemLength) + kCommonFeedbackLength + + kHeaderLength; +} + +void Nack::WithList(const uint16_t* nack_list, size_t length) { + RTC_DCHECK(nack_list); + RTC_DCHECK(packet_ids_.empty()); + RTC_DCHECK(packed_.empty()); + packet_ids_.assign(nack_list, nack_list + length); + Pack(); +} + +void Nack::Pack() { + RTC_DCHECK(!packet_ids_.empty()); + RTC_DCHECK(packed_.empty()); + auto it = packet_ids_.begin(); + const auto end = packet_ids_.end(); + while (it != end) { + PackedNack item; + item.first_pid = *it++; + // Bitmask specifies losses in any of the 16 packets following the pid. + item.bitmask = 0; + while (it != end) { + uint16_t shift = static_cast<uint16_t>(*it - item.first_pid - 1); + if (shift <= 15) { + item.bitmask |= (1 << shift); + ++it; + } else { + break; + } + } + packed_.push_back(item); + } +} + +void Nack::Unpack() { + RTC_DCHECK(packet_ids_.empty()); + RTC_DCHECK(!packed_.empty()); + for (const PackedNack& item : packed_) { + packet_ids_.push_back(item.first_pid); + uint16_t pid = item.first_pid + 1; + for (uint16_t bitmask = item.bitmask; bitmask != 0; bitmask >>= 1, ++pid) + if (bitmask & 1) + packet_ids_.push_back(pid); + } +} + +} // namespace rtcp +} // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h new file mode 100644 index 0000000000..fb2be113a2 --- /dev/null +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_ +#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_ + +#include <vector> + +#include "webrtc/base/basictypes.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" + +namespace webrtc { +namespace rtcp { + +class Nack : public Rtpfb { + public: + const uint8_t kFeedbackMessageType = 1; + Nack() {} + + virtual ~Nack() {} + + // Parse assumes header is already parsed and validated. + bool Parse(const RTCPUtility::RtcpCommonHeader& header, + const uint8_t* payload); // Size of the payload is in the header. + + void WithList(const uint16_t* nack_list, size_t length); + const std::vector<uint16_t>& packet_ids() const { return packet_ids_; } + + protected: + bool Create(uint8_t* packet, + size_t* index, + size_t max_length, + RtcpPacket::PacketReadyCallback* callback) const override; + + size_t BlockLength() const override; + + private: + const size_t kNackItemLength = 4; + struct PackedNack { + uint16_t first_pid; + uint16_t bitmask; + }; + + void Pack(); // Fills packed_ using packed_ids_. (used in WithList). + void Unpack(); // Fills packet_ids_ using packed_. (used in Parse). + + std::vector<PackedNack> packed_; + std::vector<uint16_t> packet_ids_; + + RTC_DISALLOW_COPY_AND_ASSIGN(Nack); +}; + +} // namespace rtcp +} // namespace webrtc +#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_NACK_H_ diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc new file mode 100644 index 0000000000..01e30f5644 --- /dev/null +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" + +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +using ::testing::_; +using ::testing::ElementsAreArray; +using ::testing::Invoke; +using ::testing::UnorderedElementsAreArray; + +using webrtc::rtcp::Nack; +using webrtc::rtcp::RawPacket; +using webrtc::RTCPUtility::RtcpCommonHeader; +using webrtc::RTCPUtility::RtcpParseCommonHeader; + +namespace webrtc { +namespace { + +const uint32_t kSenderSsrc = 0x12345678; +const uint32_t kRemoteSsrc = 0x23456789; + +const uint16_t kList[] = {0, 1, 3, 8, 16}; +const size_t kListLength = sizeof(kList) / sizeof(kList[0]); +const uint8_t kPacket[] = {0x81, 205, 0x00, 0x03, 0x12, 0x34, 0x56, 0x78, + 0x23, 0x45, 0x67, 0x89, 0x00, 0x00, 0x80, 0x85}; +const size_t kPacketLength = sizeof(kPacket); + +const uint16_t kWrapList[] = {0xffdc, 0xffec, 0xfffe, 0xffff, 0x0000, + 0x0001, 0x0003, 0x0014, 0x0064}; +const size_t kWrapListLength = sizeof(kWrapList) / sizeof(kWrapList[0]); +const uint8_t kWrapPacket[] = {0x81, 205, 0x00, 0x06, 0x12, 0x34, 0x56, 0x78, + 0x23, 0x45, 0x67, 0x89, 0xff, 0xdc, 0x80, 0x00, + 0xff, 0xfe, 0x00, 0x17, 0x00, 0x14, 0x00, 0x00, + 0x00, 0x64, 0x00, 0x00}; +const size_t kWrapPacketLength = sizeof(kWrapPacket); + +TEST(RtcpPacketNackTest, Create) { + Nack nack; + nack.From(kSenderSsrc); + nack.To(kRemoteSsrc); + nack.WithList(kList, kListLength); + + rtc::scoped_ptr<RawPacket> packet = nack.Build(); + + EXPECT_EQ(kPacketLength, packet->Length()); + EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength)); +} + +TEST(RtcpPacketNackTest, Parse) { + RtcpCommonHeader header; + EXPECT_TRUE(RtcpParseCommonHeader(kPacket, kPacketLength, &header)); + EXPECT_EQ(kPacketLength, header.BlockSize()); + Nack parsed; + + EXPECT_TRUE( + parsed.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes)); + const Nack& const_parsed = parsed; + + EXPECT_EQ(kSenderSsrc, const_parsed.sender_ssrc()); + EXPECT_EQ(kRemoteSsrc, const_parsed.media_ssrc()); + EXPECT_THAT(const_parsed.packet_ids(), ElementsAreArray(kList)); +} + +TEST(RtcpPacketNackTest, CreateWrap) { + Nack nack; + nack.From(kSenderSsrc); + nack.To(kRemoteSsrc); + nack.WithList(kWrapList, kWrapListLength); + + rtc::scoped_ptr<RawPacket> packet = nack.Build(); + + EXPECT_EQ(kWrapPacketLength, packet->Length()); + EXPECT_EQ(0, memcmp(kWrapPacket, packet->Buffer(), kWrapPacketLength)); +} + +TEST(RtcpPacketNackTest, ParseWrap) { + RtcpCommonHeader header; + EXPECT_TRUE(RtcpParseCommonHeader(kWrapPacket, kWrapPacketLength, &header)); + EXPECT_EQ(kWrapPacketLength, header.BlockSize()); + + Nack parsed; + EXPECT_TRUE( + parsed.Parse(header, kWrapPacket + RtcpCommonHeader::kHeaderSizeBytes)); + + EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); + EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); + EXPECT_THAT(parsed.packet_ids(), ElementsAreArray(kWrapList)); +} + +TEST(RtcpPacketNackTest, BadOrder) { + // Does not guarantee optimal packing, but should guarantee correctness. + const uint16_t kUnorderedList[] = {1, 25, 13, 12, 9, 27, 29}; + const size_t kUnorderedListLength = + sizeof(kUnorderedList) / sizeof(kUnorderedList[0]); + Nack nack; + nack.From(kSenderSsrc); + nack.To(kRemoteSsrc); + nack.WithList(kUnorderedList, kUnorderedListLength); + + rtc::scoped_ptr<RawPacket> packet = nack.Build(); + + Nack parsed; + RtcpCommonHeader header; + EXPECT_TRUE( + RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header)); + EXPECT_TRUE(parsed.Parse( + header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes)); + + EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); + EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); + EXPECT_THAT(parsed.packet_ids(), UnorderedElementsAreArray(kUnorderedList)); +} + +TEST(RtcpPacketNackTest, CreateFragmented) { + Nack nack; + const uint16_t kList[] = {1, 100, 200, 300, 400}; + const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); + nack.From(kSenderSsrc); + nack.To(kRemoteSsrc); + nack.WithList(kList, kListLength); + + class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback { + public: + MOCK_METHOD2(OnPacketReady, void(uint8_t*, size_t)); + } verifier; + + class NackVerifier { + public: + explicit NackVerifier(std::vector<uint16_t> ids) : ids_(ids) {} + void operator()(uint8_t* data, size_t length) { + RtcpCommonHeader header; + EXPECT_TRUE(RtcpParseCommonHeader(data, length, &header)); + EXPECT_EQ(length, header.BlockSize()); + Nack nack; + EXPECT_TRUE( + nack.Parse(header, data + RtcpCommonHeader::kHeaderSizeBytes)); + EXPECT_EQ(kSenderSsrc, nack.sender_ssrc()); + EXPECT_EQ(kRemoteSsrc, nack.media_ssrc()); + EXPECT_THAT(nack.packet_ids(), ElementsAreArray(ids_)); + } + std::vector<uint16_t> ids_; + } packet1({1, 100, 200}), packet2({300, 400}); + + EXPECT_CALL(verifier, OnPacketReady(_, _)) + .WillOnce(Invoke(packet1)) + .WillOnce(Invoke(packet2)); + const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items + uint8_t buffer[kBufferSize]; + EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier)); +} + +TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) { + const uint16_t kList[] = {1}; + const size_t kMinNackBlockSize = 16; + Nack nack; + nack.From(kSenderSsrc); + nack.To(kRemoteSsrc); + nack.WithList(kList, 1); + class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { + public: + void OnPacketReady(uint8_t* data, size_t length) override { + ADD_FAILURE() << "Buffer should be too small."; + } + } verifier; + uint8_t buffer[kMinNackBlockSize - 1]; + EXPECT_FALSE( + nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier)); +} + +TEST(RtcpPacketNackTest, ParseFailsWithTooSmallBuffer) { + RtcpCommonHeader header; + EXPECT_TRUE(RtcpParseCommonHeader(kPacket, kPacketLength, &header)); + header.payload_size_bytes--; // Damage the packet + Nack parsed; + EXPECT_FALSE( + parsed.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes)); +} + +} // namespace +} // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc new file mode 100644 index 0000000000..b5571d45a3 --- /dev/null +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.cc @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h" + +#include "webrtc/modules/rtp_rtcp/source/byte_io.h" + +namespace webrtc { +namespace rtcp { + +// RFC 4585, Section 6.1: Feedback format. +// +// Common packet format: +// +// 0 1 2 3 +// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// |V=2|P| FMT | PT | length | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// 0 | SSRC of packet sender | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// 4 | SSRC of media source | +// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +// : Feedback Control Information (FCI) : +// : : + +void Rtpfb::ParseCommonFeedback(const uint8_t* payload) { + sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[0]); + media_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&payload[4]); +} + +void Rtpfb::CreateCommonFeedback(uint8_t* payload) const { + ByteWriter<uint32_t>::WriteBigEndian(&payload[0], sender_ssrc_); + ByteWriter<uint32_t>::WriteBigEndian(&payload[4], media_ssrc_); +} + +} // namespace rtcp +} // namespace webrtc diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h new file mode 100644 index 0000000000..801aa085c4 --- /dev/null +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + * + */ + +#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_ +#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_ + +#include "webrtc/base/basictypes.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" + +namespace webrtc { +namespace rtcp { + +// RTPFB: Transport layer feedback message. +// RFC4585, Section 6.2 +class Rtpfb : public RtcpPacket { + public: + static const uint8_t kPacketType = 205; + + Rtpfb() : sender_ssrc_(0), media_ssrc_(0) {} + virtual ~Rtpfb() {} + + void From(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void To(uint32_t ssrc) { media_ssrc_ = ssrc; } + + uint32_t sender_ssrc() const { return sender_ssrc_; } + uint32_t media_ssrc() const { return media_ssrc_; } + + protected: + static const size_t kCommonFeedbackLength = 8; + void ParseCommonFeedback(const uint8_t* payload); + void CreateCommonFeedback(uint8_t* payload) const; + + private: + uint32_t sender_ssrc_; + uint32_t media_ssrc_; +}; + +} // namespace rtcp +} // namespace webrtc +#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_ diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc index 008bc63ef7..78b0523d8d 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc @@ -26,7 +26,6 @@ using webrtc::rtcp::Bye; using webrtc::rtcp::Dlrr; using webrtc::rtcp::Empty; using webrtc::rtcp::Fir; -using webrtc::rtcp::Nack; using webrtc::rtcp::RawPacket; using webrtc::rtcp::ReceiverReport; using webrtc::rtcp::Remb; @@ -243,104 +242,6 @@ TEST(RtcpPacketTest, Sli) { EXPECT_EQ(kPictureId, parser.sli_item()->PictureId()); } -TEST(RtcpPacketTest, Nack) { - Nack nack; - const uint16_t kList[] = {0, 1, 3, 8, 16}; - const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, kListLength); - rtc::scoped_ptr<RawPacket> packet(nack.Build()); - RtcpPacketParser parser; - parser.Parse(packet->Buffer(), packet->Length()); - EXPECT_EQ(1, parser.nack()->num_packets()); - EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc()); - EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc()); - EXPECT_EQ(1, parser.nack_item()->num_packets()); - std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list(); - EXPECT_EQ(kListLength, seqs.size()); - for (size_t i = 0; i < kListLength; ++i) { - EXPECT_EQ(kList[i], seqs[i]); - } -} - -TEST(RtcpPacketTest, NackWithWrap) { - Nack nack; - const uint16_t kList[] = {65500, 65516, 65534, 65535, 0, 1, 3, 20, 100}; - const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, kListLength); - rtc::scoped_ptr<RawPacket> packet(nack.Build()); - RtcpPacketParser parser; - parser.Parse(packet->Buffer(), packet->Length()); - EXPECT_EQ(1, parser.nack()->num_packets()); - EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc()); - EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc()); - EXPECT_EQ(4, parser.nack_item()->num_packets()); - std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list(); - EXPECT_EQ(kListLength, seqs.size()); - for (size_t i = 0; i < kListLength; ++i) { - EXPECT_EQ(kList[i], seqs[i]); - } -} - -TEST(RtcpPacketTest, NackFragmented) { - Nack nack; - const uint16_t kList[] = {1, 100, 200, 300, 400}; - const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]); - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, kListLength); - - class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { - public: - void OnPacketReady(uint8_t* data, size_t length) override { - ++packets_created_; - RtcpPacketParser parser; - parser.Parse(data, length); - EXPECT_EQ(1, parser.nack()->num_packets()); - EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc()); - EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc()); - switch (packets_created_) { - case 1: - EXPECT_THAT(parser.nack_item()->last_nack_list(), - ElementsAre(1, 100, 200)); - break; - case 2: - EXPECT_THAT(parser.nack_item()->last_nack_list(), - ElementsAre(300, 400)); - break; - default: - ADD_FAILURE() << "Unexpected packet count: " << packets_created_; - } - } - int packets_created_ = 0; - } verifier; - const size_t kBufferSize = 12 + (3 * 4); // Fits common header + 3 nack items - uint8_t buffer[kBufferSize]; - EXPECT_TRUE(nack.BuildExternalBuffer(buffer, kBufferSize, &verifier)); - EXPECT_EQ(2, verifier.packets_created_); -} - -TEST(RtcpPacketTest, NackWithTooSmallBuffer) { - const uint16_t kList[] = {1}; - const size_t kMinNackBlockSize = 16; - Nack nack; - nack.From(kSenderSsrc); - nack.To(kRemoteSsrc); - nack.WithList(kList, 1); - class Verifier : public rtcp::RtcpPacket::PacketReadyCallback { - public: - void OnPacketReady(uint8_t* data, size_t length) override { - ADD_FAILURE() << "Buffer should be too small."; - } - } verifier; - uint8_t buffer[kMinNackBlockSize - 1]; - EXPECT_FALSE( - nack.BuildExternalBuffer(buffer, kMinNackBlockSize - 1, &verifier)); -} - TEST(RtcpPacketTest, Rpsi) { Rpsi rpsi; // 1000001 (7 bits = 1 byte in native string). diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc index ab3e0ef4eb..c29ab85eb2 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc @@ -24,6 +24,7 @@ #include "webrtc/modules/rtp_rtcp/source/byte_io.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index 405a78d8c5..8329f603f9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -18,6 +18,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" #include "webrtc/system_wrappers/include/scoped_vector.h" #include "webrtc/test/rtcp_packet_parser.h" |