Add NACK and RPSI packet types to RTCP packet builder.

Fixes bug found when parsing received RPSI packet.

BUG=2450
R=mflodman@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/17419004

git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@6194 4adac7df-926f-26a2-2b94-8c16560cd09d

2 files changed, 137 insertions, 82 deletions

diff --git a/test/rtcp_packet_parser.cc b/test/rtcp_packet_parser.cc
index 2e5880e2..9ae8543d 100644
--- a/test/rtcp_packet_parser.cc
+++ b/test/rtcp_packet_parser.cc
@@ -23,25 +23,54 @@ void RtcpPacketParser::Parse(const void *data, int len) {
   for (RTCPUtility::RTCPPacketTypes type = parser.Begin();
       type != RTCPUtility::kRtcpNotValidCode;
       type = parser.Iterate()) {
-    if (type == RTCPUtility::kRtcpSrCode) {
-      sender_report_.Set(parser.Packet().SR);
-    } else if (type == RTCPUtility::kRtcpRrCode) {
-      receiver_report_.Set(parser.Packet().RR);
-    } else if (type == RTCPUtility::kRtcpByeCode) {
-      bye_.Set(parser.Packet().BYE);
-    } else if (type == RTCPUtility::kRtcpReportBlockItemCode) {
-      report_block_.Set(parser.Packet().ReportBlockItem);
-      ++report_blocks_per_ssrc_[parser.Packet().ReportBlockItem.SSRC];
-    } else if (type == RTCPUtility::kRtcpPsfbFirCode) {
-      fir_.Set(parser.Packet().FIR);
-    } else if (type == webrtc::RTCPUtility::kRtcpPsfbFirItemCode) {
-      fir_item_.Set(parser.Packet().FIRItem);
-    } else if (type == RTCPUtility::kRtcpRtpfbNackCode) {
-      nack_.Set(parser.Packet().NACK);
-    } else if (type == RTCPUtility::kRtcpRtpfbNackItemCode) {
-      nack_item_.Set(parser.Packet().NACKItem);
+    switch (type) {
+      case RTCPUtility::kRtcpSrCode:
+        sender_report_.Set(parser.Packet().SR);
+        break;
+      case RTCPUtility::kRtcpRrCode:
+        receiver_report_.Set(parser.Packet().RR);
+        break;
+      case RTCPUtility::kRtcpByeCode:
+        bye_.Set(parser.Packet().BYE);
+        break;
+      case RTCPUtility::kRtcpReportBlockItemCode:
+        report_block_.Set(parser.Packet().ReportBlockItem);
+        ++report_blocks_per_ssrc_[parser.Packet().ReportBlockItem.SSRC];
+        break;
+      case RTCPUtility::kRtcpPsfbRpsiCode:
+        rpsi_.Set(parser.Packet().RPSI);
+        break;
+      case RTCPUtility::kRtcpPsfbFirCode:
+        fir_.Set(parser.Packet().FIR);
+        break;
+      case RTCPUtility::kRtcpPsfbFirItemCode:
+        fir_item_.Set(parser.Packet().FIRItem);
+        break;
+      case RTCPUtility::kRtcpRtpfbNackCode:
+        nack_.Set(parser.Packet().NACK);
+        nack_item_.Clear();
+        break;
+      case RTCPUtility::kRtcpRtpfbNackItemCode:
+        nack_item_.Set(parser.Packet().NACKItem);
+        break;
+      default:
+        break;
     }
   }
 }
+
+uint64_t Rpsi::PictureId() const {
+  assert(num_packets_ > 0);
+  uint16_t num_bytes = rpsi_.NumberOfValidBits / 8;
+  assert(num_bytes > 0);
+  uint64_t picture_id = 0;
+  for (uint16_t i = 0; i < num_bytes - 1; ++i) {
+    picture_id += (rpsi_.NativeBitString[i] & 0x7f);
+    picture_id <<= 7;
+  }
+  picture_id += (rpsi_.NativeBitString[num_bytes - 1] & 0x7f);
+  return picture_id;
+}
+
 }  // namespace test
 }  // namespace webrtc
