[rtp_rtcp] Lint errors cleaned from rtp_utility

webrtc/modules/rtp_rtcp/source/rtp_utility.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
-#include <assert.h>
-#include <math.h>  // ceil
-#include <string.h>  // memcpy
-
-#if defined(_WIN32)
-// Order for these headers are important
-#include <winsock2.h>  // timeval
-#include <windows.h>  // FILETIME NOLINT(build/include_alpha)
-#include <MMSystem.h>  // timeGetTime
-#elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
-#include <sys/time.h>  // gettimeofday
-#include <time.h>
-#endif
-#if (!defined(NDEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
-#include <stdio.h>
-#endif
+#include <string.h>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
-
-#if (!defined(NDEBUG) && defined(_WIN32) && (_MSC_VER >= 1400))
-#define DEBUG_PRINT(...)           \
-  {                                \
-    char msg[256];                 \
-    sprintf(msg, __VA_ARGS__);     \
-    OutputDebugString(msg);        \
-  }
-#else
-// special fix for visual 2003
-#define DEBUG_PRINT(exp)        ((void)0)
-#endif  // !defined(NDEBUG) && defined(_WIN32)
 
 namespace webrtc {
 
 RtpData* NullObjectRtpData() {
   static NullRtpData null_rtp_data;
   return &null_rtp_data;
 }
 
 RtpFeedback* NullObjectRtpFeedback() {
   static NullRtpFeedback null_rtp_feedback;
@@ skipping 21 matching lines @@
   kRtpMinParseLength = 12
 };
 
 /*
  * Misc utility routines
  */
 
 #if defined(_WIN32)
 bool StringCompare(const char* str1, const char* str2,
                    const uint32_t length) {
-  return (_strnicmp(str1, str2, length) == 0) ? true : false;
+  return _strnicmp(str1, str2, length) == 0;
 }
 #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
 bool StringCompare(const char* str1, const char* str2,
                    const uint32_t length) {
-  return (strncasecmp(str1, str2, length) == 0) ? true : false;
+  return strncasecmp(str1, str2, length) == 0;
 }
 #endif
 
 size_t Word32Align(size_t size) {
   uint32_t remainder = size % 4;
   if (remainder != 0)
     return size + 4 - remainder;
   return size;
 }
 
-uint32_t pow2(uint8_t exp) {
-  return 1 << exp;
-}
-
 RtpHeaderParser::RtpHeaderParser(const uint8_t* rtpData,
                                  const size_t rtpDataLength)
     : _ptrRTPDataBegin(rtpData),
       _ptrRTPDataEnd(rtpData ? (rtpData + rtpDataLength) : NULL) {
 }
 
 RtpHeaderParser::~RtpHeaderParser() {
 }
 
 bool RtpHeaderParser::RTCP() const {
@@ skipping 89 matching lines @@
   uint32_t SSRC = ByteReader<uint32_t>::ReadBigEndian(ptr);
   ptr += 4;
 
   header->payloadType  = PT;
   header->ssrc         = SSRC;
   header->headerLength = 4 + (len << 2);
 
   return true;
 }
 
-bool RtpHeaderParser::Parse(RTPHeader& header,
+bool RtpHeaderParser::Parse(RTPHeader* header,
                             RtpHeaderExtensionMap* ptrExtensionMap) const {
   const ptrdiff_t length = _ptrRTPDataEnd - _ptrRTPDataBegin;
   if (length < kRtpMinParseLength) {
     return false;
   }
 
   // Version
   const uint8_t V  = _ptrRTPDataBegin[0] >> 6;
   // Padding
   const bool          P  = ((_ptrRTPDataBegin[0] & 0x20) == 0) ? false : true;
@@ skipping 18 matching lines @@
   if (V != kRtpExpectedVersion) {
     return false;
   }
 
   const size_t CSRCocts = CC * 4;
 
   if ((ptr + CSRCocts) > _ptrRTPDataEnd) {
     return false;
   }
 
-  header.markerBit      = M;
-  header.payloadType    = PT;
-  header.sequenceNumber = sequenceNumber;
-  header.timestamp      = RTPTimestamp;
-  header.ssrc           = SSRC;
-  header.numCSRCs       = CC;
-  header.paddingLength  = P ? *(_ptrRTPDataEnd - 1) : 0;
+  header->markerBit      = M;
+  header->payloadType    = PT;
+  header->sequenceNumber = sequenceNumber;
+  header->timestamp      = RTPTimestamp;
+  header->ssrc           = SSRC;
+  header->numCSRCs       = CC;
+  header->paddingLength  = P ? *(_ptrRTPDataEnd - 1) : 0;
 
   for (uint8_t i = 0; i < CC; ++i) {
     uint32_t CSRC = ByteReader<uint32_t>::ReadBigEndian(ptr);
     ptr += 4;
-    header.arrOfCSRCs[i] = CSRC;
+    header->arrOfCSRCs[i] = CSRC;
   }
 
-  header.headerLength   = 12 + CSRCocts;
+  header->headerLength   = 12 + CSRCocts;
 
   // If in effect, MAY be omitted for those packets for which the offset
   // is zero.
-  header.extension.hasTransmissionTimeOffset = false;
-  header.extension.transmissionTimeOffset = 0;
+  header->extension.hasTransmissionTimeOffset = false;
+  header->extension.transmissionTimeOffset = 0;
 
   // May not be present in packet.
-  header.extension.hasAbsoluteSendTime = false;
-  header.extension.absoluteSendTime = 0;
+  header->extension.hasAbsoluteSendTime = false;
+  header->extension.absoluteSendTime = 0;
 
   // May not be present in packet.
-  header.extension.hasAudioLevel = false;
-  header.extension.voiceActivity = false;
-  header.extension.audioLevel = 0;
+  header->extension.hasAudioLevel = false;
+  header->extension.voiceActivity = false;
+  header->extension.audioLevel = 0;
 
   // May not be present in packet.
-  header.extension.hasVideoRotation = false;
-  header.extension.videoRotation = 0;
+  header->extension.hasVideoRotation = false;
+  header->extension.videoRotation = 0;
 
   if (X) {
     /* RTP header extension, 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
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |      defined by profile       |           length              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                        header extension                       |
     |                             ....                              |
     */
     const ptrdiff_t remain = _ptrRTPDataEnd - ptr;
     if (remain < 4) {
       return false;
     }
 
-    header.headerLength += 4;
+    header->headerLength += 4;
 
     uint16_t definedByProfile = ByteReader<uint16_t>::ReadBigEndian(ptr);
     ptr += 2;
 
     // in 32 bit words
     size_t XLen = ByteReader<uint16_t>::ReadBigEndian(ptr);
     ptr += 2;
     XLen *= 4;  // in bytes
 
     if (static_cast<size_t>(remain) < (4 + XLen)) {
       return false;
     }
     if (definedByProfile == kRtpOneByteHeaderExtensionId) {
       const uint8_t* ptrRTPDataExtensionEnd = ptr + XLen;
       ParseOneByteExtensionHeader(header,
                                   ptrExtensionMap,
                                   ptrRTPDataExtensionEnd,
                                   ptr);
     }
-    header.headerLength += XLen;
+    header->headerLength += XLen;
   }
-  if (header.headerLength + header.paddingLength > static_cast<size_t>(length))
+  if (header->headerLength + header->paddingLength >
+      static_cast<size_t>(length))
     return false;
   return true;
 }
 
 void RtpHeaderParser::ParseOneByteExtensionHeader(
-    RTPHeader& header,
+    RTPHeader* header,
     const RtpHeaderExtensionMap* ptrExtensionMap,
     const uint8_t* ptrRTPDataExtensionEnd,
     const uint8_t* ptr) const {
   if (!ptrExtensionMap) {
     return;
   }
 
   while (ptrRTPDataExtensionEnd - ptr > 0) {
     //  0
     //  0 1 2 3 4 5 6 7
@@ skipping 25 matching lines @@
             LOG(LS_WARNING) << "Incorrect transmission time offset len: "
                             << len;
             return;
           }
           //  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
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           // |  ID   | len=2 |              transmission offset              |
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
-          header.extension.transmissionTimeOffset =
+          header->extension.transmissionTimeOffset =
               ByteReader<int32_t, 3>::ReadBigEndian(ptr);
-          header.extension.hasTransmissionTimeOffset = true;
+          header->extension.hasTransmissionTimeOffset = true;
           break;
         }
         case kRtpExtensionAudioLevel: {
           if (len != 0) {
             LOG(LS_WARNING) << "Incorrect audio level len: " << len;
             return;
           }
           //  0                   1
           //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           // |  ID   | len=0 |V|   level     |
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           //
-          header.extension.audioLevel = ptr[0] & 0x7f;
-          header.extension.voiceActivity = (ptr[0] & 0x80) != 0;
-          header.extension.hasAudioLevel = true;
+          header->extension.audioLevel = ptr[0] & 0x7f;
+          header->extension.voiceActivity = (ptr[0] & 0x80) != 0;
+          header->extension.hasAudioLevel = true;
           break;
         }
         case kRtpExtensionAbsoluteSendTime: {
           if (len != 2) {
             LOG(LS_WARNING) << "Incorrect absolute send time len: " << len;
             return;
           }
           //  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
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           // |  ID   | len=2 |              absolute send time               |
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
-          header.extension.absoluteSendTime =
+          header->extension.absoluteSendTime =
               ByteReader<uint32_t, 3>::ReadBigEndian(ptr);
-          header.extension.hasAbsoluteSendTime = true;
+          header->extension.hasAbsoluteSendTime = true;
           break;
         }
         case kRtpExtensionVideoRotation: {
           if (len != 0) {
             LOG(LS_WARNING)
                 << "Incorrect coordination of video coordination len: " << len;
             return;
           }
           //  0                   1
           //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           // |  ID   | len=0 |0 0 0 0 C F R R|
           // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-          header.extension.hasVideoRotation = true;
-          header.extension.videoRotation = ptr[0];
+          header->extension.hasVideoRotation = true;
+          header->extension.videoRotation = ptr[0];
           break;
         }
         case kRtpExtensionTransportSequenceNumber: {
           if (len != 1) {
             LOG(LS_WARNING)
                 << "Incorrect peer connection sequence number len: " << len;
             return;
           }
           //   0                   1                   2
           //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
           //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
           //  |  ID   | L=1   |transport wide sequence number |
           //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
           uint16_t sequence_number = ptr[0] << 8;
           sequence_number += ptr[1];
-          header.extension.transportSequenceNumber = sequence_number;
-          header.extension.hasTransportSequenceNumber = true;
+          header->extension.transportSequenceNumber = sequence_number;
+          header->extension.hasTransportSequenceNumber = true;
           break;
         }
         default: {
           LOG(LS_WARNING) << "Extension type not implemented: " << type;
           return;
         }
       }
     }
     ptr += (len + 1);
     uint8_t num_bytes = ParsePaddingBytes(ptrRTPDataExtensionEnd, ptr);
     ptr += num_bytes;
   }
 }
 
 uint8_t RtpHeaderParser::ParsePaddingBytes(
     const uint8_t* ptrRTPDataExtensionEnd,
     const uint8_t* ptr) const {
   uint8_t num_zero_bytes = 0;
   while (ptrRTPDataExtensionEnd - ptr > 0) {
     if (*ptr != 0) {
       return num_zero_bytes;
     }
     ptr++;
     num_zero_bytes++;
   }
   return num_zero_bytes;
 }
 }  // namespace RtpUtility
-
 }  // namespace webrtc