Add packetization and coding/decoding of feedback message format.

webrtc/modules/rtp_rtcp/source/rtcp_packet.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 74 matching lines @@
   for (uint32_t i = 0; i < 64; ++i) {
     if (input_base10 <= (mantissa_max << i)) {
       exponent = i;
       break;
     }
   }
   *exp = exponent;
   *mantissa = (input_base10 >> exponent);
 }
 
-size_t BlockToHeaderLength(size_t length_in_bytes) {
-  // Length in 32-bit words minus 1.
-  assert(length_in_bytes > 0);
-  assert(length_in_bytes % 4 == 0);
-  return (length_in_bytes / 4) - 1;
-}
-
-// From RFC 3550, RTP: A Transport Protocol for Real-Time Applications.
-//
-// RTP header format.
-//   0                   1                   2                   3
-//   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//  |V=2|P| RC/FMT  |      PT       |             length            |
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-
-void CreateHeader(uint8_t count_or_format,  // Depends on packet type.
-                  uint8_t packet_type,
-                  size_t length,
-                  uint8_t* buffer,
-                  size_t* pos) {
-  assert(length <= 0xffff);
-  const uint8_t kVersion = 2;
-  AssignUWord8(buffer, pos, (kVersion << 6) + count_or_format);
-  AssignUWord8(buffer, pos, packet_type);
-  AssignUWord16(buffer, pos, length);
-}
-
 //  Sender report (SR) (RFC 3550).
 //   0                   1                   2                   3
 //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |V=2|P|    RC   |   PT=SR=200   |             length            |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                         SSRC of sender                        |
 //  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 //  |              NTP timestamp, most significant word             |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |             NTP timestamp, least significant word             |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                         RTP timestamp                         |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                     sender's packet count                     |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                      sender's octet count                     |
 //  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 
 void CreateSenderReport(const RTCPPacketSR& sr,
-                        size_t length,
                         uint8_t* buffer,
                         size_t* pos) {
-  CreateHeader(sr.NumberOfReportBlocks, PT_SR, length, buffer, pos);
   AssignUWord32(buffer, pos, sr.SenderSSRC);
   AssignUWord32(buffer, pos, sr.NTPMostSignificant);
   AssignUWord32(buffer, pos, sr.NTPLeastSignificant);
   AssignUWord32(buffer, pos, sr.RTPTimestamp);
   AssignUWord32(buffer, pos, sr.SenderPacketCount);
   AssignUWord32(buffer, pos, sr.SenderOctetCount);
 }
 
 //  Receiver report (RR), header (RFC 3550).
 //
 //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |V=2|P|    RC   |   PT=RR=201   |             length            |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                     SSRC of packet sender                     |
 //  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 
 void CreateReceiverReport(const RTCPPacketRR& rr,
-                          size_t length,
                           uint8_t* buffer,
                           size_t* pos) {
-  CreateHeader(rr.NumberOfReportBlocks, PT_RR, length, buffer, pos);
   AssignUWord32(buffer, pos, rr.SenderSSRC);
 }
 
 //  Report block (RFC 3550).
 //
 //   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
 //  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 //  |                 SSRC_1 (SSRC of first source)                 |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  | fraction lost |       cumulative number of packets lost       |
