Refactor RTCP sender

The main purpose of this CL is to clean up RTCPSender::PrepareRTCP, but
it has quite a few ramifications. Notable changes:

* Removed the rtcpPacketTypeFlags bit vector and don't assume
  RTCPPacketType values have a single unique bit set. This will allow
  making this an enum class once rtcp_receiver has been overhauled.

* Flags are now stored in a map that is a member of the class. This
  meant we could remove some bool flags (eg send_remb_) which was
  previously masked into rtcpPacketTypeFlags and then masked out again
  when testing if a remb packet should be sent.

* Make all build methods, eg. BuildREMB(), have the same signature.
  An RtcpContext struct was introduced for this purpose. This allowed
  the use of a map from RTCPPacketType to method pointer. Instead of
  18 consecutive if-statements, there is now a single loop.
  The context class also allowed some simplifications in the build
  methods themselves.

* A few minor simplifications and cleanups.

The next step is to gradually replace the builder methods with the
builders from the new RtcpPacket classes.

BUG=2450
R=asapersson@webrtc.org, pbos@webrtc.org

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

Cr-Commit-Position: refs/heads/master@{#9166}

webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h

@@ -11,6 +11,7 @@
 #ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
 #define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
 
+#include <set>
 #include <vector>
 
 #include "webrtc/modules/interface/module.h"
@@ -390,12 +391,20 @@ class RtpRtcp : public Module {
 
     /*
     *   Force a send of a RTCP packet
-    *   normal SR and RR are triggered via the process function
+    *   periodic SR and RR are triggered via the process function
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t SendRTCP(
+    virtual int32_t SendRTCP(RTCPPacketType rtcpPacketType) = 0;
-        uint32_t rtcpPacketType = kRtcpReport) = 0;
+
+    /*
+    *   Force a send of a RTCP packet with more than one packet type.
+    *   periodic SR and RR are triggered via the process function
+    *
+    *   return -1 on failure else 0
+    */
+    virtual int32_t SendCompoundRTCP(
+        const std::set<RTCPPacketType>& rtcpPacketTypes) = 0;
 
     /*
     *    Good state of RTP receiver inform sender

webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h

@@ -88,20 +88,21 @@ enum RTCPAppSubTypes
     kAppSubtypeBwe     = 0x00
 };
 
-enum RTCPPacketType
+// TODO(sprang): Make this an enum class once rtcp_receiver has been cleaned up.
-{
+enum RTCPPacketType : uint32_t {
   kRtcpReport = 0x0001,
   kRtcpSr = 0x0002,
   kRtcpRr = 0x0004,
-    kRtcpBye            = 0x0008,
+  kRtcpSdes = 0x0008,
-    kRtcpPli            = 0x0010,
+  kRtcpBye = 0x0010,
-    kRtcpNack           = 0x0020,
+  kRtcpPli = 0x0020,
-    kRtcpFir            = 0x0040,
+  kRtcpNack = 0x0040,
-    kRtcpTmmbr          = 0x0080,
+  kRtcpFir = 0x0080,
-    kRtcpTmmbn          = 0x0100,
+  kRtcpTmmbr = 0x0100,
-    kRtcpSrReq          = 0x0200,
+  kRtcpTmmbn = 0x0200,
-    kRtcpXrVoipMetric   = 0x0400,
+  kRtcpSrReq = 0x0400,
-    kRtcpApp            = 0x0800,
+  kRtcpXrVoipMetric = 0x0800,
+  kRtcpApp = 0x1000,
   kRtcpSli = 0x4000,
   kRtcpRpsi = 0x8000,
   kRtcpRemb = 0x10000,
@@ -129,7 +130,7 @@ enum NACKMethod
     kNackRtcp     = 2
 };
 
-enum RetransmissionMode {
+enum RetransmissionMode : uint8_t {
   kRetransmitOff = 0x0,
   kRetransmitFECPackets = 0x1,
   kRetransmitBaseLayer = 0x2,

webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h

@@ -156,8 +156,9 @@ class MockRtpRtcp : public RtpRtcp {
               int64_t* avgRTT,
               int64_t* minRTT,
               int64_t* maxRTT));
-  MOCK_METHOD1(SendRTCP,
+  MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packetType));
-      int32_t(uint32_t rtcpPacketType));
+  MOCK_METHOD1(SendCompoundRTCP,
+               int32_t(const std::set<RTCPPacketType>& packetTypes));
   MOCK_METHOD1(SendRTCPReferencePictureSelection,
       int32_t(const uint64_t pictureID));
   MOCK_METHOD1(SendRTCPSliceLossIndication,

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

@@ -285,69 +285,68 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
     }
 
     RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
-    while (pktType != RTCPUtility::kRtcpNotValidCode)
+    while (pktType != RTCPPacketTypes::kInvalid) {
-    {
         // Each "case" is responsible for iterate the parser to the
         // next top level packet.
         switch (pktType)
         {
-        case RTCPUtility::kRtcpSrCode:
+          case RTCPPacketTypes::kSr:
-        case RTCPUtility::kRtcpRrCode:
+          case RTCPPacketTypes::kRr:
             HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpSdesCode:
+          case RTCPPacketTypes::kSdes:
             HandleSDES(*rtcpParser);
             break;
-        case RTCPUtility::kRtcpXrHeaderCode:
+          case RTCPPacketTypes::kXrHeader:
             HandleXrHeader(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpXrReceiverReferenceTimeCode:
+          case RTCPPacketTypes::kXrReceiverReferenceTime:
             HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpXrDlrrReportBlockCode:
+          case RTCPPacketTypes::kXrDlrrReportBlock:
             HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpXrVoipMetricCode:
+          case RTCPPacketTypes::kXrVoipMetric:
             HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpByeCode:
+          case RTCPPacketTypes::kBye:
             HandleBYE(*rtcpParser);
             break;
-        case RTCPUtility::kRtcpRtpfbNackCode:
+          case RTCPPacketTypes::kRtpfbNack:
             HandleNACK(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpRtpfbTmmbrCode:
+          case RTCPPacketTypes::kRtpfbTmmbr:
             HandleTMMBR(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpRtpfbTmmbnCode:
+          case RTCPPacketTypes::kRtpfbTmmbn:
             HandleTMMBN(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpRtpfbSrReqCode:
+          case RTCPPacketTypes::kRtpfbSrReq:
             HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpPsfbPliCode:
+          case RTCPPacketTypes::kPsfbPli:
             HandlePLI(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpPsfbSliCode:
+          case RTCPPacketTypes::kPsfbSli:
             HandleSLI(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpPsfbRpsiCode:
+          case RTCPPacketTypes::kPsfbRpsi:
             HandleRPSI(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpExtendedIjCode:
+          case RTCPPacketTypes::kExtendedIj:
             HandleIJ(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpPsfbFirCode:
+          case RTCPPacketTypes::kPsfbFir:
             HandleFIR(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpPsfbAppCode:
+          case RTCPPacketTypes::kPsfbApp:
             HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpAppCode:
+          case RTCPPacketTypes::kApp:
             // generic application messages
             HandleAPP(*rtcpParser, rtcpPacketInformation);
             break;
-        case RTCPUtility::kRtcpAppItemCode:
+          case RTCPPacketTypes::kAppItem:
             // generic application messages
             HandleAPPItem(*rtcpParser, rtcpPacketInformation);
             break;
@@ -374,7 +373,8 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
     RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
     const RTCPUtility::RTCPPacket& rtcpPacket   = rtcpParser.Packet();
 
-    assert((rtcpPacketType == RTCPUtility::kRtcpRrCode) || (rtcpPacketType == RTCPUtility::kRtcpSrCode));
+    assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
+           (rtcpPacketType == RTCPPacketTypes::kSr));
 
     // SR.SenderSSRC
     // The synchronization source identifier for the originator of this SR packet
@@ -382,7 +382,9 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
     // rtcpPacket.RR.SenderSSRC
     // The source of the packet sender, same as of SR? or is this a CE?
 
-    const uint32_t remoteSSRC = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.SenderSSRC:rtcpPacket.SR.SenderSSRC;
+    const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
+                                    ? rtcpPacket.RR.SenderSSRC
+                                    : rtcpPacket.SR.SenderSSRC;
 
     rtcpPacketInformation.remoteSSRC = remoteSSRC;
 
@@ -393,8 +395,7 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
         return;
     }
 
-    if (rtcpPacketType == RTCPUtility::kRtcpSrCode)
+    if (rtcpPacketType == RTCPPacketTypes::kSr) {
-    {
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
                            "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
@@ -434,8 +435,7 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
 
     rtcpPacketType = rtcpParser.Iterate();
 
-    while (rtcpPacketType == RTCPUtility::kRtcpReportBlockItemCode)
+    while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
-    {
         HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
         rtcpPacketType = rtcpParser.Iterate();
     }
@@ -756,7 +756,7 @@ int32_t RTCPReceiver::BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec) {
 // no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser) {
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpSdesChunkCode) {
+  while (pktType == RTCPPacketTypes::kSdesChunk) {
     HandleSDESChunk(rtcpParser);
     pktType = rtcpParser.Iterate();
   }
@@ -792,7 +792,7 @@ void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
   rtcpPacketInformation.ResetNACKPacketIdArray();
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpRtpfbNackItemCode) {
+  while (pktType == RTCPPacketTypes::kRtpfbNackItem) {
     HandleNACKItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
@@ -896,7 +896,7 @@ void RTCPReceiver::HandleXrDlrrReportBlock(
   // Iterate through sub-block(s), if any.
   RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate();
 
-  while (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
+  while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) {
     HandleXrDlrrReportBlockItem(packet, rtcpPacketInformation);
     packet_type = parser.Iterate();
   }
@@ -1029,7 +1029,7 @@ void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
   ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpRtpfbTmmbrItemCode) {
+  while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
     HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
     pktType = rtcpParser.Iterate();
   }
@@ -1074,7 +1074,7 @@ void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
   ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpRtpfbTmmbnItemCode) {
+  while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
     HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
     pktType = rtcpParser.Iterate();
   }
@@ -1101,7 +1101,7 @@ void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpPsfbSliItemCode) {
+  while (pktType == RTCPPacketTypes::kPsfbSliItem) {
     HandleSLIItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
@@ -1121,8 +1121,7 @@ RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
 {
     const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
     RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-    if(pktType == RTCPUtility::kRtcpPsfbRpsiCode)
+    if (pktType == RTCPPacketTypes::kPsfbRpsi) {
-    {
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi; // received signal that we have a confirmed reference picture
         if(rtcpPacket.RPSI.NumberOfValidBits%8 != 0)
         {
@@ -1148,9 +1147,9 @@ RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
 void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser,
                                  RTCPPacketInformation& rtcpPacketInformation) {
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  if (pktType == RTCPUtility::kRtcpPsfbRembCode) {
+  if (pktType == RTCPPacketTypes::kPsfbRemb) {
     pktType = rtcpParser.Iterate();
-    if (pktType == RTCPUtility::kRtcpPsfbRembItemCode) {
+    if (pktType == RTCPPacketTypes::kPsfbRembItem) {
       HandleREMBItem(rtcpParser, rtcpPacketInformation);
       rtcpParser.Iterate();
     }
@@ -1163,7 +1162,7 @@ void RTCPReceiver::HandleIJ(RTCPUtility::RTCPParserV2& rtcpParser,
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpExtendedIjItemCode) {
+  while (pktType == RTCPPacketTypes::kExtendedIjItem) {
     HandleIJItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
@@ -1193,7 +1192,7 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
       GetReceiveInformation(rtcpPacket.FIR.SenderSSRC);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPUtility::kRtcpPsfbFirItemCode) {
+  while (pktType == RTCPPacketTypes::kPsfbFirItem) {
     HandleFIRItem(ptrReceiveInfo, rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
@@ -1367,8 +1366,8 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
         _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(
             rtcpPacketInformation.receiverEstimatedMaxBitrate);
       }
-      if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr ||
+      if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr) ||
-          rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr) {
+          (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
         int64_t now = _clock->TimeInMilliseconds();
         _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
             rtcpPacketInformation.report_blocks,

webrtc/modules/rtp_rtcp/source/rtcp_sender.h

@@ -12,6 +12,7 @@
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
 
 #include <map>
+#include <set>
 #include <sstream>
 #include <string>
 
@@ -40,10 +41,10 @@ class NACKStringBuilder {
   std::string GetResult();
 
  private:
-  std::ostringstream _stream;
+  std::ostringstream stream_;
-  int _count;
+  int count_;
-  uint16_t _prevNack;
+  uint16_t prevNack_;
-  bool _consecutive;
+  bool consecutive_;
 };
 
 class RTCPSender {
@@ -107,7 +108,14 @@ public:
  bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const;
 
  int32_t SendRTCP(const FeedbackState& feedback_state,
-                  uint32_t rtcpPacketTypeFlags,
+                  RTCPPacketType packetType,
+                  int32_t nackSize = 0,
+                  const uint16_t* nackList = 0,
+                  bool repeat = false,
+                  uint64_t pictureID = 0);
+
+ int32_t SendCompoundRTCP(const FeedbackState& feedback_state,
+                          const std::set<RTCPPacketType>& packetTypes,
                           int32_t nackSize = 0,
                           const uint16_t* nackList = 0,
                           bool repeat = false,
@@ -150,18 +158,36 @@ public:
  void SetTargetBitrate(unsigned int target_bitrate);
 
 private:
+ struct RtcpContext;
+
+ // The BuildResult indicates the outcome of a call to a builder method,
+ // constructing a part of an RTCP packet:
+ //
+ // kError
+ //   Building RTCP packet failed, propagate error out to caller.
+ // kAbort
+ //   The (partial) block being build should not be included. Reset current
+ //   buffer position to the state before the method call and proceed to the
+ //   next packet type.
+ // kTruncated
+ //   There is not enough room in the buffer to fit the data being constructed.
+ //   (IP packet is full). Proceed to the next packet type, and call this
+ //   method again when a new buffer has been allocated.
+ // TODO(sprang): Actually allocate multiple packets if needed.
+ // kSuccess
+ //   Data has been successfully placed in the buffer.
+
+ enum class BuildResult { kError, kAborted, kTruncated, kSuccess };
+
  int32_t SendToNetwork(const uint8_t* dataBuffer, size_t length);
 
- int32_t WriteAllReportBlocksToBuffer(uint8_t* rtcpbuffer,
+ RTCPSender::BuildResult WriteAllReportBlocksToBuffer(
-                                      int pos,
+     RtcpContext* context,
-                                      uint8_t* numberOfReportBlocks,
+     uint8_t* numberOfReportBlocks)
-                                      uint32_t NTPsec,
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-                                      uint32_t NTPfrac)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
 
- int32_t WriteReportBlocksToBuffer(
+ void WriteReportBlocksToBuffer(
-     uint8_t* rtcpbuffer,
+     RtcpContext* context,
-     int32_t position,
      const std::map<uint32_t, RTCPReportBlock*>& report_blocks);
 
  int32_t AddReportBlock(uint32_t SSRC,
@@ -174,21 +200,8 @@ private:
                     uint32_t* ntp_secs,
                     uint32_t* ntp_frac);
 
- int32_t BuildSR(const FeedbackState& feedback_state,
-                 uint8_t* rtcpbuffer,
-                 int32_t pos,
-                 uint32_t NTPsec,
-                 uint32_t NTPfrac)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
-
- int32_t BuildRR(uint8_t* rtcpbuffer,
-                 int32_t pos,
-                 uint32_t NTPsec,
-                 uint32_t NTPfrac)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
-
  int PrepareRTCP(const FeedbackState& feedback_state,
-                 uint32_t packetTypeFlags,
+                 const std::set<RTCPPacketType>& packetTypes,
                  int32_t nackSize,
                  const uint16_t* nackList,
                  bool repeat,
@@ -196,135 +209,142 @@ private:
                  uint8_t* rtcp_buffer,
                  int buffer_size);
 
- bool ShouldSendReportBlocks(uint32_t rtcp_packet_type) const;
+ BuildResult BuildSR(RtcpContext* context)
-
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- int32_t BuildExtendedJitterReport(uint8_t* rtcpbuffer,
+ BuildResult BuildRR(RtcpContext* context)
-                                   int32_t pos,
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-                                   uint32_t jitterTransmissionTimeOffset)
+ BuildResult BuildExtendedJitterReport(RtcpContext* context)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-
+ BuildResult BuildSDEC(RtcpContext* context)
- int32_t BuildSDEC(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildPLI(RtcpContext* context)
- int32_t BuildPLI(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildREMB(RtcpContext* context)
- int32_t BuildREMB(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildTMMBR(RtcpContext* context)
- int32_t BuildTMMBR(ModuleRtpRtcpImpl* module, uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildTMMBN(RtcpContext* context)
- int32_t BuildTMMBN(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildAPP(RtcpContext* context)
- int32_t BuildAPP(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildVoIPMetric(RtcpContext* context)
- int32_t BuildVoIPMetric(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildBYE(RtcpContext* context)
- int32_t BuildBYE(uint8_t* rtcpbuffer, int32_t pos)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildFIR(RtcpContext* context)
- int32_t BuildFIR(uint8_t* rtcpbuffer, int32_t pos, bool repeat)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildSLI(RtcpContext* context)
- int32_t BuildSLI(uint8_t* rtcpbuffer, int32_t pos, uint8_t pictureID)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+ BuildResult BuildRPSI(RtcpContext* context)
- int32_t BuildRPSI(uint8_t* rtcpbuffer,
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-                   int32_t pos,
+ BuildResult BuildNACK(RtcpContext* context)
-                   uint64_t pictureID,
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-                   uint8_t payloadType)
+ BuildResult BuildReceiverReferenceTime(RtcpContext* context)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-
+ BuildResult BuildDlrr(RtcpContext* context)
- int32_t BuildNACK(uint8_t* rtcpbuffer,
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-                   int32_t pos,
-                   int32_t nackSize,
-                   const uint16_t* nackList,
-                   std::string* nackString)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
- int32_t BuildReceiverReferenceTime(uint8_t* buffer,
-                                    int32_t pos,
-                                    uint32_t ntp_sec,
-                                    uint32_t ntp_frac)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
- int32_t BuildDlrr(uint8_t* buffer,
-                   int32_t pos,
-                   const RtcpReceiveTimeInfo& info)
-     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
 
 private:
- const int32_t _id;
+ const int32_t id_;
- const bool _audio;
+ const bool audio_;
- Clock* const _clock;
+ Clock* const clock_;
- RTCPMethod _method GUARDED_BY(_criticalSectionRTCPSender);
+ RTCPMethod method_ GUARDED_BY(critical_section_rtcp_sender_);
 
- rtc::scoped_ptr<CriticalSectionWrapper> _criticalSectionTransport;
+ rtc::scoped_ptr<CriticalSectionWrapper> critical_section_transport_;
- Transport* _cbTransport GUARDED_BY(_criticalSectionTransport);
+ Transport* cbTransport_ GUARDED_BY(critical_section_transport_);
 
- rtc::scoped_ptr<CriticalSectionWrapper> _criticalSectionRTCPSender;
+ rtc::scoped_ptr<CriticalSectionWrapper> critical_section_rtcp_sender_;
- bool _usingNack GUARDED_BY(_criticalSectionRTCPSender);
+ bool using_nack_ GUARDED_BY(critical_section_rtcp_sender_);
- bool _sending GUARDED_BY(_criticalSectionRTCPSender);
+ bool sending_ GUARDED_BY(critical_section_rtcp_sender_);
- bool _sendTMMBN GUARDED_BY(_criticalSectionRTCPSender);
+ bool remb_enabled_ GUARDED_BY(critical_section_rtcp_sender_);
- bool _REMB GUARDED_BY(_criticalSectionRTCPSender);
+ bool extended_jitter_report_enabled_ GUARDED_BY(critical_section_rtcp_sender_);
- bool _sendREMB GUARDED_BY(_criticalSectionRTCPSender);
- bool _TMMBR GUARDED_BY(_criticalSectionRTCPSender);
- bool _IJ GUARDED_BY(_criticalSectionRTCPSender);
 
- int64_t _nextTimeToSendRTCP GUARDED_BY(_criticalSectionRTCPSender);
+ int64_t next_time_to_send_rtcp_ GUARDED_BY(critical_section_rtcp_sender_);
 
- uint32_t start_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t start_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t last_rtp_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t last_rtp_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
- int64_t last_frame_capture_time_ms_ GUARDED_BY(_criticalSectionRTCPSender);
+ int64_t last_frame_capture_time_ms_ GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t _SSRC GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
  // SSRC that we receive on our RTP channel
- uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t remote_ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
- char _CNAME[RTCP_CNAME_SIZE] GUARDED_BY(_criticalSectionRTCPSender);
+ char cname_[RTCP_CNAME_SIZE] GUARDED_BY(critical_section_rtcp_sender_);
 
- ReceiveStatistics* receive_statistics_ GUARDED_BY(_criticalSectionRTCPSender);
+ ReceiveStatistics* receive_statistics_
+     GUARDED_BY(critical_section_rtcp_sender_);
  std::map<uint32_t, RTCPReportBlock*> internal_report_blocks_
-     GUARDED_BY(_criticalSectionRTCPSender);
+     GUARDED_BY(critical_section_rtcp_sender_);
  std::map<uint32_t, RTCPReportBlock*> external_report_blocks_
-     GUARDED_BY(_criticalSectionRTCPSender);
+     GUARDED_BY(critical_section_rtcp_sender_);
- std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs
+ std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> csrc_cnames_
-     GUARDED_BY(_criticalSectionRTCPSender);
+     GUARDED_BY(critical_section_rtcp_sender_);
 
  // Sent
- uint32_t _lastSendReport[RTCP_NUMBER_OF_SR] GUARDED_BY(
+ uint32_t last_send_report_[RTCP_NUMBER_OF_SR] GUARDED_BY(
-     _criticalSectionRTCPSender);  // allow packet loss and RTT above 1 sec
+     critical_section_rtcp_sender_);  // allow packet loss and RTT above 1 sec
- int64_t _lastRTCPTime[RTCP_NUMBER_OF_SR] GUARDED_BY(
+ int64_t last_rtcp_time_[RTCP_NUMBER_OF_SR] GUARDED_BY(
-     _criticalSectionRTCPSender);
+     critical_section_rtcp_sender_);
 
  // Sent XR receiver reference time report.
  // <mid ntp (mid 32 bits of the 64 bits NTP timestamp), send time in ms>.
- std::map<uint32_t, int64_t> last_xr_rr_ GUARDED_BY(_criticalSectionRTCPSender);
+ std::map<uint32_t, int64_t> last_xr_rr_
+     GUARDED_BY(critical_section_rtcp_sender_);
 
  // send CSRCs
- std::vector<uint32_t> csrcs_ GUARDED_BY(_criticalSectionRTCPSender);
+ std::vector<uint32_t> csrcs_ GUARDED_BY(critical_section_rtcp_sender_);
 
  // Full intra request
- uint8_t _sequenceNumberFIR GUARDED_BY(_criticalSectionRTCPSender);
+ uint8_t sequence_number_fir_ GUARDED_BY(critical_section_rtcp_sender_);
 
  // REMB
- uint32_t _rembBitrate GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t remb_bitrate_ GUARDED_BY(critical_section_rtcp_sender_);
- std::vector<uint32_t> remb_ssrcs_ GUARDED_BY(_criticalSectionRTCPSender);
+ std::vector<uint32_t> remb_ssrcs_ GUARDED_BY(critical_section_rtcp_sender_);
 
- TMMBRHelp _tmmbrHelp GUARDED_BY(_criticalSectionRTCPSender);
+ TMMBRHelp tmmbr_help_ GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t _tmmbr_Send GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t tmmbr_send_ GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t _packetOH_Send GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t packet_oh_send_ GUARDED_BY(critical_section_rtcp_sender_);
 
  // APP
- bool _appSend GUARDED_BY(_criticalSectionRTCPSender);
+ uint8_t app_sub_type_ GUARDED_BY(critical_section_rtcp_sender_);
- uint8_t _appSubType GUARDED_BY(_criticalSectionRTCPSender);
+ uint32_t app_name_ GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t _appName GUARDED_BY(_criticalSectionRTCPSender);
+ rtc::scoped_ptr<uint8_t[]> app_data_ GUARDED_BY(critical_section_rtcp_sender_);
- rtc::scoped_ptr<uint8_t[]> _appData GUARDED_BY(_criticalSectionRTCPSender);
+ uint16_t app_length_ GUARDED_BY(critical_section_rtcp_sender_);
- uint16_t _appLength GUARDED_BY(_criticalSectionRTCPSender);
 
  // True if sending of XR Receiver reference time report is enabled.
- bool xrSendReceiverReferenceTimeEnabled_
+ bool xr_send_receiver_reference_time_enabled_
-     GUARDED_BY(_criticalSectionRTCPSender);
+     GUARDED_BY(critical_section_rtcp_sender_);
 
  // XR VoIP metric
- bool _xrSendVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
+ RTCPVoIPMetric xr_voip_metric_ GUARDED_BY(critical_section_rtcp_sender_);
- RTCPVoIPMetric _xrVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
 
  RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
  RtcpPacketTypeCounter packet_type_counter_
-     GUARDED_BY(_criticalSectionRTCPSender);
+     GUARDED_BY(critical_section_rtcp_sender_);
 
- RTCPUtility::NackStats nack_stats_ GUARDED_BY(_criticalSectionRTCPSender);
+ RTCPUtility::NackStats nack_stats_ GUARDED_BY(critical_section_rtcp_sender_);
+
+ void SetFlag(RTCPPacketType type, bool is_volatile)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+ void SetFlags(const std::set<RTCPPacketType>& types, bool is_volatile)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+ bool IsFlagPresent(RTCPPacketType type) const
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+ bool ConsumeFlag(RTCPPacketType type, bool forced = false)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+ bool AllVolatileFlagsConsumed() const
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
+ struct ReportFlag {
+   ReportFlag(RTCPPacketType type, bool is_volatile)
+       : type(type), is_volatile(is_volatile) {}
+   bool operator<(const ReportFlag& flag) const { return type < flag.type; }
+   bool operator==(const ReportFlag& flag) const { return type == flag.type; }
+   const RTCPPacketType type;
+   const bool is_volatile;
+ };
+
+ std::set<ReportFlag> report_flags_ GUARDED_BY(critical_section_rtcp_sender_);
+
+ typedef BuildResult (RTCPSender::*Builder)(RtcpContext*);
+ std::map<RTCPPacketType, Builder> builders_;
 };
 }  // namespace webrtc
 

webrtc/modules/rtp_rtcp/source/rtcp_utility.cc

@@ -49,9 +49,9 @@ RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData,
       _validPacket(false),
       _ptrRTCPData(rtcpData),
       _ptrRTCPBlockEnd(NULL),
-      _state(State_TopLevel),
+      _state(ParseState::State_TopLevel),
       _numberOfBlocks(0),
-      _packetType(kRtcpNotValidCode) {
+      _packetType(RTCPPacketTypes::kInvalid) {
   Validate();
 }
 
@@ -88,58 +88,58 @@ RTCPUtility::RTCPPacketTypes
 RTCPUtility::RTCPParserV2::Iterate()
 {
     // Reset packet type
-    _packetType = kRtcpNotValidCode;
+  _packetType = RTCPPacketTypes::kInvalid;
 
     if (IsValid())
     {
         switch (_state)
         {
-        case State_TopLevel:
+          case ParseState::State_TopLevel:
             IterateTopLevel();
             break;
-        case State_ReportBlockItem:
+          case ParseState::State_ReportBlockItem:
             IterateReportBlockItem();
             break;
-        case State_SDESChunk:
+          case ParseState::State_SDESChunk:
             IterateSDESChunk();
             break;
-        case State_BYEItem:
+          case ParseState::State_BYEItem:
             IterateBYEItem();
             break;
-        case State_ExtendedJitterItem:
+          case ParseState::State_ExtendedJitterItem:
             IterateExtendedJitterItem();
             break;
-        case State_RTPFB_NACKItem:
+          case ParseState::State_RTPFB_NACKItem:
             IterateNACKItem();
             break;
-        case State_RTPFB_TMMBRItem:
+          case ParseState::State_RTPFB_TMMBRItem:
             IterateTMMBRItem();
             break;
-        case State_RTPFB_TMMBNItem:
+          case ParseState::State_RTPFB_TMMBNItem:
             IterateTMMBNItem();
             break;
-        case State_PSFB_SLIItem:
+          case ParseState::State_PSFB_SLIItem:
             IterateSLIItem();
             break;
-        case State_PSFB_RPSIItem:
+          case ParseState::State_PSFB_RPSIItem:
             IterateRPSIItem();
             break;
-        case State_PSFB_FIRItem:
+          case ParseState::State_PSFB_FIRItem:
             IterateFIRItem();
             break;
-        case State_PSFB_AppItem:
+          case ParseState::State_PSFB_AppItem:
             IteratePsfbAppItem();
             break;
-        case State_PSFB_REMBItem:
+          case ParseState::State_PSFB_REMBItem:
             IteratePsfbREMBItem();
             break;
-        case State_XRItem:
+          case ParseState::State_XRItem:
             IterateXrItem();
             break;
-        case State_XR_DLLRItem:
+          case ParseState::State_XR_DLLRItem:
             IterateXrDlrrItem();
             break;
-        case State_AppItem:
+          case ParseState::State_AppItem:
             IterateAppItem();
             break;
         default:
@@ -515,7 +515,7 @@ RTCPUtility::RTCPParserV2::ParseRR()
 
     _ptrRTCPData += 4; // Skip header
 
-    _packetType = kRtcpRrCode;
+    _packetType = RTCPPacketTypes::kRr;
 
     _packet.RR.SenderSSRC = *_ptrRTCPData++ << 24;
     _packet.RR.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -525,7 +525,7 @@ RTCPUtility::RTCPParserV2::ParseRR()
     _packet.RR.NumberOfReportBlocks = _numberOfBlocks;
 
     // State transition
-    _state = State_ReportBlockItem;
+    _state = ParseState::State_ReportBlockItem;
 
     return true;
 }
@@ -543,7 +543,7 @@ RTCPUtility::RTCPParserV2::ParseSR()
 
     _ptrRTCPData += 4; // Skip header
 
-    _packetType = kRtcpSrCode;
+    _packetType = RTCPPacketTypes::kSr;
 
     _packet.SR.SenderSSRC = *_ptrRTCPData++ << 24;
     _packet.SR.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -580,11 +580,11 @@ RTCPUtility::RTCPParserV2::ParseSR()
     // State transition
     if(_numberOfBlocks != 0)
     {
-        _state = State_ReportBlockItem;
+      _state = ParseState::State_ReportBlockItem;
     }else
     {
         // don't go to state report block item if 0 report blocks
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
         EndCurrentBlock();
     }
     return true;
@@ -597,7 +597,7 @@ RTCPUtility::RTCPParserV2::ParseReportBlockItem()
 
     if (length < 24 || _numberOfBlocks <= 0)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
@@ -634,7 +634,7 @@ RTCPUtility::RTCPParserV2::ParseReportBlockItem()
     _packet.ReportBlockItem.DelayLastSR += *_ptrRTCPData++;
 
     _numberOfBlocks--;
-    _packetType = kRtcpReportBlockItemCode;
+    _packetType = RTCPPacketTypes::kReportBlockItem;
     return true;
 }
 
@@ -665,10 +665,10 @@ RTCPUtility::RTCPParserV2::ParseIJ()
 
     _ptrRTCPData += 4; // Skip header
 
-    _packetType = kRtcpExtendedIjCode;
+    _packetType = RTCPPacketTypes::kExtendedIj;
 
     // State transition
-    _state = State_ExtendedJitterItem;
+    _state = ParseState::State_ExtendedJitterItem;
     return true;
 }
 
@@ -679,7 +679,7 @@ RTCPUtility::RTCPParserV2::ParseIJItem()
 
     if (length < 4 || _numberOfBlocks <= 0)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
         EndCurrentBlock();
         return false;
     }
@@ -690,7 +690,7 @@ RTCPUtility::RTCPParserV2::ParseIJItem()
     _packet.ExtendedJitterReportItem.Jitter += *_ptrRTCPData++;
 
     _numberOfBlocks--;
-    _packetType = kRtcpExtendedIjItemCode;
+    _packetType = RTCPPacketTypes::kExtendedIjItem;
     return true;
 }
 
@@ -701,15 +701,15 @@ RTCPUtility::RTCPParserV2::ParseSDES()
 
     if (length < 8)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     _ptrRTCPData += 4; // Skip header
 
-    _state = State_SDESChunk;
+    _state = ParseState::State_SDESChunk;
-    _packetType = kRtcpSdesCode;
+    _packetType = RTCPPacketTypes::kSdes;
     return true;
 }
 
@@ -718,7 +718,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
 {
     if(_numberOfBlocks <= 0)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
@@ -731,7 +731,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
         const ptrdiff_t dataLen = _ptrRTCPBlockEnd - _ptrRTCPData;
         if (dataLen < 4)
         {
-            _state = State_TopLevel;
+          _state = ParseState::State_TopLevel;
 
             EndCurrentBlock();
             return false;
@@ -749,7 +749,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
             return true;
         }
     }
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
 
     EndCurrentBlock();
     return false;
@@ -790,7 +790,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
                 // Sanity
                 if ((_ptrRTCPData + len) >= _ptrRTCPBlockEnd)
                 {
-                    _state = State_TopLevel;
+                  _state = ParseState::State_TopLevel;
 
                     EndCurrentBlock();
                     return false;
@@ -802,7 +802,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
                     if ((c < ' ') || (c > '{') || (c == '%') || (c == '\\'))
                     {
                         // Illegal char
-                        _state = State_TopLevel;
+                      _state = ParseState::State_TopLevel;
 
                         EndCurrentBlock();
                         return false;
@@ -811,7 +811,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
                 }
                 // Make sure we are null terminated.
                 _packet.CName.CName[i] = 0;
-                _packetType = kRtcpSdesChunkCode;
+                _packetType = RTCPPacketTypes::kSdesChunk;
 
                 foundCName = true;
             }
@@ -821,7 +821,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
     }
 
     // No end tag found!
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
 
     EndCurrentBlock();
     return false;
@@ -832,7 +832,7 @@ RTCPUtility::RTCPParserV2::ParseBYE()
 {
     _ptrRTCPData += 4; // Skip header
 
-    _state = State_BYEItem;
+    _state = ParseState::State_BYEItem;
 
     return ParseBYEItem();
 }
@@ -843,13 +843,13 @@ RTCPUtility::RTCPParserV2::ParseBYEItem()
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
     if (length < 4 || _numberOfBlocks == 0)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpByeCode;
+    _packetType = RTCPPacketTypes::kBye;
 
     _packet.BYE.SenderSSRC = *_ptrRTCPData++ << 24;
     _packet.BYE.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -894,8 +894,8 @@ bool RTCPUtility::RTCPParserV2::ParseXr()
     _packet.XR.OriginatorSSRC += *_ptrRTCPData++ << 8;
     _packet.XR.OriginatorSSRC += *_ptrRTCPData++;
 
-    _packetType = kRtcpXrHeaderCode;
+    _packetType = RTCPPacketTypes::kXrHeader;
-    _state = State_XRItem;
+    _state = ParseState::State_XRItem;
     return true;
 }
 
@@ -915,7 +915,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrItem() {
   const int kBlockHeaderLengthInBytes = 4;
   const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
   if (length < kBlockHeaderLengthInBytes) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
@@ -956,7 +956,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrReceiverReferenceTimeItem(
   const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
   if (block_length_4bytes != kBlockLengthIn4Bytes ||
       length < kBlockLengthInBytes) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
@@ -971,8 +971,8 @@ bool RTCPUtility::RTCPParserV2::ParseXrReceiverReferenceTimeItem(
   _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++<<8;
   _packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++;
 
-  _packetType = kRtcpXrReceiverReferenceTimeCode;
+  _packetType = RTCPPacketTypes::kXrReceiverReferenceTime;
-  _state = State_XRItem;
+  _state = ParseState::State_XRItem;
   return true;
 }
 
@@ -997,25 +997,25 @@ bool RTCPUtility::RTCPParserV2::ParseXrDlrr(int block_length_4bytes) {
   const int kSubBlockLengthIn4Bytes = 3;
   if (block_length_4bytes < 0 ||
       (block_length_4bytes % kSubBlockLengthIn4Bytes) != 0) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
-  _packetType = kRtcpXrDlrrReportBlockCode;
+  _packetType = RTCPPacketTypes::kXrDlrrReportBlock;
-  _state = State_XR_DLLRItem;
+  _state = ParseState::State_XR_DLLRItem;
   _numberOfBlocks = block_length_4bytes / kSubBlockLengthIn4Bytes;
   return true;
 }
 
 bool RTCPUtility::RTCPParserV2::ParseXrDlrrItem() {
   if (_numberOfBlocks == 0) {
-    _state = State_XRItem;
+    _state = ParseState::State_XRItem;
     return false;
   }
   const int kSubBlockLengthInBytes = 12;
   const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
   if (length < kSubBlockLengthInBytes) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
@@ -1035,9 +1035,9 @@ bool RTCPUtility::RTCPParserV2::ParseXrDlrrItem() {
   _packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++ << 8;
   _packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++;
 
-  _packetType = kRtcpXrDlrrReportBlockItemCode;
+  _packetType = RTCPPacketTypes::kXrDlrrReportBlockItem;
   --_numberOfBlocks;
-  _state = State_XR_DLLRItem;
+  _state = ParseState::State_XR_DLLRItem;
   return true;
 }
 /*  VoIP Metrics Report Block.
@@ -1070,7 +1070,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrVoipMetricItem(int block_length_4bytes) {
   const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
   if (block_length_4bytes != kBlockLengthIn4Bytes ||
       length < kBlockLengthInBytes) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
@@ -1117,8 +1117,8 @@ bool RTCPUtility::RTCPParserV2::ParseXrVoipMetricItem(int block_length_4bytes) {
   _packet.XRVOIPMetricItem.JBabsMax = *_ptrRTCPData++ << 8;
   _packet.XRVOIPMetricItem.JBabsMax += *_ptrRTCPData++;
 
-  _packetType = kRtcpXrVoipMetricCode;
+  _packetType = RTCPPacketTypes::kXrVoipMetric;
-  _state = State_XRItem;
+  _state = ParseState::State_XRItem;
   return true;
 }
 
@@ -1127,13 +1127,13 @@ bool RTCPUtility::RTCPParserV2::ParseXrUnsupportedBlockType(
   const int32_t kBlockLengthInBytes = block_length_4bytes * 4;
   const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
   if (length < kBlockLengthInBytes) {
-    _state = State_TopLevel;
+    _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
   // Skip block.
   _ptrRTCPData += kBlockLengthInBytes;
-  _state = State_XRItem;
+  _state = ParseState::State_XRItem;
   return false;
 }
 
@@ -1171,11 +1171,11 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
         case 1:
         {
             // NACK
-            _packetType             = kRtcpRtpfbNackCode;
+          _packetType = RTCPPacketTypes::kRtpfbNack;
             _packet.NACK.SenderSSRC = senderSSRC;
             _packet.NACK.MediaSSRC  = mediaSSRC;
 
-            _state = State_RTPFB_NACKItem;
+            _state = ParseState::State_RTPFB_NACKItem;
 
             return true;
         }
@@ -1188,22 +1188,22 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
         case 3:
         {
             // TMMBR
-            _packetType              = kRtcpRtpfbTmmbrCode;
+          _packetType = RTCPPacketTypes::kRtpfbTmmbr;
             _packet.TMMBR.SenderSSRC = senderSSRC;
             _packet.TMMBR.MediaSSRC  = mediaSSRC;
 
-            _state = State_RTPFB_TMMBRItem;
+            _state = ParseState::State_RTPFB_TMMBRItem;
 
             return true;
         }
         case 4:
         {
             // TMMBN
-            _packetType              = kRtcpRtpfbTmmbnCode;
+          _packetType = RTCPPacketTypes::kRtpfbTmmbn;
             _packet.TMMBN.SenderSSRC = senderSSRC;
             _packet.TMMBN.MediaSSRC  = mediaSSRC;
 
-            _state = State_RTPFB_TMMBNItem;
+            _state = ParseState::State_RTPFB_TMMBNItem;
 
             return true;
         }
@@ -1212,7 +1212,7 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
             // RTCP-SR-REQ Rapid Synchronisation of RTP Flows
             // draft-perkins-avt-rapid-rtp-sync-03.txt
             // trigger a new RTCP SR
-            _packetType = kRtcpRtpfbSrReqCode;
+          _packetType = RTCPPacketTypes::kRtpfbSrReq;
 
             // Note: No state transition, SR REQ is empty!
             return true;
@@ -1230,7 +1230,7 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
         {
         case 1:
             // PLI
-            _packetType            = kRtcpPsfbPliCode;
+          _packetType = RTCPPacketTypes::kPsfbPli;
             _packet.PLI.SenderSSRC = senderSSRC;
             _packet.PLI.MediaSSRC  = mediaSSRC;
 
@@ -1238,34 +1238,34 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
             return true;
         case 2:
             // SLI
-            _packetType            = kRtcpPsfbSliCode;
+          _packetType = RTCPPacketTypes::kPsfbSli;
             _packet.SLI.SenderSSRC = senderSSRC;
             _packet.SLI.MediaSSRC  = mediaSSRC;
 
-            _state = State_PSFB_SLIItem;
+            _state = ParseState::State_PSFB_SLIItem;
 
             return true;
         case 3:
-            _packetType             = kRtcpPsfbRpsiCode;
+          _packetType = RTCPPacketTypes::kPsfbRpsi;
             _packet.RPSI.SenderSSRC = senderSSRC;
             _packet.RPSI.MediaSSRC  = mediaSSRC;
 
-            _state = State_PSFB_RPSIItem;
+            _state = ParseState::State_PSFB_RPSIItem;
             return true;
         case 4:
             // FIR
-            _packetType            = kRtcpPsfbFirCode;
+          _packetType = RTCPPacketTypes::kPsfbFir;
             _packet.FIR.SenderSSRC = senderSSRC;
             _packet.FIR.MediaSSRC  = mediaSSRC;
 
-            _state = State_PSFB_FIRItem;
+            _state = ParseState::State_PSFB_FIRItem;
             return true;
         case 15:
-            _packetType                = kRtcpPsfbAppCode;
+          _packetType = RTCPPacketTypes::kPsfbApp;
             _packet.PSFBAPP.SenderSSRC = senderSSRC;
             _packet.PSFBAPP.MediaSSRC  = mediaSSRC;
 
-            _state = State_PSFB_AppItem;
+            _state = ParseState::State_PSFB_AppItem;
             return true;
         default:
             break;
@@ -1298,19 +1298,19 @@ bool RTCPUtility::RTCPParserV2::ParseRPSIItem() {
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
 
     if (length < 4) {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     if (length > 2 + RTCP_RPSI_DATA_SIZE) {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpPsfbRpsiCode;
+    _packetType = RTCPPacketTypes::kPsfbRpsi;
 
     uint8_t padding_bits = *_ptrRTCPData++;
     _packet.RPSI.PayloadType = *_ptrRTCPData++;
@@ -1332,13 +1332,13 @@ RTCPUtility::RTCPParserV2::ParseNACKItem()
 
     if (length < 4)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpRtpfbNackItemCode;
+    _packetType = RTCPPacketTypes::kRtpfbNackItem;
 
     _packet.NACKItem.PacketID = *_ptrRTCPData++ << 8;
     _packet.NACKItem.PacketID += *_ptrRTCPData++;
@@ -1356,41 +1356,41 @@ RTCPUtility::RTCPParserV2::ParsePsfbAppItem()
 
     if (length < 4)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     if(*_ptrRTCPData++ != 'R')
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     if(*_ptrRTCPData++ != 'E')
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     if(*_ptrRTCPData++ != 'M')
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
     if(*_ptrRTCPData++ != 'B')
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
-    _packetType = kRtcpPsfbRembCode;
+    _packetType = RTCPPacketTypes::kPsfbRemb;
-    _state = State_PSFB_REMBItem;
+    _state = ParseState::State_PSFB_REMBItem;
     return true;
 }
 
@@ -1401,7 +1401,7 @@ RTCPUtility::RTCPParserV2::ParsePsfbREMBItem()
 
     if (length < 4)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
@@ -1420,13 +1420,13 @@ RTCPUtility::RTCPParserV2::ParsePsfbREMBItem()
     const ptrdiff_t length_ssrcs = _ptrRTCPBlockEnd - _ptrRTCPData;
     if (length_ssrcs < 4 * _packet.REMBItem.NumberOfSSRCs)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpPsfbRembItemCode;
+    _packetType = RTCPPacketTypes::kPsfbRembItem;
 
     for (int i = 0; i < _packet.REMBItem.NumberOfSSRCs; i++)
     {
@@ -1447,13 +1447,13 @@ RTCPUtility::RTCPParserV2::ParseTMMBRItem()
 
     if (length < 8)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpRtpfbTmmbrItemCode;
+    _packetType = RTCPPacketTypes::kRtpfbTmmbrItem;
 
     _packet.TMMBRItem.SSRC = *_ptrRTCPData++ << 24;
     _packet.TMMBRItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1486,13 +1486,13 @@ RTCPUtility::RTCPParserV2::ParseTMMBNItem()
 
     if (length < 8)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpRtpfbTmmbnItemCode;
+    _packetType = RTCPPacketTypes::kRtpfbTmmbnItem;
 
     _packet.TMMBNItem.SSRC = *_ptrRTCPData++ << 24;
     _packet.TMMBNItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1532,12 +1532,12 @@ RTCPUtility::RTCPParserV2::ParseSLIItem()
 
     if (length < 4)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
-    _packetType = kRtcpPsfbSliItemCode;
+    _packetType = RTCPPacketTypes::kPsfbSliItem;
 
     uint32_t buffer;
     buffer = *_ptrRTCPData++ << 24;
@@ -1561,13 +1561,13 @@ RTCPUtility::RTCPParserV2::ParseFIRItem()
 
     if (length < 8)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
 
-    _packetType = kRtcpPsfbFirItemCode;
+    _packetType = RTCPPacketTypes::kPsfbFirItem;
 
     _packet.FIRItem.SSRC = *_ptrRTCPData++ << 24;
     _packet.FIRItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1604,12 +1604,12 @@ RTCPUtility::RTCPParserV2::ParseAPP( const RTCPCommonHeader& header)
 
     length  = _ptrRTCPBlockEnd - _ptrRTCPData;
 
-    _packetType = kRtcpAppCode;
+    _packetType = RTCPPacketTypes::kApp;
 
     _packet.APP.SubType = header.IC;
     _packet.APP.Name = name;
 
-    _state = State_AppItem;
+    _state = ParseState::State_AppItem;
     return true;
 }
 
@@ -1619,12 +1619,12 @@ RTCPUtility::RTCPParserV2::ParseAPPItem()
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
     if (length < 4)
     {
-        _state = State_TopLevel;
+      _state = ParseState::State_TopLevel;
 
         EndCurrentBlock();
         return false;
     }
-    _packetType = kRtcpAppItemCode;
+    _packetType = RTCPPacketTypes::kAppItem;
 
     if(length > kRtcpAppCode_DATA_SIZE)
     {

webrtc/modules/rtp_rtcp/source/rtcp_utility.h

@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+*  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
- *
+*
- *  Use of this source code is governed by a BSD-style license
+*  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
+*  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
+*  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
+*  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
+*  be found in the AUTHORS file in the root of the source tree.
- */
+*/
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
@@ -42,20 +42,17 @@ class NackStats {
   uint32_t unique_requests_;
 };
 
-    uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac);
+uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac);
 
