src/third_party/webrtc/modules/rtp_rtcp/source/rtp_utility.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
  12
  13 #include <assert.h>
  14 #include <math.h>  // ceil
  15 #include <string.h>  // memcpy
  16
  17 #if defined(_WIN32)
  18 // Order for these headers are important
  19 #include <Windows.h>  // FILETIME
  20
  21 #include <WinSock.h>  // timeval
  22
  23 #include <MMSystem.h>  // timeGetTime
  24 #elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
  25 #include <sys/time.h>  // gettimeofday
  26 #include <time.h>
  27 #endif
  28 #if (defined(_DEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
  29 #include <stdio.h>
  30 #endif
  31
  32 #include "webrtc/system_wrappers/interface/tick_util.h"
  33 #include "webrtc/system_wrappers/interface/logging.h"
  34
  35 #if (defined(_DEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
  36 #define DEBUG_PRINT(...)           \
  37   {                                \
  38     char msg[256];                 \
  39     sprintf(msg, __VA_ARGS__);     \
  40     OutputDebugString(msg);        \
  41   }
  42 #else
  43 // special fix for visual 2003
  44 #define DEBUG_PRINT(exp)        ((void)0)
  45 #endif  // defined(_DEBUG) && defined(_WIN32)
  46
  47 namespace webrtc {
  48
  49 RtpData* NullObjectRtpData() {
  50   static NullRtpData null_rtp_data;
  51   return &null_rtp_data;
  52 }
  53
  54 RtpFeedback* NullObjectRtpFeedback() {
  55   static NullRtpFeedback null_rtp_feedback;
  56   return &null_rtp_feedback;
  57 }
  58
  59 RtpAudioFeedback* NullObjectRtpAudioFeedback() {
  60   static NullRtpAudioFeedback null_rtp_audio_feedback;
  61   return &null_rtp_audio_feedback;
  62 }
  63
  64 ReceiveStatistics* NullObjectReceiveStatistics() {
  65   static NullReceiveStatistics null_receive_statistics;
  66   return &null_receive_statistics;
  67 }
  68
  69 namespace ModuleRTPUtility {
  70
  71 enum {
  72   kRtcpExpectedVersion = 2,
  73   kRtcpMinHeaderLength = 4,
  74   kRtcpMinParseLength = 8,
  75
  76   kRtpExpectedVersion = 2,
  77   kRtpMinParseLength = 12
  78 };
  79
  80 /*
  81  * Time routines.
  82  */
  83
  84 uint32_t GetCurrentRTP(Clock* clock, uint32_t freq) {
  85   const bool use_global_clock = (clock == NULL);
  86   Clock* local_clock = clock;
  87   if (use_global_clock) {
  88     local_clock = Clock::GetRealTimeClock();
  89   }
  90   uint32_t secs = 0, frac = 0;
  91   local_clock->CurrentNtp(secs, frac);
  92   if (use_global_clock) {
  93     delete local_clock;
  94   }
  95   return ConvertNTPTimeToRTP(secs, frac, freq);
  96 }
  97
  98 uint32_t ConvertNTPTimeToRTP(uint32_t NTPsec, uint32_t NTPfrac, uint32_t freq) {
  99   float ftemp = (float)NTPfrac / (float)NTP_FRAC;
 100   uint32_t tmp = (uint32_t)(ftemp * freq);
 101   return NTPsec * freq + tmp;
 102 }
 103
 104 uint32_t ConvertNTPTimeToMS(uint32_t NTPsec, uint32_t NTPfrac) {
 105   int freq = 1000;
 106   float ftemp = (float)NTPfrac / (float)NTP_FRAC;
 107   uint32_t tmp = (uint32_t)(ftemp * freq);
 108   uint32_t MStime = NTPsec * freq + tmp;
 109   return MStime;
 110 }
 111
 112 /*
 113  * Misc utility routines
 114  */
 115
 116 #if defined(_WIN32)
 117 bool StringCompare(const char* str1, const char* str2,
 118                    const uint32_t length) {
 119   return (_strnicmp(str1, str2, length) == 0) ? true : false;
 120 }
 121 #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
 122 bool StringCompare(const char* str1, const char* str2,
 123                    const uint32_t length) {
 124   return (strncasecmp(str1, str2, length) == 0) ? true : false;
 125 }
 126 #endif
 127
 128 /* for RTP/RTCP
 129     All integer fields are carried in network byte order, that is, most
 130     significant byte (octet) first.  AKA big-endian.
 131 */
 132 void AssignUWord32ToBuffer(uint8_t* dataBuffer, uint32_t value) {
 133 #if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
 134   dataBuffer[0] = static_cast<uint8_t>(value >> 24);
 135   dataBuffer[1] = static_cast<uint8_t>(value >> 16);
 136   dataBuffer[2] = static_cast<uint8_t>(value >> 8);
 137   dataBuffer[3] = static_cast<uint8_t>(value);
 138 #else
 139   uint32_t* ptr = reinterpret_cast<uint32_t*>(dataBuffer);
 140   ptr[0] = value;
 141 #endif
 142 }
 143
 144 void AssignUWord24ToBuffer(uint8_t* dataBuffer, uint32_t value) {
 145 #if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
 146   dataBuffer[0] = static_cast<uint8_t>(value >> 16);
 147   dataBuffer[1] = static_cast<uint8_t>(value >> 8);
 148   dataBuffer[2] = static_cast<uint8_t>(value);
 149 #else
 150   dataBuffer[0] = static_cast<uint8_t>(value);
 151   dataBuffer[1] = static_cast<uint8_t>(value >> 8);
 152   dataBuffer[2] = static_cast<uint8_t>(value >> 16);
 153 #endif
 154 }
 155
 156 void AssignUWord16ToBuffer(uint8_t* dataBuffer, uint16_t value) {
 157 #if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
 158   dataBuffer[0] = static_cast<uint8_t>(value >> 8);
 159   dataBuffer[1] = static_cast<uint8_t>(value);
 160 #else
 161   uint16_t* ptr = reinterpret_cast<uint16_t*>(dataBuffer);
 162   ptr[0] = value;
 163 #endif
 164 }
 165
 166 uint16_t BufferToUWord16(const uint8_t* dataBuffer) {
 167 #if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
 168   return (dataBuffer[0] << 8) + dataBuffer[1];
 169 #else
 170   return *reinterpret_cast<const uint16_t*>(dataBuffer);
 171 #endif
 172 }
 173
 174 uint32_t BufferToUWord24(const uint8_t* dataBuffer) {
 175   return (dataBuffer[0] << 16) + (dataBuffer[1] << 8) + dataBuffer[2];
 176 }
 177
 178 uint32_t BufferToUWord32(const uint8_t* dataBuffer) {
 179 #if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
 180   return (dataBuffer[0] << 24) + (dataBuffer[1] << 16) + (dataBuffer[2] << 8) +
 181       dataBuffer[3];
 182 #else
 183   return *reinterpret_cast<const uint32_t*>(dataBuffer);
 184 #endif
 185 }
 186
 187 uint32_t pow2(uint8_t exp) {
 188   return 1 << exp;
 189 }
 190
 191 void RTPPayload::SetType(RtpVideoCodecTypes videoType) {
 192   type = videoType;
 193
 194   switch (type) {
 195     case kRtpVideoGeneric:
 196       break;
 197     case kRtpVideoVp8: {
 198       info.VP8.nonReferenceFrame = false;
 199       info.VP8.beginningOfPartition = false;
 200       info.VP8.partitionID = 0;
 201       info.VP8.hasPictureID = false;
 202       info.VP8.hasTl0PicIdx = false;
 203       info.VP8.hasTID = false;
 204       info.VP8.hasKeyIdx = false;
 205       info.VP8.pictureID = -1;
 206       info.VP8.tl0PicIdx = -1;
 207       info.VP8.tID = -1;
 208       info.VP8.layerSync = false;
 209       info.VP8.frameWidth = 0;
 210       info.VP8.frameHeight = 0;
 211       break;
 212     }
 213     default:
 214       break;
 215   }
 216 }
 217
 218 RTPHeaderParser::RTPHeaderParser(const uint8_t* rtpData,
 219                                  const uint32_t rtpDataLength)
 220   : _ptrRTPDataBegin(rtpData),
 221     _ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
 222 }
 223
 224 RTPHeaderParser::~RTPHeaderParser() {
 225 }
 226
 227 bool RTPHeaderParser::RTCP() const {
 228   // 72 to 76 is reserved for RTP
 229   // 77 to 79 is not reserver but  they are not assigned we will block them
 230   // for RTCP 200 SR  == marker bit + 72
 231   // for RTCP 204 APP == marker bit + 76
 232   /*
 233   *       RTCP
 234   *
 235   * FIR      full INTRA-frame request             192     [RFC2032]   supported
 236   * NACK     negative acknowledgement             193     [RFC2032]
 237   * IJ       Extended inter-arrival jitter report 195     [RFC-ietf-avt-rtp-toff
 238   * set-07.txt] http://tools.ietf.org/html/draft-ietf-avt-rtp-toffset-07
 239   * SR       sender report                        200     [RFC3551]   supported
 240   * RR       receiver report                      201     [RFC3551]   supported
 241   * SDES     source description                   202     [RFC3551]   supported
 242   * BYE      goodbye                              203     [RFC3551]   supported
 243   * APP      application-defined                  204     [RFC3551]   ignored
 244   * RTPFB    Transport layer FB message           205     [RFC4585]   supported
 245   * PSFB     Payload-specific FB message          206     [RFC4585]   supported
 246   * XR       extended report                      207     [RFC3611]   supported
 247   */
 248
 249   /* 205       RFC 5104
 250    * FMT 1      NACK       supported
 251    * FMT 2      reserved
 252    * FMT 3      TMMBR      supported
 253    * FMT 4      TMMBN      supported
 254    */
 255
 256   /* 206      RFC 5104
 257   * FMT 1:     Picture Loss Indication (PLI)                      supported
 258   * FMT 2:     Slice Lost Indication (SLI)
 259   * FMT 3:     Reference Picture Selection Indication (RPSI)
 260   * FMT 4:     Full Intra Request (FIR) Command                   supported
 261   * FMT 5:     Temporal-Spatial Trade-off Request (TSTR)
 262   * FMT 6:     Temporal-Spatial Trade-off Notification (TSTN)
 263   * FMT 7:     Video Back Channel Message (VBCM)
 264   * FMT 15:    Application layer FB message
 265   */
 266
 267   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 268   if (length < kRtcpMinHeaderLength) {
 269     return false;
 270   }
 271
 272   const uint8_t V  = _ptrRTPDataBegin[0] >> 6;
 273   if (V != kRtcpExpectedVersion) {
 274     return false;
 275   }
 276
 277   const uint8_t  payloadType = _ptrRTPDataBegin[1];
 278   bool RTCP = false;
 279   switch (payloadType) {
 280     case 192:
 281       RTCP = true;
 282       break;
 283     case 193:
 284       // not supported
 285       // pass through and check for a potential RTP packet
 286       break;
 287     case 195:
 288     case 200:
 289     case 201:
 290     case 202:
 291     case 203:
 292     case 204:
 293     case 205:
 294     case 206:
 295     case 207:
 296       RTCP = true;
 297       break;
 298   }
 299   return RTCP;
 300 }
 301
 302 bool RTPHeaderParser::ParseRtcp(RTPHeader* header) const {
 303   assert(header != NULL);
 304
 305   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 306   if (length < kRtcpMinParseLength) {
 307     return false;
 308   }
 309
 310   const uint8_t V = _ptrRTPDataBegin[0] >> 6;
 311   if (V != kRtcpExpectedVersion) {
 312     return false;
 313   }
 314
 315   const uint8_t PT = _ptrRTPDataBegin[1];
 316   const uint16_t len = (_ptrRTPDataBegin[2] << 8) + _ptrRTPDataBegin[3];
 317   const uint8_t* ptr = &_ptrRTPDataBegin[4];
 318
 319   uint32_t SSRC = *ptr++ << 24;
 320   SSRC += *ptr++ << 16;
 321   SSRC += *ptr++ << 8;
 322   SSRC += *ptr++;
 323
 324   header->payloadType  = PT;
 325   header->ssrc         = SSRC;
 326   header->headerLength = 4 + (len << 2);
 327
 328   return true;
 329 }
 330
 331 bool RTPHeaderParser::Parse(RTPHeader& header,
 332                             RtpHeaderExtensionMap* ptrExtensionMap) const {
 333   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 334   if (length < kRtpMinParseLength) {
 335     return false;
 336   }
 337
 338   // Version
 339   const uint8_t V  = _ptrRTPDataBegin[0] >> 6;
 340   // Padding
 341   const bool          P  = ((_ptrRTPDataBegin[0] & 0x20) == 0) ? false : true;
 342   // eXtension
 343   const bool          X  = ((_ptrRTPDataBegin[0] & 0x10) == 0) ? false : true;
 344   const uint8_t CC = _ptrRTPDataBegin[0] & 0x0f;
 345   const bool          M  = ((_ptrRTPDataBegin[1] & 0x80) == 0) ? false : true;
 346
 347   const uint8_t PT = _ptrRTPDataBegin[1] & 0x7f;
 348
 349   const uint16_t sequenceNumber = (_ptrRTPDataBegin[2] << 8) +
 350       _ptrRTPDataBegin[3];
 351
 352   const uint8_t* ptr = &_ptrRTPDataBegin[4];
 353
 354   uint32_t RTPTimestamp = *ptr++ << 24;
 355   RTPTimestamp += *ptr++ << 16;
 356   RTPTimestamp += *ptr++ << 8;
 357   RTPTimestamp += *ptr++;
 358
 359   uint32_t SSRC = *ptr++ << 24;
 360   SSRC += *ptr++ << 16;
 361   SSRC += *ptr++ << 8;
 362   SSRC += *ptr++;
 363
 364   if (V != kRtpExpectedVersion) {
 365     return false;
 366   }
 367
 368   const uint8_t CSRCocts = CC * 4;
 369
 370   if ((ptr + CSRCocts) > _ptrRTPDataEnd) {
 371     return false;
 372   }
 373
 374   header.markerBit      = M;
 375   header.payloadType    = PT;
 376   header.sequenceNumber = sequenceNumber;
 377   header.timestamp      = RTPTimestamp;
 378   header.ssrc           = SSRC;
 379   header.numCSRCs       = CC;
 380   header.paddingLength  = P ? *(_ptrRTPDataEnd - 1) : 0;
 381
 382   for (unsigned int i = 0; i < CC; ++i) {
 383     uint32_t CSRC = *ptr++ << 24;
 384     CSRC += *ptr++ << 16;
 385     CSRC += *ptr++ << 8;
 386     CSRC += *ptr++;
 387     header.arrOfCSRCs[i] = CSRC;
 388   }
 389
 390   header.headerLength   = 12 + CSRCocts;
 391
 392   // If in effect, MAY be omitted for those packets for which the offset
 393   // is zero.
 394   header.extension.hasTransmissionTimeOffset = false;
 395   header.extension.transmissionTimeOffset = 0;
 396
 397   // May not be present in packet.
 398   header.extension.hasAbsoluteSendTime = false;
 399   header.extension.absoluteSendTime = 0;
 400
 401   // May not be present in packet.
 402   header.extension.hasAudioLevel = false;
 403   header.extension.audioLevel = 0;
 404
 405   if (X) {
 406     /* RTP header extension, RFC 3550.
 407      0                   1                   2                   3
 408      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
 409     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 410     |      defined by profile       |           length              |
 411     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 412     |                        header extension                       |
 413     |                             ....                              |
 414     */
 415     const ptrdiff_t remain = _ptrRTPDataEnd - ptr;
 416     if (remain < 4) {
 417       return false;
 418     }
 419
 420     header.headerLength += 4;
 421
 422     uint16_t definedByProfile = *ptr++ << 8;
 423     definedByProfile += *ptr++;
 424
 425     uint16_t XLen = *ptr++ << 8;
 426     XLen += *ptr++; // in 32 bit words
 427     XLen *= 4; // in octs
 428
 429     if (remain < (4 + XLen)) {
 430       return false;
 431     }
 432     if (definedByProfile == kRtpOneByteHeaderExtensionId) {
 433       const uint8_t* ptrRTPDataExtensionEnd = ptr + XLen;
 434       ParseOneByteExtensionHeader(header,
 435                                   ptrExtensionMap,
 436                                   ptrRTPDataExtensionEnd,
 437                                   ptr);
 438     }
 439     header.headerLength += XLen;
 440   }
 441   return true;
 442 }
 443
 444 void RTPHeaderParser::ParseOneByteExtensionHeader(
 445     RTPHeader& header,
 446     const RtpHeaderExtensionMap* ptrExtensionMap,
 447     const uint8_t* ptrRTPDataExtensionEnd,
 448     const uint8_t* ptr) const {
 449   if (!ptrExtensionMap) {
 450     return;
 451   }
 452
 453   while (ptrRTPDataExtensionEnd - ptr > 0) {
 454     //  0
 455     //  0 1 2 3 4 5 6 7
 456     // +-+-+-+-+-+-+-+-+
 457     // |  ID   |  len  |
 458     // +-+-+-+-+-+-+-+-+
 459
 460     // Note that 'len' is the header extension element length, which is the
 461     // number of bytes - 1.
 462     const uint8_t id = (*ptr & 0xf0) >> 4;
 463     const uint8_t len = (*ptr & 0x0f);
 464     ptr++;
 465
 466     if (id == 15) {
 467       LOG(LS_WARNING)
 468           << "RTP extension header 15 encountered. Terminate parsing.";
 469       return;
 470     }
 471
 472     RTPExtensionType type;
 473     if (ptrExtensionMap->GetType(id, &type) != 0) {
 474       // If we encounter an unknown extension, just skip over it.
 475       LOG(LS_WARNING) << "Failed to find extension id: "
 476                       << static_cast<int>(id);
 477     } else {
 478       switch (type) {
 479         case kRtpExtensionTransmissionTimeOffset: {
 480           if (len != 2) {
 481             LOG(LS_WARNING) << "Incorrect transmission time offset len: "
 482                             << len;
 483             return;
 484           }
 485           //  0                   1                   2                   3
 486           //  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
 487           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 488           // |  ID   | len=2 |              transmission offset              |
 489           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 490
 491           int32_t transmissionTimeOffset = ptr[0] << 16;
 492           transmissionTimeOffset += ptr[1] << 8;
 493           transmissionTimeOffset += ptr[2];
 494           header.extension.transmissionTimeOffset =
 495               transmissionTimeOffset;
 496           if (transmissionTimeOffset & 0x800000) {
 497             // Negative offset, correct sign for Word24 to Word32.
 498             header.extension.transmissionTimeOffset |= 0xFF000000;
 499           }
 500           header.extension.hasTransmissionTimeOffset = true;
 501           break;
 502         }
 503         case kRtpExtensionAudioLevel: {
 504           if (len != 0) {
 505             LOG(LS_WARNING) << "Incorrect audio level len: " << len;
 506             return;
 507           }
 508           //  0                   1                   2                   3
 509           //  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
 510           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 511           // |  ID   | len=0 |V|   level     |      0x00     |      0x00     |
 512           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 513           //
 514
 515           // Parse out the fields but only use it for debugging for now.
 516           // const uint8_t V = (*ptr & 0x80) >> 7;
 517           // const uint8_t level = (*ptr & 0x7f);
 518           // DEBUG_PRINT("RTP_AUDIO_LEVEL_UNIQUE_ID: ID=%u, len=%u, V=%u,
 519           // level=%u", ID, len, V, level);
 520
 521           header.extension.audioLevel = ptr[0];
 522           header.extension.hasAudioLevel = true;
 523           break;
 524         }
 525         case kRtpExtensionAbsoluteSendTime: {
 526           if (len != 2) {
 527             LOG(LS_WARNING) << "Incorrect absolute send time len: " << len;
 528             return;
 529           }
 530           //  0                   1                   2                   3
 531           //  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
 532           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 533           // |  ID   | len=2 |              absolute send time               |
 534           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 535
 536           uint32_t absoluteSendTime = ptr[0] << 16;
 537           absoluteSendTime += ptr[1] << 8;
 538           absoluteSendTime += ptr[2];
 539           header.extension.absoluteSendTime = absoluteSendTime;
 540           header.extension.hasAbsoluteSendTime = true;
 541           break;
 542         }
 543         default: {
 544           LOG(LS_WARNING) << "Extension type not implemented: " << type;
 545           return;
 546         }
 547       }
 548     }
 549     ptr += (len + 1);
 550     uint8_t num_bytes = ParsePaddingBytes(ptrRTPDataExtensionEnd, ptr);
 551     ptr += num_bytes;
 552   }
 553 }
 554
 555 uint8_t RTPHeaderParser::ParsePaddingBytes(
 556   const uint8_t* ptrRTPDataExtensionEnd,
 557   const uint8_t* ptr) const {
 558
 559   uint8_t num_zero_bytes = 0;
 560   while (ptrRTPDataExtensionEnd - ptr > 0) {
 561     if (*ptr != 0) {
 562       return num_zero_bytes;
 563     }
 564     ptr++;
 565     num_zero_bytes++;
 566   }
 567   return num_zero_bytes;
 568 }
 569
 570 RTPPayloadParser::RTPPayloadParser(const RtpVideoCodecTypes videoType,
 571                                    const uint8_t* payloadData,
 572                                    uint16_t payloadDataLength)
 573     : _dataPtr(payloadData),
 574       _dataLength(payloadDataLength),
 575       _videoType(videoType) {}
 576
 577 RTPPayloadParser::~RTPPayloadParser() {
 578 }
 579
 580 bool RTPPayloadParser::Parse(RTPPayload& parsedPacket) const {
 581   parsedPacket.SetType(_videoType);
 582
 583   switch (_videoType) {
 584     case kRtpVideoGeneric:
 585       return ParseGeneric(parsedPacket);
 586     case kRtpVideoVp8:
 587       return ParseVP8(parsedPacket);
 588     default:
 589       return false;
 590   }
 591 }
 592
 593 bool RTPPayloadParser::ParseGeneric(RTPPayload& /*parsedPacket*/) const {
 594   return false;
 595 }
 596
 597 //
 598 // VP8 format:
 599 //
 600 // Payload descriptor
 601 //       0 1 2 3 4 5 6 7
 602 //      +-+-+-+-+-+-+-+-+
 603 //      |X|R|N|S|PartID | (REQUIRED)
 604 //      +-+-+-+-+-+-+-+-+
 605 // X:   |I|L|T|K|  RSV  | (OPTIONAL)
 606 //      +-+-+-+-+-+-+-+-+
 607 // I:   |   PictureID   | (OPTIONAL)
 608 //      +-+-+-+-+-+-+-+-+
 609 // L:   |   TL0PICIDX   | (OPTIONAL)
 610 //      +-+-+-+-+-+-+-+-+
 611 // T/K: |TID:Y| KEYIDX  | (OPTIONAL)
 612 //      +-+-+-+-+-+-+-+-+
 613 //
 614 // Payload header (considered part of the actual payload, sent to decoder)
 615 //       0 1 2 3 4 5 6 7
 616 //      +-+-+-+-+-+-+-+-+
 617 //      |Size0|H| VER |P|
 618 //      +-+-+-+-+-+-+-+-+
 619 //      |      ...      |
 620 //      +               +
 621
 622 bool RTPPayloadParser::ParseVP8(RTPPayload& parsedPacket) const {
 623   RTPPayloadVP8* vp8 = &parsedPacket.info.VP8;
 624   const uint8_t* dataPtr = _dataPtr;
 625   int dataLength = _dataLength;
 626
 627   // Parse mandatory first byte of payload descriptor
 628   bool extension = (*dataPtr & 0x80) ? true : false;            // X bit
 629   vp8->nonReferenceFrame = (*dataPtr & 0x20) ? true : false;    // N bit
 630   vp8->beginningOfPartition = (*dataPtr & 0x10) ? true : false; // S bit
 631   vp8->partitionID = (*dataPtr & 0x0F);          // PartID field
 632
 633   if (vp8->partitionID > 8) {
 634     // Weak check for corrupt data: PartID MUST NOT be larger than 8.
 635     return false;
 636   }
 637
 638   // Advance dataPtr and decrease remaining payload size
 639   dataPtr++;
 640   dataLength--;
 641
 642   if (extension) {
 643     const int parsedBytes = ParseVP8Extension(vp8, dataPtr, dataLength);
 644     if (parsedBytes < 0) return false;
 645     dataPtr += parsedBytes;
 646     dataLength -= parsedBytes;
 647   }
 648
 649   if (dataLength <= 0) {
 650     LOG(LS_ERROR) << "Error parsing VP8 payload descriptor!";
 651     return false;
 652   }
 653
 654   // Read P bit from payload header (only at beginning of first partition)
 655   if (dataLength > 0 && vp8->beginningOfPartition && vp8->partitionID == 0) {
 656     parsedPacket.frameType = (*dataPtr & 0x01) ? kPFrame : kIFrame;
 657   } else {
 658     parsedPacket.frameType = kPFrame;
 659   }
 660   if (0 != ParseVP8FrameSize(parsedPacket, dataPtr, dataLength)) {
 661     return false;
 662   }
 663   parsedPacket.info.VP8.data       = dataPtr;
 664   parsedPacket.info.VP8.dataLength = dataLength;
 665   return true;
 666 }
 667
 668 int RTPPayloadParser::ParseVP8FrameSize(RTPPayload& parsedPacket,
 669                                         const uint8_t* dataPtr,
 670                                         int dataLength) const {
 671   if (parsedPacket.frameType != kIFrame) {
 672     // Included in payload header for I-frames.
 673     return 0;
 674   }
 675   if (dataLength < 10) {
 676     // For an I-frame we should always have the uncompressed VP8 header
 677     // in the beginning of the partition.
 678     return -1;
 679   }
 680   RTPPayloadVP8* vp8 = &parsedPacket.info.VP8;
 681   vp8->frameWidth = ((dataPtr[7] << 8) + dataPtr[6]) & 0x3FFF;
 682   vp8->frameHeight = ((dataPtr[9] << 8) + dataPtr[8]) & 0x3FFF;
 683   return 0;
 684 }
 685
 686 int RTPPayloadParser::ParseVP8Extension(RTPPayloadVP8* vp8,
 687                                         const uint8_t* dataPtr,
 688                                         int dataLength) const {
 689   int parsedBytes = 0;
 690   if (dataLength <= 0) return -1;
 691   // Optional X field is present
 692   vp8->hasPictureID = (*dataPtr & 0x80) ? true : false; // I bit
 693   vp8->hasTl0PicIdx = (*dataPtr & 0x40) ? true : false; // L bit
 694   vp8->hasTID = (*dataPtr & 0x20) ? true : false;       // T bit
 695   vp8->hasKeyIdx = (*dataPtr & 0x10) ? true : false;    // K bit
 696
 697   // Advance dataPtr and decrease remaining payload size
 698   dataPtr++;
 699   parsedBytes++;
 700   dataLength--;
 701
 702   if (vp8->hasPictureID) {
 703     if (ParseVP8PictureID(vp8, &dataPtr, &dataLength, &parsedBytes) != 0) {
 704       return -1;
 705     }
 706   }
 707
 708   if (vp8->hasTl0PicIdx) {
 709     if (ParseVP8Tl0PicIdx(vp8, &dataPtr, &dataLength, &parsedBytes) != 0) {
 710       return -1;
 711     }
 712   }
 713
 714   if (vp8->hasTID || vp8->hasKeyIdx) {
 715     if (ParseVP8TIDAndKeyIdx(vp8, &dataPtr, &dataLength, &parsedBytes) != 0) {
 716       return -1;
 717     }
 718   }
 719   return parsedBytes;
 720 }
 721
 722 int RTPPayloadParser::ParseVP8PictureID(RTPPayloadVP8* vp8,
 723                                         const uint8_t** dataPtr,
 724                                         int* dataLength,
 725                                         int* parsedBytes) const {
 726   if (*dataLength <= 0) return -1;
 727   vp8->pictureID = (**dataPtr & 0x7F);
 728   if (**dataPtr & 0x80) {
 729     (*dataPtr)++;
 730     (*parsedBytes)++;
 731     if (--(*dataLength) <= 0) return -1;
 732     // PictureID is 15 bits
 733     vp8->pictureID = (vp8->pictureID << 8) +** dataPtr;
 734   }
 735   (*dataPtr)++;
 736   (*parsedBytes)++;
 737   (*dataLength)--;
 738   return 0;
 739 }
 740
 741 int RTPPayloadParser::ParseVP8Tl0PicIdx(RTPPayloadVP8* vp8,
 742                                         const uint8_t** dataPtr,
 743                                         int* dataLength,
 744                                         int* parsedBytes) const {
 745   if (*dataLength <= 0) return -1;
 746   vp8->tl0PicIdx = **dataPtr;
 747   (*dataPtr)++;
 748   (*parsedBytes)++;
 749   (*dataLength)--;
 750   return 0;
 751 }
 752
 753 int RTPPayloadParser::ParseVP8TIDAndKeyIdx(RTPPayloadVP8* vp8,
 754                                            const uint8_t** dataPtr,
 755                                            int* dataLength,
 756                                            int* parsedBytes) const {
 757   if (*dataLength <= 0) return -1;
 758   if (vp8->hasTID) {
 759     vp8->tID = ((**dataPtr >> 6) & 0x03);
 760     vp8->layerSync = (**dataPtr & 0x20) ? true : false;  // Y bit
 761   }
 762   if (vp8->hasKeyIdx) {
 763     vp8->keyIdx = (**dataPtr & 0x1F);
 764   }
 765   (*dataPtr)++;
 766   (*parsedBytes)++;
 767   (*dataLength)--;
 768   return 0;
 769 }
 770
 771 }  // namespace ModuleRTPUtility
 772
 773 }  // namespace webrtc