@@ skipping 33 matching lines @@
 //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //     .                                                               .
 //     .                                                               .
 //     .                                                               .
 //     |                      inter-arrival jitter                     |
 //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateIj(const std::vector<uint32_t>& ij_items,
               uint8_t* buffer,
               size_t* pos) {
-  size_t length = ij_items.size();
-  CreateHeader(length, PT_IJ, length, buffer, pos);
-  for (std::vector<uint32_t>::const_iterator it = ij_items.begin();
-       it != ij_items.end(); ++it) {
-    AssignUWord32(buffer, pos, *it);
-  }
+  for (uint32_t item : ij_items)
+    AssignUWord32(buffer, pos, item);
 }
 
 // Source Description (SDES) (RFC 3550).
 //
 //         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
 //        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // header |V=2|P|    SC   |  PT=SDES=202  |             length            |
 //        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 // chunk  |                          SSRC/CSRC_1                          |
 //   1    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //        |                           SDES items                          |
 //        |                              ...                              |
 //        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 // chunk  |                          SSRC/CSRC_2                          |
 //   2    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //        |                           SDES items                          |
 //        |                              ...                              |
 //        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 //
 // Canonical End-Point Identifier SDES Item (CNAME)
 //
 //    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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |    CNAME=1    |     length    | user and domain name        ...
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateSdes(const std::vector<Sdes::Chunk>& chunks,
-                size_t length,
                 uint8_t* buffer,
                 size_t* pos) {
-  CreateHeader(chunks.size(), PT_SDES, length, buffer, pos);
   const uint8_t kSdesItemType = 1;
   for (std::vector<Sdes::Chunk>::const_iterator it = chunks.begin();
        it != chunks.end(); ++it) {
     AssignUWord32(buffer, pos, (*it).ssrc);
     AssignUWord8(buffer, pos, kSdesItemType);
     AssignUWord8(buffer, pos, (*it).name.length());
     memcpy(buffer + *pos, (*it).name.data(), (*it).name.length());
     *pos += (*it).name.length();
     memset(buffer + *pos, 0, (*it).null_octets);
     *pos += (*it).null_octets;
   }
 }
 
 // Bye packet (BYE) (RFC 3550).
 //
 //        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|    SC   |   PT=BYE=203  |             length            |
 //       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //       |                           SSRC/CSRC                           |
 //       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //       :                              ...                              :
 //       +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 // (opt) |     length    |               reason for leaving            ...
 //       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateBye(const RTCPPacketBYE& bye,
                const std::vector<uint32_t>& csrcs,
-               size_t length,
                uint8_t* buffer,
                size_t* pos) {
-  CreateHeader(length, PT_BYE, length, buffer, pos);
   AssignUWord32(buffer, pos, bye.SenderSSRC);
   for (uint32_t csrc : csrcs)
     AssignUWord32(buffer, pos, csrc);
 }
 
 // Application-Defined packet (APP) (RFC 3550).
 //
 //   0                   1                   2                   3
 //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |V=2|P| subtype |   PT=APP=204  |             length            |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                           SSRC/CSRC                           |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                          name (ASCII)                         |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                   application-dependent data                ...
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateApp(const RTCPPacketAPP& app,
                uint32_t ssrc,
-               size_t length,
                uint8_t* buffer,
                size_t* pos) {
-  CreateHeader(app.SubType, PT_APP, length, buffer, pos);
   AssignUWord32(buffer, pos, ssrc);
   AssignUWord32(buffer, pos, app.Name);
   memcpy(buffer + *pos, app.Data, app.Size);
   *pos += app.Size;
 }
 
 // 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               |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                  SSRC of packet sender                        |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                  SSRC of media source                         |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   :            Feedback Control Information (FCI)                 :
 //   :
 //
 
 // Picture loss indication (PLI) (RFC 4585).
 //
 // FCI: no feedback control information.
 
 void CreatePli(const RTCPPacketPSFBPLI& pli,
-               size_t length,
                uint8_t* buffer,
                size_t* pos) {
-  const uint8_t kFmt = 1;
-  CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
   AssignUWord32(buffer, pos, pli.SenderSSRC);
   AssignUWord32(buffer, pos, pli.MediaSSRC);
 }
 
 // Slice loss indication (SLI) (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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |            First        |        Number           | PictureID |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateSli(const RTCPPacketPSFBSLI& sli,
                const RTCPPacketPSFBSLIItem& sli_item,