-    // CNAME
+// CNAME
-    struct RTCPCnameInformation
+struct RTCPCnameInformation {
-    {
   char name[RTCP_CNAME_SIZE];
-    };
+};
-    struct RTCPPacketRR
+struct RTCPPacketRR {
-    {
   uint32_t SenderSSRC;
   uint8_t NumberOfReportBlocks;
-    };
+};
-    struct RTCPPacketSR
+struct RTCPPacketSR {
-    {
   uint32_t SenderSSRC;
   uint8_t NumberOfReportBlocks;
 
@@ -65,9 +62,8 @@ class NackStats {
   uint32_t RTPTimestamp;
   uint32_t SenderPacketCount;
   uint32_t SenderOctetCount;
-    };
+};
-    struct RTCPPacketReportBlockItem
+struct RTCPPacketReportBlockItem {
-    {
   // report block
   uint32_t SSRC;
   uint8_t FractionLost;
@@ -76,44 +72,37 @@ class NackStats {
   uint32_t Jitter;
   uint32_t LastSR;
   uint32_t DelayLastSR;
-    };
+};
-    struct RTCPPacketSDESCName
+struct RTCPPacketSDESCName {
-    {
   // RFC3550
   uint32_t SenderSSRC;
   char CName[RTCP_CNAME_SIZE];
-    };
+};
 
-    struct RTCPPacketExtendedJitterReportItem
+struct RTCPPacketExtendedJitterReportItem {
-    {
   // RFC 5450
   uint32_t Jitter;
-    };
+};
 
-    struct RTCPPacketBYE
+struct RTCPPacketBYE {
-    {
   uint32_t SenderSSRC;
-    };
+};
-    struct RTCPPacketXR
+struct RTCPPacketXR {
-    {
   // RFC 3611
   uint32_t OriginatorSSRC;
-    };
+};
-    struct RTCPPacketXRReceiverReferenceTimeItem
+struct RTCPPacketXRReceiverReferenceTimeItem {
-    {
   // RFC 3611 4.4
   uint32_t NTPMostSignificant;
   uint32_t NTPLeastSignificant;
-    };
+};
-    struct RTCPPacketXRDLRRReportBlockItem
+struct RTCPPacketXRDLRRReportBlockItem {
-    {
   // RFC 3611 4.5
   uint32_t SSRC;
   uint32_t LastRR;
   uint32_t DelayLastRR;
-    };
+};
-    struct RTCPPacketXRVOIPMetricItem
+struct RTCPPacketXRVOIPMetricItem {
-    {
   // RFC 3611 4.7
   uint32_t SSRC;
   uint8_t lossRate;
@@ -136,109 +125,93 @@ class NackStats {
   uint16_t JBnominal;
   uint16_t JBmax;
   uint16_t JBabsMax;
-    };
+};
 
-    struct RTCPPacketRTPFBNACK
+struct RTCPPacketRTPFBNACK {
-    {
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;
-    };
+};
-    struct RTCPPacketRTPFBNACKItem
+struct RTCPPacketRTPFBNACKItem {
-    {
   // RFC4585
   uint16_t PacketID;
   uint16_t BitMask;
-    };
+};
 
-    struct RTCPPacketRTPFBTMMBR
+struct RTCPPacketRTPFBTMMBR {
-    {
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;  // zero!
-    };
+};
-    struct RTCPPacketRTPFBTMMBRItem
+struct RTCPPacketRTPFBTMMBRItem {
-    {
   // RFC5104
   uint32_t SSRC;
   uint32_t MaxTotalMediaBitRate;  // In Kbit/s
   uint32_t MeasuredOverhead;
-    };
+};
 
-    struct RTCPPacketRTPFBTMMBN
+struct RTCPPacketRTPFBTMMBN {
-    {
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;  // zero!
-    };
+};
-    struct RTCPPacketRTPFBTMMBNItem
+struct RTCPPacketRTPFBTMMBNItem {
-    {
   // RFC5104
   uint32_t SSRC;  // "Owner"
   uint32_t MaxTotalMediaBitRate;
   uint32_t MeasuredOverhead;
-    };
+};
 
-    struct RTCPPacketPSFBFIR
+struct RTCPPacketPSFBFIR {
-    {
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;  // zero!
-    };
+};
-    struct RTCPPacketPSFBFIRItem
+struct RTCPPacketPSFBFIRItem {
-    {
   // RFC5104
   uint32_t SSRC;
   uint8_t CommandSequenceNumber;
-    };
+};
 
-    struct RTCPPacketPSFBPLI
+struct RTCPPacketPSFBPLI {
-    {
   // RFC4585
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;
-    };
+};
 
-    struct RTCPPacketPSFBSLI
+struct RTCPPacketPSFBSLI {
-    {
   // RFC4585
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;
-    };
+};
-    struct RTCPPacketPSFBSLIItem
+struct RTCPPacketPSFBSLIItem {
-    {
   // RFC4585
   uint16_t FirstMB;
   uint16_t NumberOfMB;
   uint8_t PictureId;
-    };
+};
-    struct RTCPPacketPSFBRPSI
+struct RTCPPacketPSFBRPSI {
-    {
   // RFC4585
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;
   uint8_t PayloadType;
   uint16_t NumberOfValidBits;
   uint8_t NativeBitString[RTCP_RPSI_DATA_SIZE];
-    };
+};
-    struct RTCPPacketPSFBAPP
+struct RTCPPacketPSFBAPP {
-    {
   uint32_t SenderSSRC;
   uint32_t MediaSSRC;
-    };
+};
-    struct RTCPPacketPSFBREMBItem
+struct RTCPPacketPSFBREMBItem {
-    {
   uint32_t BitRate;
   uint8_t NumberOfSSRCs;
   uint32_t SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
-    };
+};
-    // generic name APP
+// generic name APP
-    struct RTCPPacketAPP
+struct RTCPPacketAPP {
-    {
   uint8_t SubType;
   uint32_t Name;
   uint8_t Data[kRtcpAppCode_DATA_SIZE];
   uint16_t Size;
-    };
+};
 
-    union RTCPPacket
+union RTCPPacket {
-    {
   RTCPPacketRR RR;
   RTCPPacketSR SR;
   RTCPPacketReportBlockItem ReportBlockItem;
@@ -271,82 +244,77 @@ class NackStats {
   RTCPPacketXRVOIPMetricItem XRVOIPMetricItem;
 
   RTCPPacketAPP APP;
-    };
+};
 
-    enum RTCPPacketTypes
+enum class RTCPPacketTypes {
-    {
+  kInvalid,
-        kRtcpNotValidCode,
 
   // RFC3550
-        kRtcpRrCode,
+  kRr,
-        kRtcpSrCode,
+  kSr,
-        kRtcpReportBlockItemCode,
+  kReportBlockItem,
 
-        kRtcpSdesCode,
+  kSdes,
-        kRtcpSdesChunkCode,
+  kSdesChunk,
-        kRtcpByeCode,
+  kBye,
 
   // RFC5450
-        kRtcpExtendedIjCode,
+  kExtendedIj,
-        kRtcpExtendedIjItemCode,
+  kExtendedIjItem,
 
   // RFC4585
-        kRtcpRtpfbNackCode,
+  kRtpfbNack,
-        kRtcpRtpfbNackItemCode,
+  kRtpfbNackItem,
 
-        kRtcpPsfbPliCode,
+  kPsfbPli,
-        kRtcpPsfbRpsiCode,
+  kPsfbRpsi,
-        kRtcpPsfbSliCode,
+  kPsfbSli,
-        kRtcpPsfbSliItemCode,
+  kPsfbSliItem,
-        kRtcpPsfbAppCode,
+  kPsfbApp,
-        kRtcpPsfbRembCode,
+  kPsfbRemb,
-        kRtcpPsfbRembItemCode,
+  kPsfbRembItem,
 
   // RFC5104
-        kRtcpRtpfbTmmbrCode,
+  kRtpfbTmmbr,
-        kRtcpRtpfbTmmbrItemCode,
+  kRtpfbTmmbrItem,
-        kRtcpRtpfbTmmbnCode,
+  kRtpfbTmmbn,
-        kRtcpRtpfbTmmbnItemCode,
+  kRtpfbTmmbnItem,
-        kRtcpPsfbFirCode,
+  kPsfbFir,
-        kRtcpPsfbFirItemCode,
+  kPsfbFirItem,
 
   // draft-perkins-avt-rapid-rtp-sync
-        kRtcpRtpfbSrReqCode,
+  kRtpfbSrReq,
 
   // RFC 3611
-        kRtcpXrHeaderCode,
+  kXrHeader,
-        kRtcpXrReceiverReferenceTimeCode,
+  kXrReceiverReferenceTime,
-        kRtcpXrDlrrReportBlockCode,
+  kXrDlrrReportBlock,
-        kRtcpXrDlrrReportBlockItemCode,
+  kXrDlrrReportBlockItem,
-        kRtcpXrVoipMetricCode,
+  kXrVoipMetric,
 
-        kRtcpAppCode,
+  kApp,
-        kRtcpAppItemCode,
+  kAppItem,
-    };
+};
 
-    struct RTCPRawPacket
+struct RTCPRawPacket {
-    {
   const uint8_t* _ptrPacketBegin;
   const uint8_t* _ptrPacketEnd;
-    };
+};
 
-    struct RTCPModRawPacket
+struct RTCPModRawPacket {
-    {
   uint8_t* _ptrPacketBegin;
   uint8_t* _ptrPacketEnd;
-    };
+};
 
-    struct RTCPCommonHeader
+struct RTCPCommonHeader {
-    {
   uint8_t V;   // Version
   bool P;      // Padding
   uint8_t IC;  // Item count/subtype
   uint8_t PT;  // Packet Type
   uint16_t LengthInOctets;
-    };
+};
 
-    enum RTCPPT
+enum RTCPPT : uint8_t {
-    {
   PT_IJ = 195,
   PT_SR = 200,
   PT_RR = 201,
@@ -356,23 +324,23 @@ class NackStats {
   PT_RTPFB = 205,
   PT_PSFB = 206,
   PT_XR = 207
-    };
+};
 
-    // Extended report blocks, RFC 3611.
+// Extended report blocks, RFC 3611.
-    enum RtcpXrBlockType {
+enum RtcpXrBlockType : uint8_t {
   kBtReceiverReferenceTime = 4,
   kBtDlrr = 5,
   kBtVoipMetric = 7
-    };
+};
 
-    bool RTCPParseCommonHeader( const uint8_t* ptrDataBegin,
+bool RTCPParseCommonHeader(const uint8_t* ptrDataBegin,
                            const uint8_t* ptrDataEnd,
                            RTCPCommonHeader& parsedHeader);
 
-    class RTCPParserV2
+class RTCPParserV2 {
-    {
  public:
-        RTCPParserV2(const uint8_t* rtcpData,
+  RTCPParserV2(
+      const uint8_t* rtcpData,
       size_t rtcpDataLength,
       bool rtcpReducedSizeEnable);  // Set to true, to allow non-compound RTCP!
   ~RTCPParserV2();
@@ -388,8 +356,7 @@ class NackStats {
   RTCPPacketTypes Iterate();
 
  private:
-        enum ParseState
+  enum class ParseState {
-        {
     State_TopLevel,            // Top level packet
     State_ReportBlockItem,     // SR/RR report block
     State_SDESChunk,           // SDES chunk
@@ -478,13 +445,11 @@ class NackStats {
 
   RTCPPacketTypes _packetType;
   RTCPPacket _packet;
-    };
+};
 
-    class RTCPPacketIterator
+class RTCPPacketIterator {
-    {
  public:
-        RTCPPacketIterator(uint8_t* rtcpData,
+  RTCPPacketIterator(uint8_t* rtcpData, size_t rtcpDataLength);
-                            size_t rtcpDataLength);
   ~RTCPPacketIterator();
 
   const RTCPCommonHeader* Begin();
@@ -498,7 +463,7 @@ class NackStats {
   uint8_t* _ptrBlock;
 
   RTCPCommonHeader _header;
-    };
+};
 }  // RTCPUtility
 }  // namespace webrtc
 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc

@@ -556,8 +556,15 @@ int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
 
 // Force a send of an RTCP packet.
 // Normal SR and RR are triggered via the process function.
-int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
+int32_t ModuleRtpRtcpImpl::SendRTCP(RTCPPacketType packet_type) {
-  return rtcp_sender_.SendRTCP(GetFeedbackState(), rtcp_packet_type);
+  return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
+}
+
+// Force a send of an RTCP packet.
+// Normal SR and RR are triggered via the process function.
+int32_t ModuleRtpRtcpImpl::SendCompoundRTCP(
+    const std::set<RTCPPacketType>& packet_types) {
+  return rtcp_sender_.SendCompoundRTCP(GetFeedbackState(), packet_types);
 }
 
 int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h

@@ -161,7 +161,10 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
 
   // Force a send of an RTCP packet.
   // Normal SR and RR are triggered via the process function.
-  int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) override;
+  int32_t SendRTCP(RTCPPacketType rtcpPacketType) override;
+
+  int32_t SendCompoundRTCP(
+      const std::set<RTCPPacketType>& rtcpPacketTypes) override;
 
   int32_t ResetSendDataCountersRTP() override;
 

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc

@@ -373,7 +373,10 @@ TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
   EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
 
   // Receive module sends a FIR and PLI.
-  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli));
+  std::set<RTCPPacketType> packet_types;
+  packet_types.insert(kRtcpFir);
+  packet_types.insert(kRtcpPli);
+  EXPECT_EQ(0, receiver_.impl_->SendCompoundRTCP(packet_types));
   EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
   EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
   // Send module receives the FIR and PLI.

webrtc/test/rtcp_packet_parser.cc

@@ -15,6 +15,8 @@
 namespace webrtc {
 namespace test {
 
+using namespace RTCPUtility;
+
 RtcpPacketParser::RtcpPacketParser() {}
 
 RtcpPacketParser::~RtcpPacketParser() {}
@@ -24,98 +26,97 @@ void RtcpPacketParser::Parse(const void *data, size_t len) {
   RTCPUtility::RTCPParserV2 parser(packet, len, true);
   EXPECT_TRUE(parser.IsValid());
   for (RTCPUtility::RTCPPacketTypes type = parser.Begin();
-      type != RTCPUtility::kRtcpNotValidCode;
+       type != RTCPPacketTypes::kInvalid; type = parser.Iterate()) {
-      type = parser.Iterate()) {
     switch (type) {
-      case RTCPUtility::kRtcpSrCode:
+      case RTCPPacketTypes::kSr:
         sender_report_.Set(parser.Packet().SR);
         break;
-      case RTCPUtility::kRtcpRrCode:
+      case RTCPPacketTypes::kRr:
         receiver_report_.Set(parser.Packet().RR);
         break;
-      case RTCPUtility::kRtcpReportBlockItemCode:
+      case RTCPPacketTypes::kReportBlockItem:
         report_block_.Set(parser.Packet().ReportBlockItem);
         ++report_blocks_per_ssrc_[parser.Packet().ReportBlockItem.SSRC];
         break;
-      case RTCPUtility::kRtcpSdesCode:
+      case RTCPPacketTypes::kSdes:
         sdes_.Set();
         break;
-      case RTCPUtility::kRtcpSdesChunkCode:
+      case RTCPPacketTypes::kSdesChunk:
         sdes_chunk_.Set(parser.Packet().CName);
         break;
-      case RTCPUtility::kRtcpByeCode:
+      case RTCPPacketTypes::kBye:
         bye_.Set(parser.Packet().BYE);
         break;
-      case RTCPUtility::kRtcpAppCode:
+      case RTCPPacketTypes::kApp:
         app_.Set(parser.Packet().APP);
         break;
-      case RTCPUtility::kRtcpAppItemCode:
+      case RTCPPacketTypes::kAppItem:
         app_item_.Set(parser.Packet().APP);
         break;
-      case RTCPUtility::kRtcpExtendedIjCode:
+      case RTCPPacketTypes::kExtendedIj:
         ij_.Set();
         break;
-      case RTCPUtility::kRtcpExtendedIjItemCode:
+      case RTCPPacketTypes::kExtendedIjItem:
         ij_item_.Set(parser.Packet().ExtendedJitterReportItem);
         break;
-      case RTCPUtility::kRtcpPsfbPliCode:
+      case RTCPPacketTypes::kPsfbPli:
         pli_.Set(parser.Packet().PLI);
         break;
-      case RTCPUtility::kRtcpPsfbSliCode:
+      case RTCPPacketTypes::kPsfbSli:
         sli_.Set(parser.Packet().SLI);
         break;
-      case RTCPUtility::kRtcpPsfbSliItemCode:
+      case RTCPPacketTypes::kPsfbSliItem:
         sli_item_.Set(parser.Packet().SLIItem);
         break;
-      case RTCPUtility::kRtcpPsfbRpsiCode:
+      case RTCPPacketTypes::kPsfbRpsi:
         rpsi_.Set(parser.Packet().RPSI);
         break;
-      case RTCPUtility::kRtcpPsfbFirCode:
+      case RTCPPacketTypes::kPsfbFir:
         fir_.Set(parser.Packet().FIR);
         break;
-      case RTCPUtility::kRtcpPsfbFirItemCode:
+      case RTCPPacketTypes::kPsfbFirItem:
         fir_item_.Set(parser.Packet().FIRItem);
         break;
-      case RTCPUtility::kRtcpRtpfbNackCode:
+      case RTCPPacketTypes::kRtpfbNack:
         nack_.Set(parser.Packet().NACK);
         nack_item_.Clear();
         break;
-      case RTCPUtility::kRtcpRtpfbNackItemCode:
+      case RTCPPacketTypes::kRtpfbNackItem:
         nack_item_.Set(parser.Packet().NACKItem);
         break;
-      case RTCPUtility::kRtcpPsfbAppCode:
+      case RTCPPacketTypes::kPsfbApp:
         psfb_app_.Set(parser.Packet().PSFBAPP);
         break;
-      case RTCPUtility::kRtcpPsfbRembItemCode:
+      case RTCPPacketTypes::kPsfbRembItem:
         remb_item_.Set(parser.Packet().REMBItem);
         break;
-      case RTCPUtility::kRtcpRtpfbTmmbrCode:
+      case RTCPPacketTypes::kRtpfbTmmbr:
         tmmbr_.Set(parser.Packet().TMMBR);
         break;
-      case RTCPUtility::kRtcpRtpfbTmmbrItemCode:
+      case RTCPPacketTypes::kRtpfbTmmbrItem:
         tmmbr_item_.Set(parser.Packet().TMMBRItem);
         break;
-      case RTCPUtility::kRtcpRtpfbTmmbnCode:
+      case RTCPPacketTypes::kRtpfbTmmbn:
         tmmbn_.Set(parser.Packet().TMMBN);
         tmmbn_items_.Clear();
         break;
-      case RTCPUtility::kRtcpRtpfbTmmbnItemCode:
+      case RTCPPacketTypes::kRtpfbTmmbnItem:
         tmmbn_items_.Set(parser.Packet().TMMBNItem);
         break;
-      case RTCPUtility::kRtcpXrHeaderCode:
+      case RTCPPacketTypes::kXrHeader:
         xr_header_.Set(parser.Packet().XR);
         dlrr_items_.Clear();
         break;
-      case RTCPUtility::kRtcpXrReceiverReferenceTimeCode:
+      case RTCPPacketTypes::kXrReceiverReferenceTime:
         rrtr_.Set(parser.Packet().XRReceiverReferenceTimeItem);
         break;
-      case RTCPUtility::kRtcpXrDlrrReportBlockCode:
+      case RTCPPacketTypes::kXrDlrrReportBlock:
         dlrr_.Set();
         break;
-      case RTCPUtility::kRtcpXrDlrrReportBlockItemCode:
+      case RTCPPacketTypes::kXrDlrrReportBlockItem:
         dlrr_items_.Set(parser.Packet().XRDLRRReportBlockItem);
         break;
-      case RTCPUtility::kRtcpXrVoipMetricCode:
+      case RTCPPacketTypes::kXrVoipMetric:
         voip_metric_.Set(parser.Packet().XRVOIPMetricItem);
         break;
       default:

webrtc/video/call_perf_tests.cc

@@ -66,9 +66,9 @@ class SyncRtcpObserver : public test::RtpRtcpObserver {
     EXPECT_TRUE(parser.IsValid());
 
     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-         packet_type != RTCPUtility::kRtcpNotValidCode;
+         packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
          packet_type = parser.Iterate()) {
-      if (packet_type == RTCPUtility::kRtcpSrCode) {
+      if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
         const RTCPUtility::RTCPPacket& packet = parser.Packet();
         RtcpMeasurement ntp_rtp_pair(
             packet.SR.NTPMostSignificant,

webrtc/video/end_to_end_tests.cc

@@ -418,8 +418,8 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kRtpfbNack) {
           --nacks_left_;
           break;
         }
@@ -929,12 +929,12 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
       EXPECT_TRUE(parser.IsValid());
 
       for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-           packet_type != RTCPUtility::kRtcpNotValidCode;
+           packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
            packet_type = parser.Iterate()) {
         if (!nack_enabled_)
-          EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
+          EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kRtpfbNack);
 
-        if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbPli) {
           received_pli_ = true;
           break;
         }
@@ -1070,9 +1070,9 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       bool has_report_block = false;
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
+        EXPECT_NE(RTCPUtility::RTCPPacketTypes::kSr, packet_type);
-        if (packet_type == RTCPUtility::kRtcpRrCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
           has_report_block = true;
           break;
         }
@@ -1336,12 +1336,12 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
       bool received_psfb = false;
       bool received_remb = false;
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRemb) {
           const RTCPUtility::RTCPPacket& packet = parser.Packet();
           EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
           received_psfb = true;
-        } else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
+        } else if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRembItem) {
           const RTCPUtility::RTCPPacket& packet = parser.Packet();
           EXPECT_GT(packet.REMBItem.BitRate, 0u);
           EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
@@ -1700,15 +1700,16 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpRrCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
           ++sent_rtcp_rr_;
         } else if (packet_type ==
-                   RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
+                   RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime) {
           ++sent_rtcp_rrtr_;
         }
-        EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
+        EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kSr);
-        EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
+        EXPECT_NE(packet_type,
+                  RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem);
         packet_type = parser.Iterate();
       }
       return SEND_PACKET;
@@ -1719,13 +1720,15 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpSrCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
           ++sent_rtcp_sr_;
-        } else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
+        } else if (packet_type ==
+                   RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem) {
           ++sent_rtcp_dlrr_;
         }
-        EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
+        EXPECT_NE(packet_type,
+                  RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime);
         packet_type = parser.Iterate();
       }
       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&

webrtc/video/video_send_stream_tests.cc

@@ -104,8 +104,8 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpSdesChunkCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
           EXPECT_EQ(parser.Packet().CName.CName, kCName);
           observation_complete_->Set();
         }
@@ -1514,8 +1514,8 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::kRtcpNotValidCode) {
+      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::kRtcpSrCode) {
+        if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
           // Only compare sent media bytes if SenderPacketCount matches the
           // number of sent rtp packets (a new rtp packet could be sent before
           // the rtcp packet).