Changed LogRtpHeader to read the header length from the packet

webrtc/video/rtc_event_log.cc

 /*
  *  Copyright (c) 2015 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/video/rtc_event_log.h"
 
 #include <deque>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/call.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/file_wrapper.h"
 
 #ifdef ENABLE_RTC_EVENT_LOG
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/video/rtc_event_log.pb.h"
 #else
 #include "webrtc/video/rtc_event_log.pb.h"
 #endif
 #endif
 
 namespace webrtc {
 
 #ifndef ENABLE_RTC_EVENT_LOG
 
 // No-op implementation if flag is not set.
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   void StartLogging(const std::string& file_name, int duration_ms) override {}
   void StopLogging(void) override {}
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override {}
   void LogVideoSendStreamConfig(
       const VideoSendStream::Config& config) override {}
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
-                    size_t header_length,
-                    size_t total_length) override {}
+                    size_t packet_length) override {}
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override {}
   void LogDebugEvent(DebugEvent event_type) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   RtcEventLogImpl();
 
   void StartLogging(const std::string& file_name, int duration_ms) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override;
   void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
   void LogRtpHeader(bool incoming,
                     MediaType media_type,
                     const uint8_t* header,
-                    size_t header_length,
-                    size_t total_length) override;
+                    size_t packet_length) override;
   void LogRtcpPacket(bool incoming,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override;
   void LogDebugEvent(DebugEvent event_type) override;
 
  private:
   // Stops logging and clears the stored data and buffers.
   void StopLoggingLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Adds a new event to the logfile if logging is active, or adds it to the
@@ skipping 195 matching lines @@
   encoder->set_name(config.encoder_settings.payload_name);
   encoder->set_payload_type(config.encoder_settings.payload_type);
 
   // TODO(terelius): We should use a separate event queue for config events.
   // The current approach of storing the configuration together with the
   // RTP events causes the configuration information to be removed 10s
   // after the ReceiveStream is created.
   HandleEvent(&event);
 }
 
-// TODO(terelius): It is more convenient and less error prone to parse the
-// header length from the packet instead of relying on the caller to provide it.
 void RtcEventLogImpl::LogRtpHeader(bool incoming,
                                    MediaType media_type,
                                    const uint8_t* header,
-                                   size_t header_length,
-                                   size_t total_length) {
+                                   size_t packet_length) {
+  // Read header length (in bytes) from packet data.
+  if (packet_length < 12u) {
+    return;  // Don't read outside the packet.
+  }
+  const bool x = (header[0] & 0x10) != 0;
+  const uint8_t cc = header[0] & 0x0f;
+  size_t header_length = 12u + cc * 4u;
+
+  if (x) {
+    if (packet_length < 12u + cc * 4u + 4u) {
+      return;  // Don't read outside the packet.
+    }
+    size_t x_len = ByteReader<uint16_t>::ReadBigEndian(header + 14 + cc * 4);
+    header_length += (x_len + 1) * 4;
+  }
+
   rtc::CritScope lock(&crit_);
   rtclog::Event rtp_event;
   const int64_t timestamp = clock_->TimeInMicroseconds();
   rtp_event.set_timestamp_us(timestamp);
   rtp_event.set_type(rtclog::Event::RTP_EVENT);
   rtp_event.mutable_rtp_packet()->set_incoming(incoming);
   rtp_event.mutable_rtp_packet()->set_type(ConvertMediaType(media_type));
-  rtp_event.mutable_rtp_packet()->set_packet_length(total_length);
+  rtp_event.mutable_rtp_packet()->set_packet_length(packet_length);
   rtp_event.mutable_rtp_packet()->set_header(header, header_length);
   HandleEvent(&rtp_event);
 }
 
 void RtcEventLogImpl::LogRtcpPacket(bool incoming,
                                     MediaType media_type,
                                     const uint8_t* packet,
                                     size_t length) {
   rtc::CritScope lock(&crit_);
   rtclog::Event rtcp_event;
@@ skipping 85 matching lines @@
   return result->ParseFromString(dump_buffer);
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 rtc::scoped_ptr<RtcEventLog> RtcEventLog::Create() {
   return rtc::scoped_ptr<RtcEventLog>(new RtcEventLogImpl());
 }
 }  // namespace webrtc