-               size_t length,
                uint8_t* buffer,
                size_t* pos) {
-  const uint8_t kFmt = 2;
-  CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
   AssignUWord32(buffer, pos, sli.SenderSSRC);
   AssignUWord32(buffer, pos, sli.MediaSSRC);
 
   AssignUWord8(buffer, pos, sli_item.FirstMB >> 5);
   AssignUWord8(buffer, pos, (sli_item.FirstMB << 3) +
                             ((sli_item.NumberOfMB >> 10) & 0x07));
   AssignUWord8(buffer, pos, sli_item.NumberOfMB >> 2);
   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,
-                size_t length,
                 uint8_t* buffer,
                 size_t* pos) {
-  const uint8_t kFmt = 1;
-  CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
   AssignUWord32(buffer, pos, nack.SenderSSRC);
   AssignUWord32(buffer, pos, nack.MediaSSRC);
   for (size_t i = start_index; i < end_index; ++i) {
     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:
 //
 //    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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |      PB       |0| Payload Type|    Native RPSI bit string     |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |   defined per codec          ...                | Padding (0) |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateRpsi(const RTCPPacketPSFBRPSI& rpsi,
                 uint8_t padding_bytes,
-                size_t length,
                 uint8_t* buffer,
                 size_t* pos) {
   // Native bit string should be a multiple of 8 bits.
   assert(rpsi.NumberOfValidBits % 8 == 0);
-  const uint8_t kFmt = 3;
-  CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
   AssignUWord32(buffer, pos, rpsi.SenderSSRC);
   AssignUWord32(buffer, pos, rpsi.MediaSSRC);
   AssignUWord8(buffer, pos, padding_bytes * 8);
   AssignUWord8(buffer, pos, rpsi.PayloadType);
   memcpy(buffer + *pos, rpsi.NativeBitString, rpsi.NumberOfValidBits / 8);
   *pos += rpsi.NumberOfValidBits / 8;
   memset(buffer + *pos, 0, padding_bytes);
   *pos += padding_bytes;
 }
 
 // Full intra request (FIR) (RFC 5104).
 //
 // 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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                              SSRC                             |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   | Seq nr.       |    Reserved                                   |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateFir(const RTCPPacketPSFBFIR& fir,
                const RTCPPacketPSFBFIRItem& fir_item,
-               size_t length,
                uint8_t* buffer,
                size_t* pos) {
-  const uint8_t kFmt = 4;
-  CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
   AssignUWord32(buffer, pos, fir.SenderSSRC);
   AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
   AssignUWord32(buffer, pos, fir_item.SSRC);
   AssignUWord8(buffer, pos, fir_item.CommandSequenceNumber);
   AssignUWord24(buffer, pos, 0);
 }
 
 void CreateTmmbrItem(const RTCPPacketRTPFBTMMBRItem& tmmbr_item,
                      uint8_t* buffer,
                      size_t* pos) {
@@ skipping 17 matching lines @@
 //    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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                              SSRC                             |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   | MxTBR Exp |  MxTBR Mantissa                 |Measured Overhead|
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateTmmbr(const RTCPPacketRTPFBTMMBR& tmmbr,
                  const RTCPPacketRTPFBTMMBRItem& tmmbr_item,
-                 size_t length,
                  uint8_t* buffer,
                  size_t* pos) {
-  const uint8_t kFmt = 3;
-  CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
   AssignUWord32(buffer, pos, tmmbr.SenderSSRC);
   AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
   CreateTmmbrItem(tmmbr_item, buffer, pos);
 }
 
 // Temporary Maximum Media Stream Bit Rate Notification (TMMBN) (RFC 5104).
 //
 // 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
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                              SSRC                             |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   | MxTBR Exp |  MxTBR Mantissa                 |Measured Overhead|
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateTmmbn(const RTCPPacketRTPFBTMMBN& tmmbn,
                  const std::vector<RTCPPacketRTPFBTMMBRItem>& tmmbn_items,
-                 size_t length,
                  uint8_t* buffer,
                  size_t* pos) {
-  const uint8_t kFmt = 4;
-  CreateHeader(kFmt, PT_RTPFB, length, buffer, pos);
   AssignUWord32(buffer, pos, tmmbn.SenderSSRC);
   AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
   for (uint8_t i = 0; i < tmmbn_items.size(); ++i) {
     CreateTmmbrItem(tmmbn_items[i], buffer, pos);
   }
 }
 
 // Receiver Estimated Max Bitrate (REMB) (draft-alvestrand-rmcat-remb).
 //
 //    0                   1                   2                   3
 //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |V=2|P| FMT=15  |   PT=206      |             length            |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                  SSRC of packet sender                        |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |                  SSRC of media source                         |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |  Unique identifier 'R' 'E' 'M' 'B'                            |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |  Num SSRC     | BR Exp    |  BR Mantissa                      |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |   SSRC feedback                                               |
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   |  ...                                                          |
 
 void CreateRemb(const RTCPPacketPSFBAPP& remb,
                 const RTCPPacketPSFBREMBItem& remb_item,
-                size_t length,
                 uint8_t* buffer,
                 size_t* pos) {
   uint32_t mantissa = 0;
   uint8_t exp = 0;
   ComputeMantissaAnd6bitBase2Exponent(remb_item.BitRate, 18, &mantissa, &exp);
 
-  const uint8_t kFmt = 15;
-  CreateHeader(kFmt, PT_PSFB, length, buffer, pos);
   AssignUWord32(buffer, pos, remb.SenderSSRC);
   AssignUWord32(buffer, pos, kUnusedMediaSourceSsrc0);
   AssignUWord8(buffer, pos, 'R');
   AssignUWord8(buffer, pos, 'E');
   AssignUWord8(buffer, pos, 'M');
   AssignUWord8(buffer, pos, 'B');
   AssignUWord8(buffer, pos, remb_item.NumberOfSSRCs);
   AssignUWord8(buffer, pos, (exp << 2) + ((mantissa >> 16) & 0x03));
   AssignUWord8(buffer, pos, mantissa >> 8);
   AssignUWord8(buffer, pos, mantissa);
@@ skipping 10 matching lines @@
 //   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|reserved |   PT=XR=207   |             length            |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  |                              SSRC                             |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  :                         report blocks                         :
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 void CreateXrHeader(const RTCPPacketXR& header,
-                    size_t length,
                     uint8_t* buffer,
                     size_t* pos) {
-  CreateHeader(0U, PT_XR, length, buffer, pos);
   AssignUWord32(buffer, pos, header.OriginatorSSRC);
 }
 
 void CreateXrBlockHeader(uint8_t block_type,
                          uint16_t block_length,
                          uint8_t* buffer,
                          size_t* pos) {
   AssignUWord8(buffer, pos, block_type);
   AssignUWord8(buffer, pos, 0);
   AssignUWord16(buffer, pos, block_length);
@@ skipping 176 matching lines @@
 bool RtcpPacket::OnBufferFull(uint8_t* packet,
                               size_t* index,
                               RtcpPacket::PacketReadyCallback* callback) const {
   if (*index == 0)
     return false;
   callback->OnPacketReady(packet, *index);
   *index = 0;
   return true;
 }
 
+size_t RtcpPacket::HeaderLength() const {
+  size_t length_in_bytes = BlockLength();
+  // Length in 32-bit words minus 1.
+  assert(length_in_bytes > 0);
+  return ((length_in_bytes + 3) / 4) - 1;
+}
+
+// From RFC 3550, RTP: A Transport Protocol for Real-Time Applications.
+//
+// RTP header format.
+//   0                   1                   2                   3
+//   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |V=2|P| RC/FMT  |      PT       |             length            |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+void RtcpPacket::CreateHeader(
+    uint8_t count_or_format,  // Depends on packet type.
+    uint8_t packet_type,
+    size_t length,
+    uint8_t* buffer,
+    size_t* pos) const {
+  assert(length <= 0xffff);
+  const uint8_t kVersion = 2;
+  AssignUWord8(buffer, pos, (kVersion << 6) + count_or_format);
+  AssignUWord8(buffer, pos, packet_type);
+  AssignUWord16(buffer, pos, length);
+}
+
 bool Empty::Create(uint8_t* packet,
                    size_t* index,
                    size_t max_length,
                    RtcpPacket::PacketReadyCallback* callback) const {
   return true;
 }
 
+size_t Empty::BlockLength() const {
+  return 0;
+}
+
 bool SenderReport::Create(uint8_t* packet,
                           size_t* index,
                           size_t max_length,
                           RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateSenderReport(sr_, BlockToHeaderLength(BlockLength()), packet, index);
+  CreateHeader(sr_.NumberOfReportBlocks, PT_SR, HeaderLength(), packet, index);
+  CreateSenderReport(sr_, packet, index);
   CreateReportBlocks(report_blocks_, packet, index);
   return true;
 }
 
 bool SenderReport::WithReportBlock(ReportBlock* block) {
   assert(block);
   if (report_blocks_.size() >= kMaxNumberOfReportBlocks) {
     LOG(LS_WARNING) << "Max report blocks reached.";
     return false;
   }
   report_blocks_.push_back(block->report_block_);
   sr_.NumberOfReportBlocks = report_blocks_.size();
   return true;
 }
 
 bool ReceiverReport::Create(uint8_t* packet,
                             size_t* index,
                             size_t max_length,
                             RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateReceiverReport(rr_, BlockToHeaderLength(BlockLength()), packet, index);
+  CreateHeader(rr_.NumberOfReportBlocks, PT_RR, HeaderLength(), packet, index);
+  CreateReceiverReport(rr_, packet, index);
   CreateReportBlocks(report_blocks_, packet, index);
   return true;
 }
 
 bool ReceiverReport::WithReportBlock(ReportBlock* block) {
   assert(block);
   if (report_blocks_.size() >= kMaxNumberOfReportBlocks) {
     LOG(LS_WARNING) << "Max report blocks reached.";
     return false;
   }
   report_blocks_.push_back(block->report_block_);
   rr_.NumberOfReportBlocks = report_blocks_.size();
   return true;
 }
 
 bool Ij::Create(uint8_t* packet,
                 size_t* index,
                 size_t max_length,
                 RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
+  size_t length = ij_items_.size();
+  CreateHeader(length, PT_IJ, length, packet, index);
   CreateIj(ij_items_, packet, index);
   return true;
 }
 
 bool Ij::WithJitterItem(uint32_t jitter) {
   if (ij_items_.size() >= kMaxNumberOfIjItems) {
     LOG(LS_WARNING) << "Max inter-arrival jitter items reached.";
     return false;
   }
   ij_items_.push_back(jitter);
   return true;
 }
 
 bool Sdes::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
                   RtcpPacket::PacketReadyCallback* callback) const {
   assert(!chunks_.empty());
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateSdes(chunks_, BlockToHeaderLength(BlockLength()), packet, index);
+  CreateHeader(chunks_.size(), PT_SDES, HeaderLength(), packet, index);
+  CreateSdes(chunks_, packet, index);
   return true;
 }
 
 bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) {
   assert(cname.length() <= 0xff);
   if (chunks_.size() >= kMaxNumberOfChunks) {
     LOG(LS_WARNING) << "Max SDES chunks reached.";
     return false;
   }
   // In each chunk, the list of items must be terminated by one or more null
@@ skipping 20 matching lines @@
 }
 
 bool Bye::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
                  RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateBye(bye_, csrcs_, BlockToHeaderLength(BlockLength()), packet, index);
