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}

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',

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",

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',

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,

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:

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

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_

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

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

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_

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).

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"

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"