diff --git a/test/rtcp_packet_parser.h b/test/rtcp_packet_parser.h
index a9e650cf..4db58c35 100644
--- a/test/rtcp_packet_parser.h
+++ b/test/rtcp_packet_parser.h
@@ -23,167 +23,192 @@ namespace test {
 
 class RtcpPacketParser;
 
-class SenderReport {
+class PacketType {
  public:
-  SenderReport() : num_packets_(0) {}
-  ~SenderReport() {}
+  virtual ~PacketType() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return sr_.SenderSSRC; }
-  uint32_t NtpSec() { return sr_.NTPMostSignificant; }
-  uint32_t NtpFrac() { return sr_.NTPLeastSignificant; }
-  uint32_t RtpTimestamp() { return sr_.RTPTimestamp; }
-  uint32_t PacketCount() { return sr_.SenderPacketCount; }
-  uint32_t OctetCount() { return sr_.SenderOctetCount; }
+  int num_packets() const { return num_packets_; }
+
+ protected:
+  PacketType() : num_packets_(0) {}
+
+  int num_packets_;
+};
+
+class SenderReport : public PacketType {
+ public:
+  SenderReport() {}
+  virtual ~SenderReport() {}
+
+  uint32_t Ssrc() const { return sr_.SenderSSRC; }
+  uint32_t NtpSec() const { return sr_.NTPMostSignificant; }
+  uint32_t NtpFrac() const { return sr_.NTPLeastSignificant; }
+  uint32_t RtpTimestamp() const { return sr_.RTPTimestamp; }
+  uint32_t PacketCount() const { return sr_.SenderPacketCount; }
+  uint32_t OctetCount() const { return sr_.SenderOctetCount; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketSR& sr) {
     sr_ = sr;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketSR sr_;
 };
 
-class ReceiverReport {
+class ReceiverReport : public PacketType {
  public:
-  ReceiverReport() : num_packets_(0) {}
-  ~ReceiverReport() {}
+  ReceiverReport() {}
+  virtual ~ReceiverReport() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return rr_.SenderSSRC; }
+  uint32_t Ssrc() const { return rr_.SenderSSRC; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketRR& rr) {
     rr_ = rr;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketRR rr_;
 };
 
-class ReportBlock {
+class ReportBlock : public PacketType {
  public:
-  ReportBlock() : num_packets_(0) {}
-  ~ReportBlock() {}
-
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return rb_.SSRC; }
-  uint8_t FractionLost() { return rb_.FractionLost; }
-  uint32_t CumPacketLost() { return rb_.CumulativeNumOfPacketsLost; }
-  uint32_t ExtHighestSeqNum() { return rb_.ExtendedHighestSequenceNumber; }
-  uint32_t Jitter() { return rb_.Jitter; }
-  uint32_t LastSr() { return rb_.LastSR; }
-  uint32_t DelayLastSr() { return rb_.DelayLastSR; }
+  ReportBlock() {}
+  virtual ~ReportBlock() {}
+
+  uint32_t Ssrc() const { return rb_.SSRC; }
+  uint8_t FractionLost() const { return rb_.FractionLost; }
+  uint32_t CumPacketLost() const { return rb_.CumulativeNumOfPacketsLost; }
+  uint32_t ExtHighestSeqNum() const { return rb_.ExtendedHighestSequenceNumber;}
+  uint32_t Jitter() const { return rb_.Jitter; }
+  uint32_t LastSr() const { return rb_.LastSR; }
+  uint32_t DelayLastSr()const  { return rb_.DelayLastSR; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketReportBlockItem& rb) {
     rb_ = rb;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketReportBlockItem rb_;
 };
 
-class Bye {
+class Bye : public PacketType {
  public:
-  Bye() : num_packets_(0) {}
-  ~Bye() {}
+  Bye() {}
+  virtual ~Bye() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return bye_.SenderSSRC; }
+  uint32_t Ssrc() const { return bye_.SenderSSRC; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketBYE& bye) {
     bye_ = bye;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketBYE bye_;
 };
 
-class Fir {
+class Rpsi : public PacketType {
+ public:
+  Rpsi() {}
+  virtual ~Rpsi() {}
+
+  uint32_t Ssrc() const { return rpsi_.SenderSSRC; }
+  uint32_t MediaSsrc() const { return rpsi_.MediaSSRC; }
+  uint8_t PayloadType() const { return rpsi_.PayloadType; }
+  uint16_t NumberOfValidBits() const { return rpsi_.NumberOfValidBits; }
+  uint64_t PictureId() const;
+
+ private:
+  friend class RtcpPacketParser;
+
+  void Set(const RTCPUtility::RTCPPacketPSFBRPSI& rpsi) {
+    rpsi_ = rpsi;
+    ++num_packets_;
+  }
+
+  RTCPUtility::RTCPPacketPSFBRPSI rpsi_;
+};
+
+class Fir : public PacketType {
  public:
-  Fir() : num_packets_(0) {}
-  ~Fir() {}
+  Fir() {}
+  virtual ~Fir() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return fir_.SenderSSRC; }
+  uint32_t Ssrc() const { return fir_.SenderSSRC; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketPSFBFIR& fir) {
     fir_ = fir;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketPSFBFIR fir_;
 };
 
-class FirItem {
+class FirItem : public PacketType {
  public:
-  FirItem() : num_packets_(0) {}
-  ~FirItem() {}
+  FirItem() {}
+  virtual ~FirItem() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return fir_item_.SSRC; }
-  uint8_t SeqNum() { return fir_item_.CommandSequenceNumber; }
+  uint32_t Ssrc() const { return fir_item_.SSRC; }
+  uint8_t SeqNum() const { return fir_item_.CommandSequenceNumber; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketPSFBFIRItem& fir_item) {
     fir_item_ = fir_item;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketPSFBFIRItem fir_item_;
 };
 
-class Nack {
+class Nack : public PacketType {
  public:
-  Nack() : num_packets_(0) {}
-  ~Nack() {}
+  Nack() {}
+  virtual ~Nack() {}
 
-  int num_packets() { return num_packets_; }
-  uint32_t Ssrc() { return nack_.SenderSSRC; }
-  uint32_t MediaSsrc() { return nack_.MediaSSRC; }
+  uint32_t Ssrc() const { return nack_.SenderSSRC; }
+  uint32_t MediaSsrc() const { return nack_.MediaSSRC; }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketRTPFBNACK& nack) {
     nack_ = nack;
     ++num_packets_;
   }
 
-  int num_packets_;
   RTCPUtility::RTCPPacketRTPFBNACK nack_;
 };
 
-class NackItem {
+class NackItem : public PacketType {
  public:
-  NackItem() : num_packets_(0) {}
-  ~NackItem() {}
+  NackItem() {}
+  virtual ~NackItem() {}
 
-  int num_packets() { return num_packets_; }
-  std::vector<uint16_t> last_nack_list() {
-    assert(num_packets_ > 0);
+  std::vector<uint16_t> last_nack_list() const {
     return last_nack_list_;
   }
 
  private:
   friend class RtcpPacketParser;
+
   void Set(const RTCPUtility::RTCPPacketRTPFBNACKItem& nack_item) {
-    last_nack_list_.clear();
     last_nack_list_.push_back(nack_item.PacketID);
     for (int i = 0; i < 16; ++i) {
       if (nack_item.BitMask & (1 << i)) {
@@ -192,12 +217,11 @@ class NackItem {
     }
     ++num_packets_;
   }
+  void Clear() { last_nack_list_.clear(); }
 
-  int num_packets_;
   std::vector<uint16_t> last_nack_list_;
 };
 
-
 class RtcpPacketParser {
  public:
   RtcpPacketParser();
@@ -209,6 +233,7 @@ class RtcpPacketParser {
   ReceiverReport* receiver_report() { return &receiver_report_; }
   ReportBlock* report_block() { return &report_block_; }
   Bye* bye() { return &bye_; }
+  Rpsi* rpsi() { return &rpsi_; }
   Fir* fir() { return &fir_; }
   FirItem* fir_item() { return &fir_item_; }
   Nack* nack() { return &nack_; }
@@ -223,6 +248,7 @@ class RtcpPacketParser {
   ReceiverReport receiver_report_;
   ReportBlock report_block_;
   Bye bye_;
+  Rpsi rpsi_;
   Fir fir_;
   FirItem fir_item_;
   Nack nack_;