+  size_t length = HeaderLength();
+  CreateHeader(length, PT_BYE, length, packet, index);
+  CreateBye(bye_, csrcs_, packet, index);
   return true;
 }
 
 bool Bye::WithCsrc(uint32_t csrc) {
   if (csrcs_.size() >= kMaxNumberOfCsrcs) {
     LOG(LS_WARNING) << "Max CSRC size reached.";
     return false;
   }
   csrcs_.push_back(csrc);
   return true;
 }
 
 bool App::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
                  RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateApp(app_, ssrc_, BlockToHeaderLength(BlockLength()), packet, index);
+  CreateHeader(app_.SubType, PT_APP, HeaderLength(), packet, index);
+  CreateApp(app_, ssrc_, packet, index);
   return true;
 }
 
 bool Pli::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
                  RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreatePli(pli_, BlockToHeaderLength(BlockLength()), packet, index);
+  const uint8_t kFmt = 1;
+  CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
+  CreatePli(pli_, packet, index);
   return true;
 }
 
 bool Sli::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
                  RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateSli(sli_, sli_item_, BlockToHeaderLength(BlockLength()), packet, index);
+  const uint8_t kFmt = 2;
+  CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
+  CreateSli(sli_, sli_item_, packet, index);
   return true;
 }
 
 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,
