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 RtpUtility {
  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 RtpHeaderParser::RtpHeaderParser(const uint8_t* rtpData,
 192                                  const size_t rtpDataLength)
 193     : _ptrRTPDataBegin(rtpData),
 194       _ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
 195 }
 196
 197 RtpHeaderParser::~RtpHeaderParser() {
 198 }
 199
 200 bool RtpHeaderParser::RTCP() const {
 201   // 72 to 76 is reserved for RTP
 202   // 77 to 79 is not reserver but  they are not assigned we will block them
 203   // for RTCP 200 SR  == marker bit + 72
 204   // for RTCP 204 APP == marker bit + 76
 205   /*
 206   *       RTCP
 207   *
 208   * FIR      full INTRA-frame request             192     [RFC2032]   supported
 209   * NACK     negative acknowledgement             193     [RFC2032]
 210   * IJ       Extended inter-arrival jitter report 195     [RFC-ietf-avt-rtp-toff
 211   * set-07.txt] http://tools.ietf.org/html/draft-ietf-avt-rtp-toffset-07
 212   * SR       sender report                        200     [RFC3551]   supported
 213   * RR       receiver report                      201     [RFC3551]   supported
 214   * SDES     source description                   202     [RFC3551]   supported
 215   * BYE      goodbye                              203     [RFC3551]   supported
 216   * APP      application-defined                  204     [RFC3551]   ignored
 217   * RTPFB    Transport layer FB message           205     [RFC4585]   supported
 218   * PSFB     Payload-specific FB message          206     [RFC4585]   supported
 219   * XR       extended report                      207     [RFC3611]   supported
 220   */
 221
 222   /* 205       RFC 5104
 223    * FMT 1      NACK       supported
 224    * FMT 2      reserved
 225    * FMT 3      TMMBR      supported
 226    * FMT 4      TMMBN      supported
 227    */
 228
 229   /* 206      RFC 5104
 230   * FMT 1:     Picture Loss Indication (PLI)                      supported
 231   * FMT 2:     Slice Lost Indication (SLI)
 232   * FMT 3:     Reference Picture Selection Indication (RPSI)
 233   * FMT 4:     Full Intra Request (FIR) Command                   supported
 234   * FMT 5:     Temporal-Spatial Trade-off Request (TSTR)
 235   * FMT 6:     Temporal-Spatial Trade-off Notification (TSTN)
 236   * FMT 7:     Video Back Channel Message (VBCM)
 237   * FMT 15:    Application layer FB message
 238   */
 239
 240   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 241   if (length < kRtcpMinHeaderLength) {
 242     return false;
 243   }
 244
 245   const uint8_t V  = _ptrRTPDataBegin[0] >> 6;
 246   if (V != kRtcpExpectedVersion) {
 247     return false;
 248   }
 249
 250   const uint8_t  payloadType = _ptrRTPDataBegin[1];
 251   bool RTCP = false;
 252   switch (payloadType) {
 253     case 192:
 254       RTCP = true;
 255       break;
 256     case 193:
 257       // not supported
 258       // pass through and check for a potential RTP packet
 259       break;
 260     case 195:
 261     case 200:
 262     case 201:
 263     case 202:
 264     case 203:
 265     case 204:
 266     case 205:
 267     case 206:
 268     case 207:
 269       RTCP = true;
 270       break;
 271   }
 272   return RTCP;
 273 }
 274
 275 bool RtpHeaderParser::ParseRtcp(RTPHeader* header) const {
 276   assert(header != NULL);
 277
 278   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 279   if (length < kRtcpMinParseLength) {
 280     return false;
 281   }
 282
 283   const uint8_t V = _ptrRTPDataBegin[0] >> 6;
 284   if (V != kRtcpExpectedVersion) {
 285     return false;
 286   }
 287
 288   const uint8_t PT = _ptrRTPDataBegin[1];
 289   const uint16_t len = (_ptrRTPDataBegin[2] << 8) + _ptrRTPDataBegin[3];
 290   const uint8_t* ptr = &_ptrRTPDataBegin[4];
 291
 292   uint32_t SSRC = *ptr++ << 24;
 293   SSRC += *ptr++ << 16;
 294   SSRC += *ptr++ << 8;
 295   SSRC += *ptr++;
 296
 297   header->payloadType  = PT;
 298   header->ssrc         = SSRC;
 299   header->headerLength = 4 + (len << 2);
 300
 301   return true;
 302 }
 303
 304 bool RtpHeaderParser::Parse(RTPHeader& header,
 305                             RtpHeaderExtensionMap* ptrExtensionMap) const {
 306   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
 307   if (length < kRtpMinParseLength) {
 308     return false;
 309   }
 310
 311   // Version
 312   const uint8_t V  = _ptrRTPDataBegin[0] >> 6;
 313   // Padding
 314   const bool          P  = ((_ptrRTPDataBegin[0] & 0x20) == 0) ? false : true;
 315   // eXtension
 316   const bool          X  = ((_ptrRTPDataBegin[0] & 0x10) == 0) ? false : true;
 317   const uint8_t CC = _ptrRTPDataBegin[0] & 0x0f;
 318   const bool          M  = ((_ptrRTPDataBegin[1] & 0x80) == 0) ? false : true;
 319
 320   const uint8_t PT = _ptrRTPDataBegin[1] & 0x7f;
 321
 322   const uint16_t sequenceNumber = (_ptrRTPDataBegin[2] << 8) +
 323       _ptrRTPDataBegin[3];
 324
 325   const uint8_t* ptr = &_ptrRTPDataBegin[4];
 326
 327   uint32_t RTPTimestamp = *ptr++ << 24;
 328   RTPTimestamp += *ptr++ << 16;
 329   RTPTimestamp += *ptr++ << 8;
 330   RTPTimestamp += *ptr++;
 331
 332   uint32_t SSRC = *ptr++ << 24;
 333   SSRC += *ptr++ << 16;
 334   SSRC += *ptr++ << 8;
 335   SSRC += *ptr++;
 336
 337   if (V != kRtpExpectedVersion) {
 338     return false;
 339   }
 340
 341   const uint8_t CSRCocts = CC * 4;
 342
 343   if ((ptr + CSRCocts) > _ptrRTPDataEnd) {
 344     return false;
 345   }
 346
 347   header.markerBit      = M;
 348   header.payloadType    = PT;
 349   header.sequenceNumber = sequenceNumber;
 350   header.timestamp      = RTPTimestamp;
 351   header.ssrc           = SSRC;
 352   header.numCSRCs       = CC;
 353   header.paddingLength  = P ? *(_ptrRTPDataEnd - 1) : 0;
 354
 355   for (unsigned int i = 0; i < CC; ++i) {
 356     uint32_t CSRC = *ptr++ << 24;
 357     CSRC += *ptr++ << 16;
 358     CSRC += *ptr++ << 8;
 359     CSRC += *ptr++;
 360     header.arrOfCSRCs[i] = CSRC;
 361   }
 362
 363   header.headerLength   = 12 + CSRCocts;
 364
 365   // If in effect, MAY be omitted for those packets for which the offset
 366   // is zero.
 367   header.extension.hasTransmissionTimeOffset = false;
 368   header.extension.transmissionTimeOffset = 0;
 369
 370   // May not be present in packet.
 371   header.extension.hasAbsoluteSendTime = false;
 372   header.extension.absoluteSendTime = 0;
 373
 374   // May not be present in packet.
 375   header.extension.hasAudioLevel = false;
 376   header.extension.audioLevel = 0;
 377
 378   if (X) {
 379     /* RTP header extension, RFC 3550.
 380      0                   1                   2                   3
 381      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
 382     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 383     |      defined by profile       |           length              |
 384     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 385     |                        header extension                       |
 386     |                             ....                              |
 387     */
 388     const ptrdiff_t remain = _ptrRTPDataEnd - ptr;
 389     if (remain < 4) {
 390       return false;
 391     }
 392
 393     header.headerLength += 4;
 394
 395     uint16_t definedByProfile = *ptr++ << 8;
 396     definedByProfile += *ptr++;
 397
 398     uint16_t XLen = *ptr++ << 8;
 399     XLen += *ptr++; // in 32 bit words
 400     XLen *= 4; // in octs
 401
 402     if (remain < (4 + XLen)) {
 403       return false;
 404     }
 405     if (definedByProfile == kRtpOneByteHeaderExtensionId) {
 406       const uint8_t* ptrRTPDataExtensionEnd = ptr + XLen;
 407       ParseOneByteExtensionHeader(header,
 408                                   ptrExtensionMap,
 409                                   ptrRTPDataExtensionEnd,
 410                                   ptr);
 411     }
 412     header.headerLength += XLen;
 413   }
 414   return true;
 415 }
 416
 417 void RtpHeaderParser::ParseOneByteExtensionHeader(
 418     RTPHeader& header,
 419     const RtpHeaderExtensionMap* ptrExtensionMap,
 420     const uint8_t* ptrRTPDataExtensionEnd,
 421     const uint8_t* ptr) const {
 422   if (!ptrExtensionMap) {
 423     return;
 424   }
 425
 426   while (ptrRTPDataExtensionEnd - ptr > 0) {
 427     //  0
 428     //  0 1 2 3 4 5 6 7
 429     // +-+-+-+-+-+-+-+-+
 430     // |  ID   |  len  |
 431     // +-+-+-+-+-+-+-+-+
 432
 433     // Note that 'len' is the header extension element length, which is the
 434     // number of bytes - 1.
 435     const uint8_t id = (*ptr & 0xf0) >> 4;
 436     const uint8_t len = (*ptr & 0x0f);
 437     ptr++;
 438
 439     if (id == 15) {
 440       LOG(LS_WARNING)
 441           << "RTP extension header 15 encountered. Terminate parsing.";
 442       return;
 443     }
 444
 445     RTPExtensionType type;
 446     if (ptrExtensionMap->GetType(id, &type) != 0) {
 447       // If we encounter an unknown extension, just skip over it.
 448       LOG(LS_WARNING) << "Failed to find extension id: "
 449                       << static_cast<int>(id);
 450     } else {
 451       switch (type) {
 452         case kRtpExtensionTransmissionTimeOffset: {
 453           if (len != 2) {
 454             LOG(LS_WARNING) << "Incorrect transmission time offset len: "
 455                             << len;
 456             return;
 457           }
 458           //  0                   1                   2                   3
 459           //  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
 460           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 461           // |  ID   | len=2 |              transmission offset              |
 462           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 463
 464           int32_t transmissionTimeOffset = ptr[0] << 16;
 465           transmissionTimeOffset += ptr[1] << 8;
 466           transmissionTimeOffset += ptr[2];
 467           header.extension.transmissionTimeOffset =
 468               transmissionTimeOffset;
 469           if (transmissionTimeOffset & 0x800000) {
 470             // Negative offset, correct sign for Word24 to Word32.
 471             header.extension.transmissionTimeOffset |= 0xFF000000;
 472           }
 473           header.extension.hasTransmissionTimeOffset = true;
 474           break;
 475         }
 476         case kRtpExtensionAudioLevel: {
 477           if (len != 0) {
 478             LOG(LS_WARNING) << "Incorrect audio level len: " << len;
 479             return;
 480           }
 481           //  0                   1                   2                   3
 482           //  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
 483           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 484           // |  ID   | len=0 |V|   level     |      0x00     |      0x00     |
 485           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 486           //
 487
 488           // Parse out the fields but only use it for debugging for now.
 489           // const uint8_t V = (*ptr & 0x80) >> 7;
 490           // const uint8_t level = (*ptr & 0x7f);
 491           // DEBUG_PRINT("RTP_AUDIO_LEVEL_UNIQUE_ID: ID=%u, len=%u, V=%u,
 492           // level=%u", ID, len, V, level);
 493
 494           header.extension.audioLevel = ptr[0];
 495           header.extension.hasAudioLevel = true;
 496           break;
 497         }
 498         case kRtpExtensionAbsoluteSendTime: {
 499           if (len != 2) {
 500             LOG(LS_WARNING) << "Incorrect absolute send time len: " << len;
 501             return;
 502           }
 503           //  0                   1                   2                   3
 504           //  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
 505           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 506           // |  ID   | len=2 |              absolute send time               |
 507           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 508
 509           uint32_t absoluteSendTime = ptr[0] << 16;
 510           absoluteSendTime += ptr[1] << 8;
 511           absoluteSendTime += ptr[2];
 512           header.extension.absoluteSendTime = absoluteSendTime;
 513           header.extension.hasAbsoluteSendTime = true;
 514           break;
 515         }
 516         default: {
 517           LOG(LS_WARNING) << "Extension type not implemented: " << type;
 518           return;
 519         }
 520       }
 521     }
 522     ptr += (len + 1);
 523     uint8_t num_bytes = ParsePaddingBytes(ptrRTPDataExtensionEnd, ptr);
 524     ptr += num_bytes;
 525   }
 526 }
 527
 528 uint8_t RtpHeaderParser::ParsePaddingBytes(
 529     const uint8_t* ptrRTPDataExtensionEnd,
 530     const uint8_t* ptr) const {
 531   uint8_t num_zero_bytes = 0;
 532   while (ptrRTPDataExtensionEnd - ptr > 0) {
 533     if (*ptr != 0) {
 534       return num_zero_bytes;
 535     }
 536     ptr++;
 537     num_zero_bytes++;
 538   }
 539   return num_zero_bytes;
 540 }
 541 }  // namespace RtpUtility
 542
 543 }  // namespace webrtc