-               BlockToHeaderLength((num_nack_fields * 4) + kCommonFbFmtLength),
                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;
@@ skipping 13 matching lines @@
 
 bool Rpsi::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
                   RtcpPacket::PacketReadyCallback* callback) const {
   assert(rpsi_.NumberOfValidBits > 0);
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateRpsi(rpsi_, padding_bytes_, BlockToHeaderLength(BlockLength()), packet,
-             index);
+  const uint8_t kFmt = 3;
+  CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
+  CreateRpsi(rpsi_, padding_bytes_, packet, index);
   return true;
 }
 
 void Rpsi::WithPictureId(uint64_t picture_id) {
   const uint32_t kPidBits = 7;
   const uint64_t k7MsbZeroMask = 0x1ffffffffffffffULL;
   uint8_t required_bytes = 0;
   uint64_t shifted_pid = picture_id;
   do {
     ++required_bytes;
@@ skipping 18 matching lines @@
 }
 
 bool Fir::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
                  RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateFir(fir_, fir_item_, BlockToHeaderLength(BlockLength()), packet, index);
+  const uint8_t kFmt = 4;
+  CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
+  CreateFir(fir_, fir_item_, packet, index);
   return true;
 }
 
 bool Remb::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
                   RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateRemb(remb_, remb_item_, BlockToHeaderLength(BlockLength()), packet,
-             index);
+  const uint8_t kFmt = 15;
+  CreateHeader(kFmt, PT_PSFB, HeaderLength(), packet, index);
+  CreateRemb(remb_, remb_item_, packet, index);
   return true;
 }
 
 void Remb::AppliesTo(uint32_t ssrc) {
   if (remb_item_.NumberOfSSRCs >= kMaxNumberOfSsrcs) {
     LOG(LS_WARNING) << "Max number of REMB feedback SSRCs reached.";
     return;
   }
   remb_item_.SSRCs[remb_item_.NumberOfSSRCs++] = ssrc;
 }
 
 bool Tmmbr::Create(uint8_t* packet,
                    size_t* index,
                    size_t max_length,
                    RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateTmmbr(tmmbr_, tmmbr_item_, BlockToHeaderLength(BlockLength()), packet,
-              index);
+  const uint8_t kFmt = 3;
+  CreateHeader(kFmt, PT_RTPFB, HeaderLength(), packet, index);
+  CreateTmmbr(tmmbr_, tmmbr_item_, packet, index);
   return true;
 }
 
 bool Tmmbn::WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead) {
   assert(overhead <= 0x1ff);
   if (tmmbn_items_.size() >= kMaxNumberOfTmmbrs) {
     LOG(LS_WARNING) << "Max TMMBN size reached.";
     return false;
   }
   RTCPPacketRTPFBTMMBRItem tmmbn_item;
   tmmbn_item.SSRC = ssrc;
   tmmbn_item.MaxTotalMediaBitRate = bitrate_kbps;
   tmmbn_item.MeasuredOverhead = overhead;
   tmmbn_items_.push_back(tmmbn_item);
   return true;
 }
 
 bool Tmmbn::Create(uint8_t* packet,
                    size_t* index,
                    size_t max_length,
                    RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateTmmbn(tmmbn_, tmmbn_items_, BlockToHeaderLength(BlockLength()), packet,
-              index);
+  const uint8_t kFmt = 4;
+  CreateHeader(kFmt, PT_RTPFB, HeaderLength(), packet, index);
+  CreateTmmbn(tmmbn_, tmmbn_items_, packet, index);
   return true;
 }
 
 bool Xr::Create(uint8_t* packet,
                 size_t* index,
                 size_t max_length,
                 RtcpPacket::PacketReadyCallback* callback) const {
   while (*index + BlockLength() > max_length) {
     if (!OnBufferFull(packet, index, callback))
       return false;
   }
-  CreateXrHeader(xr_header_, BlockToHeaderLength(BlockLength()), packet, index);
+  CreateHeader(0U, PT_XR, HeaderLength(), packet, index);
+  CreateXrHeader(xr_header_, packet, index);
   CreateRrtr(rrtr_blocks_, packet, index);
   CreateDlrr(dlrr_blocks_, packet, index);
   CreateVoipMetric(voip_metric_blocks_, packet, index);
   return true;
 }
 
 bool Xr::WithRrtr(Rrtr* rrtr) {
   assert(rrtr);
   if (rrtr_blocks_.size() >= kMaxNumberOfRrtrBlocks) {
     LOG(LS_WARNING) << "Max RRTR blocks reached.";
@@ skipping 78 matching lines @@
   return length_;
 }
 
 void RawPacket::SetLength(size_t length) {
   assert(length <= buffer_length_);
   length_ = length;
 }
 
 }  // namespace rtcp
 }  // namespace webrtc