Visualization tool for WebrtcEventLogs

webrtc/tools/event_log_visualizer/analyzer.cc

+/*
+ *  Copyright (c) 2016 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/tools/event_log_visualizer/analyzer.h"
+
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "webrtc/audio_receive_stream.h"
+#include "webrtc/audio_send_stream.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/call.h"
+#include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/video_receive_stream.h"
+#include "webrtc/video_send_stream.h"
+
+namespace {
+
+std::string HeaderToString(const webrtc::RTPHeader& parsed_header) {
+  std::stringstream ss;
+  ss << "Marker=" << parsed_header.markerBit
+     << ", PType=" << parsed_header.payloadType
+     << ", SeqNum=" << parsed_header.sequenceNumber
+     << ", CaptureTime=" << parsed_header.timestamp
+     << ", SSRC=" << parsed_header.ssrc;
+  return ss.str();
+}
+
+std::string SSRCToString(uint32_t ssrc) {

[stefan-webrtc, 2016/05/31 18:53:39]

Ssrc

[terelius, 2016/06/14 13:18:48]

Done.

+  std::stringstream ss;
+  ss << "SSRC " << ssrc;
+  return ss.str();
+}
+
+// Checks whether the an SSRC is contained in the list of desired SSRCs.

[stefan-webrtc, 2016/05/31 18:53:40]

-the

[terelius, 2016/06/14 13:18:48]

Done.

+// Note that an empty SSRC list counts matches every SSRC.

[stefan-webrtc, 2016/05/31 18:53:39]

-counts?

[terelius, 2016/06/14 13:18:48]

Done.

+bool MatchingSSRC(uint32_t ssrc, const std::vector<uint32_t>& desired_ssrc) {

[stefan-webrtc, 2016/05/31 18:53:40]

MatchingSsrc

[terelius, 2016/06/14 13:18:48]

Done.

+  if (desired_ssrc.size() == 0)
+    return true;
+  return std::find(desired_ssrc.begin(), desired_ssrc.end(), ssrc) !=
+         desired_ssrc.end();
+}
+
+double AbsSendTimeToMicroseconds(int64_t abs_send_time) {
+  // The timestamp is a fixed point representation with 6 bits for seconds
+  // and 18 bits for fractions of a second. Thus, we divide by 2^18 to get the
+  // time in second and then multiply by 1000000 to convert to microseconds.

[aleloi, 2016/06/08 11:44:20]

second -> seconds?

[terelius, 2016/06/14 13:18:48]

Done.

+  static const double kTimestampToMicroSec =

[aleloi, 2016/06/08 11:44:20]

constexpr?

[terelius, 2016/06/14 13:18:49]

Done.

+      1000000.0 / static_cast<double>(1 << 18);
+  return abs_send_time * kTimestampToMicroSec;
+}
+
+// Computes the difference |later| - |earlier| where |later| and |earlier|
+// are counters that wrap at |modulus|. The difference is chosen to have the
+// least absolute value. For example if |modulus| is 8, then the difference will
+// be chosen in the range [-3, 4]. If |modulus| is 9, then the difference will
+// be in [-4, 4].
+int64_t WrappingDifference(uint32_t later, uint32_t earlier, int64_t modulus) {

[stefan-webrtc, 2016/05/31 18:53:40]

Can you use philipel's mod_ops.h for this?
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

[aleloi, 2016/06/08 11:44:20]

Is there a guarantee that this function is only given numbers with difference
less than modulus?

[terelius, 2016/06/14 13:18:48]

Yes, the numbers should always be less than modulus. I've documented this with a
DCHECK.

[terelius, 2016/06/14 13:18:48]

No, at least not off the shelf. I want the signed difference with the smallest
possible magnitude, but philipel's functions all return unsigned results.

+  RTC_DCHECK_LE(1, modulus);
+  int64_t difference =
+      static_cast<int64_t>(later) - static_cast<int64_t>(earlier);
+  int64_t max_difference = modulus / 2;
+  int64_t min_difference = max_difference - modulus + 1;
+  if (difference > max_difference) {
+    difference -= modulus;
+  }
+  if (difference < min_difference) {
+    difference += modulus;
+  }
+  return difference;
+}
+
+// typedef StreamID uint64_t;

[stefan-webrtc, 2016/05/31 18:53:40]

Remove?

[terelius, 2016/06/14 13:18:49]

Done. I was considering whether a typedef would make the code more readable.

+uint64_t GetStreamID(uint32_t ssrc,

[stefan-webrtc, 2016/05/31 18:53:40]

GetStreamId

[aleloi, 2016/06/08 11:44:20]

I'd like a comment that explains what StreamID is. E.g. 48-bit number consisting
of ... defined in ... used in ...

[terelius, 2016/06/14 13:18:49]

I've added a comment, but this isn't a defined concept. Normally there is no
risk of mixing up incoming and outgoing packets, so incoming and outgoing
streams could conceivably use the same SSRC. Since we store both incoming and
outgoing packets as the same type, we need to distinguish packets and streams by
some other parameters in addition to the SSRC. The simplest way is to append the
other identifiers to the SSRC.

[terelius, 2016/06/14 13:18:49]

Done.

+                     webrtc::PacketDirection direction,
+                     webrtc::MediaType media_type) {
+  uint64_t stream = ssrc;
+  stream = (stream << 8) +
+           static_cast<uint64_t>(direction == webrtc::kIncomingPacket);
+  // stream_id = stream_id

[stefan-webrtc, 2016/05/31 18:53:40]

Remove

[terelius, 2016/06/14 13:18:48]

Done.

+  stream = (stream << 8) + static_cast<uint64_t>(media_type);
+  return stream;
+}
+
+uint32_t GetSsrcFromStreamID(uint64_t stream) {

[stefan-webrtc, 2016/05/31 18:53:40]

GetSsrcFromStreamId

[terelius, 2016/06/14 13:18:48]

Done.

+  return stream >> 16;
+}
+
+}  // namespace
+
+namespace webrtc {
+namespace plotting {
+
+EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log,
+                                   bool extra_info)
+    : parsed_log(log), extra_point_info(extra_info) {
+  uint64_t first_timestamp = std::numeric_limits<uint64_t>::max();
+  uint64_t last_timestamp = std::numeric_limits<uint64_t>::min();
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT)
+      continue;
+    if (event_type == ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT)
+      continue;
+    if (event_type == ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT)
+      continue;
+    if (event_type == ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT)
+      continue;
+    uint64_t timestamp = parsed_log.GetTimestamp(i);
+    if (timestamp < first_timestamp)

[aleloi, 2016/06/08 11:44:20]

You use if-statements here and the ternary ?: operator below. I'd say that
std::min/max is more readable.

[terelius, 2016/06/14 13:18:48]

Good point. Done.

+      first_timestamp = timestamp;
+    if (timestamp > last_timestamp)
+      last_timestamp = timestamp;
+  }
+  if (last_timestamp < first_timestamp) {
+    // No useful events in the log

[stefan-webrtc, 2016/05/31 18:53:40]

End with .

[terelius, 2016/06/14 13:18:48]

Done.

+    first_timestamp = last_timestamp = 0;
+  }
+  begin_time = first_timestamp;
+  end_time = last_timestamp;
+  window_duration = 250000;
+  step = 10000;
+}
+
+void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
+                                         Plot* plot) {
+  std::map<uint32_t, TimeSeries> time_series;
+
+  std::string message;

[aleloi, 2016/06/08 11:44:20]

It looks scary when message is defined outside of the loop, conditionally
updated and copied to a function. Nothing bad happens here, but in an artificial
scenario where extra_point_info is updated while this function is running you
could get points labeled with wrong messages.

Since it's not a performance issue, I want |message| moved into the loop. The
same for all the other variables except |header|.

Also, consider renaming message to maybe 'point_info'.

[terelius, 2016/06/14 13:18:49]

This is a rather artificial scenario. The code is not thread safe anyway, so the
only thing to worry about is updating |extra_point_info| within this loop.
However, changing the state of |extra_point_info| would be a major change to
what you are plotting, similar to changing which packet direction or which log
file you are plotting. This is typically not done at all and should definitely
not be done while a plot is being generated.

Anyway, I moved the declaration of |message| and made |extra_point_info| const,
but I disagree with moving the other variables. They are always accessed
together so it would be surprising if |header| wasn't declared with the others.
Moreover, the logic of the loop would be harder to follow if it was interspersed
with boiler-plate declarations.

+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;
+  float max_y = 0;
+
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, &media_type, header,
+                              &header_length, &total_length);
+      if (direction == desired_direction) {
+        // Parse header to get SSRC
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        // Filter on SSRC
+        if (MatchingSSRC(parsed_header.ssrc, desired_ssrc)) {
+          uint64_t timestamp = parsed_log.GetTimestamp(i);
+          float x = static_cast<float>(timestamp - begin_time) / 1000000;
+          float y = total_length;
+          max_y = (y > max_y) ? y : max_y;

[aleloi, 2016/06/08 11:44:20]

Make it consistent with the other min/max calculations. Unless this is the
standard in webrtc, I vote for std::max.

[terelius, 2016/06/14 13:18:48]

Done.

+          if (extra_point_info) {
+            message = HeaderToString(parsed_header);
+          }
+          time_series[parsed_header.ssrc].points.push_back(
+              TimeSeriesPoint(x, y, message));
+        }
+      }
+    }
+  }
+
+  // Set labels and put in graph

[stefan-webrtc, 2016/05/31 18:53:40]

End with .

[terelius, 2016/06/14 13:18:48]

Done.

+  for (auto& kv : time_series) {
+    kv.second.label = SSRCToString(kv.first);
+    kv.second.style = BAR_GRAPH;
+    plot->series.push_back(TimeSeries());
+    plot->series.back().swap(kv.second);
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = -1;
+  plot->yaxis_max = max_y * 1.1;

[aleloi, 2016/06/08 11:44:20]

Make 1.1, 1.02, -1 constants.

[terelius, 2016/06/14 13:18:49]

Done.

+  plot->yaxis_label = "Packet size (bytes)";
+  if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
+    plot->title = "Incoming RTP packets";
+  } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
+    plot->title = "Outgoing RTP packets";
+  }
+}
+
+// For each SSRC, plot the time between the consecutive playouts.
+void EventLogAnalyzer::CreatePlayoutGraph(Plot* plot) {
+  std::map<uint32_t, TimeSeries> time_series;
+  std::map<uint32_t, uint64_t> last_playout;
+
+  uint32_t ssrc;
+  float max_y = 0;
+
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::AUDIO_PLAYOUT_EVENT) {
+      parsed_log.GetAudioPlayout(i, &ssrc);
+      uint64_t timestamp = parsed_log.GetTimestamp(i);
+      if (MatchingSSRC(ssrc, desired_ssrc)) {
+        float x = static_cast<float>(timestamp - begin_time) / 1000000;
+        float y = static_cast<float>(timestamp - last_playout[ssrc]) / 1000;
+        if (time_series[ssrc].points.size() == 0) {
+          // There were no previusly logged playout for this SSRC.
+          // Generate a point, but place it on the x-axis.
+          y = 0;
+        }
+        max_y = (y > max_y) ? y : max_y;
+        time_series[ssrc].points.push_back(TimeSeriesPoint(x, y, ""));
+        last_playout[ssrc] = timestamp;
+      }
+    }
+  }
+
+  // Set labels and put in graph
+  for (auto& kv : time_series) {
+    kv.second.label = SSRCToString(kv.first);
+    kv.second.style = BAR_GRAPH;
+    plot->series.push_back(TimeSeries());
+    plot->series.back().swap(kv.second);
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;

[stefan-webrtc, 2016/05/31 18:53:40]

Maybe name the constant 1.02 "kXMargin" or something like that?

[terelius, 2016/06/14 13:18:48]

Done.

+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = -1;
+  plot->yaxis_max = max_y * 1.1;

[stefan-webrtc, 2016/05/31 18:53:40]

kYMargin?

[terelius, 2016/06/14 13:18:49]

Done.

+  plot->yaxis_label = "Time since last playout (ms)";
+  plot->title = "Audio playout";
+}
+
+// For each SSRC, plot the time between the consecutive playouts.
+void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
+  std::map<uint32_t, TimeSeries> time_series;
+  std::map<uint32_t, uint16_t> last_seqno;
+
+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;
+
+  int max_y = 1;
+  int min_y = 0;
+
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, &media_type, header,
+                              &header_length, &total_length);
+      uint64_t timestamp = parsed_log.GetTimestamp(i);
+      if (direction == PacketDirection::kIncomingPacket) {
+        // Parse header to get SSRC.
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        // Filter on SSRC.
+        if (MatchingSSRC(parsed_header.ssrc, desired_ssrc)) {
+          float x = static_cast<float>(timestamp - begin_time) / 1000000;
+          int y = WrappingDifference(parsed_header.sequenceNumber,
+                                     last_seqno[parsed_header.ssrc], 1ul << 16);
+          if (time_series[parsed_header.ssrc].points.size() == 0) {
+            // There were no previusly logged playout for this SSRC.
+            // Generate a point, but place it on the x-axis.
+            y = 0;
+          }
+          max_y = (y > max_y) ? y : max_y;
+          min_y = (y < min_y) ? y : min_y;
+          time_series[parsed_header.ssrc].points.push_back(
+              TimeSeriesPoint(x, y, ""));
+          last_seqno[parsed_header.ssrc] = parsed_header.sequenceNumber;
+        }
+      }
+    }
+  }
+
+  // Set labels and put in graph.
+  for (auto& kv : time_series) {
+    kv.second.label = SSRCToString(kv.first);
+    kv.second.style = BAR_GRAPH;
+    plot->series.push_back(TimeSeries());
+    plot->series.back().swap(kv.second);
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = min_y - 0.05 * (max_y - min_y);
+  plot->yaxis_max = max_y + 0.05 * (max_y - min_y);
+  plot->yaxis_label = "Difference since last packet";
+  plot->title = "Sequence number";
+}
+
+void EventLogAnalyzer::CreateDelayChangeGraph(Plot* plot) {
+  // Maps a stream identifier consisting of ssrc, direction and MediaType
+  // to the header extensions used by that stream,
+  std::map<uint64_t, RtpHeaderExtensionMap> extension_maps;
+
+  struct SendReceiveTime {
+    SendReceiveTime() = default;
+    SendReceiveTime(uint32_t send_time, uint64_t recv_time)
+        : absoluteSendTime(send_time), receiveTimestamp(recv_time) {}
+    uint32_t absoluteSendTime;  // 24-bit value in units of 2^-18 seconds
+    uint64_t receiveTimestamp;  // In microseconds
+  };
+  std::map<uint64_t, SendReceiveTime> last_packet;
+  std::map<uint64_t, TimeSeries> time_series;
+
+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;
+
+  float max_y = 10;
+  float min_y = 0;
+
+  //

[stefan-webrtc, 2016/05/31 18:53:40]

Remove?

[terelius, 2016/06/14 13:18:48]

Done.

+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT) {
+      VideoReceiveStream::Config config(nullptr);
+      parsed_log.GetVideoReceiveConfig(i, &config);
+      uint64_t stream = GetStreamID(config.rtp.remote_ssrc, kIncomingPacket,
+                                    MediaType::VIDEO);
+      extension_maps[stream].Erase();
+      for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
+        const std::string& extension = config.rtp.extensions[j].name;

[aleloi, 2016/06/03 08:51:11]

RtpExtension.name was removed in 6f8d686d. It seems to have been renamed into
`RtpExtension.uri' now.

[terelius, 2016/06/14 13:18:48]

Done.

+        int id = config.rtp.extensions[j].id;
+        extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                        id);
+      }
+    } else if (event_type == ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT) {
+      VideoSendStream::Config config(nullptr);
+      parsed_log.GetVideoSendConfig(i, &config);
+      for (auto ssrc : config.rtp.ssrcs) {
+        uint64_t stream = GetStreamID(ssrc, kIncomingPacket, MediaType::VIDEO);
+        extension_maps[stream].Erase();
+        for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
+          const std::string& extension = config.rtp.extensions[j].name;
+          int id = config.rtp.extensions[j].id;
+          extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                          id);
+        }
+      }
+    } else if (event_type == ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
+      AudioReceiveStream::Config config;
+      // TODO(terelius): Parse the audio configs once we have them
+    } else if (event_type == ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT) {
+      AudioSendStream::Config config(nullptr);
+      // TODO(terelius): Parse the audio configs once we have them
+    } else if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, &media_type, header,
+                              &header_length, &total_length);
+      if (direction == kIncomingPacket) {
+        // Parse header to get SSRC
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        // Filter on SSRC
+        if (MatchingSSRC(parsed_header.ssrc, desired_ssrc)) {
+          uint64_t stream =
+              GetStreamID(parsed_header.ssrc, direction, media_type);
+          // Look up the extension_map and parse it again to get the extensions.
+          if (extension_maps.count(stream) == 1) {
+            RtpHeaderExtensionMap* extension_map = &extension_maps[stream];
+            rtp_parser.Parse(&parsed_header, extension_map);
+            if (parsed_header.extension.hasAbsoluteSendTime) {
+              uint64_t timestamp = parsed_log.GetTimestamp(i);
+              int64_t send_time_diff = WrappingDifference(
+                  parsed_header.extension.absoluteSendTime,
+                  last_packet[stream].absoluteSendTime, 1ul << 24);
+              int64_t recv_time_diff =
+                  timestamp - last_packet[stream].receiveTimestamp;
+
+              float x = static_cast<float>(timestamp - begin_time) / 1000000;
+              double y = static_cast<double>(
+                             recv_time_diff -
+                             AbsSendTimeToMicroseconds(send_time_diff)) /
+                         1000;
+              if (time_series[stream].points.size() == 0) {
+                // There were no previusly logged playout for this SSRC.
+                // Generate a point, but place it on the x-axis.
+                y = 0;
+              }
+
+              max_y = (y > max_y) ? y : max_y;
+              min_y = (y < min_y) ? y : min_y;
+              time_series[stream].points.push_back(TimeSeriesPoint(x, y, ""));
+              last_packet[stream] = SendReceiveTime(
+                  parsed_header.extension.absoluteSendTime, timestamp);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Set labels and put in graph
+  for (auto& kv : time_series) {
+    kv.second.label = SSRCToString(GetSsrcFromStreamID(kv.first));
+    kv.second.style = BAR_GRAPH;
+    plot->series.push_back(TimeSeries());
+    plot->series.back().swap(kv.second);
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = min_y - 0.05 * (max_y - min_y);
+  plot->yaxis_max = max_y + 0.05 * (max_y - min_y);
+  plot->yaxis_label = "Latency change (ms)";
+  plot->title = "Network latency change between consecutive packets";
+}
+
+void EventLogAnalyzer::CreateAccumulatedDelayChangeGraph(Plot* plot) {
+  // TODO(terelius): Refactor

[stefan-webrtc, 2016/05/31 18:53:39]

Is the plan to base this method on the previous one in some way?

[terelius, 2016/06/14 13:18:49]

Not really base one on the other, but there is a lot of similarities in parsing
and filtering the packets. I'm currently leaning towards keeping a list of
parsed RTP headers in the class and add convenience functions to find the next
packet that matches a certain set of conditions. I think that could reduce the
code size of all/most of the CreateXYZGraph() functions. Though there are other
options too, and it is possible that both graphs should be generated at the same
time.

+
+  // Maps a stream identifier consisting of ssrc, direction and MediaType
+  // to the header extensions used by that stream,
+  std::map<uint64_t, RtpHeaderExtensionMap> extension_maps;
+
+  struct SendReceiveTime {
+    SendReceiveTime() = default;
+    SendReceiveTime(uint32_t send_time, uint64_t recv_time, double accumulated)
+        : absoluteSendTime(send_time),
+          receiveTimestamp(recv_time),
+          accumulatedDelay(accumulated) {}
+    uint32_t absoluteSendTime;  // 24-bit value in units of 2^-18 seconds
+    uint64_t receiveTimestamp;  // In microseconds
+    double accumulatedDelay;    // In milliseconds

[stefan-webrtc, 2016/05/31 18:53:40]

No camel case

[terelius, 2016/06/14 13:18:48]

Done. However, this means that I am no longer consistent with
RtpUtility::RtpHeaderParser.

+  };
+  std::map<uint64_t, SendReceiveTime> last_packet;
+  std::map<uint64_t, TimeSeries> time_series;
+
+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;
+
+  double max_y = 10;
+  double min_y = 0;
+
+  //
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT) {
+      VideoReceiveStream::Config config(nullptr);
+      parsed_log.GetVideoReceiveConfig(i, &config);
+      uint64_t stream = GetStreamID(config.rtp.remote_ssrc, kIncomingPacket,
+                                    MediaType::VIDEO);
+      extension_maps[stream].Erase();
+      for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
+        const std::string& extension = config.rtp.extensions[j].name;
+        int id = config.rtp.extensions[j].id;
+        extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                        id);
+      }
+    } else if (event_type == ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT) {
+      VideoSendStream::Config config(nullptr);
+      parsed_log.GetVideoSendConfig(i, &config);
+      for (auto ssrc : config.rtp.ssrcs) {
+        uint64_t stream = GetStreamID(ssrc, kIncomingPacket, MediaType::VIDEO);
+        extension_maps[stream].Erase();
+        for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
+          const std::string& extension = config.rtp.extensions[j].name;
+          int id = config.rtp.extensions[j].id;
+          extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                          id);
+        }
+      }
+    } else if (event_type == ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
+      AudioReceiveStream::Config config;
+      // TODO(terelius): Parse the audio configs once we have them
+    } else if (event_type == ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT) {
+      AudioSendStream::Config config(nullptr);
+      // TODO(terelius): Parse the audio configs once we have them
+    } else if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, &media_type, header,
+                              &header_length, &total_length);
+      if (direction == kIncomingPacket) {
+        // Parse header to get SSRC
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        // Filter on SSRC
+        if (MatchingSSRC(parsed_header.ssrc, desired_ssrc)) {
+          uint64_t stream =
+              GetStreamID(parsed_header.ssrc, direction, media_type);
+          // Look up the extension_map and parse it again to get the extensions.
+          if (extension_maps.count(stream) == 1) {
+            RtpHeaderExtensionMap* extension_map = &extension_maps[stream];
+            rtp_parser.Parse(&parsed_header, extension_map);
+            if (parsed_header.extension.hasAbsoluteSendTime) {
+              uint64_t timestamp = parsed_log.GetTimestamp(i);
+              int64_t send_time_diff = WrappingDifference(
+                  parsed_header.extension.absoluteSendTime,
+                  last_packet[stream].absoluteSendTime, 1ul << 24);
+              int64_t recv_time_diff =
+                  timestamp - last_packet[stream].receiveTimestamp;
+
+              float x = static_cast<float>(timestamp - begin_time) / 1000000;
+              double y = last_packet[stream].accumulatedDelay +
+                         static_cast<double>(
+                             recv_time_diff -
+                             AbsSendTimeToMicroseconds(send_time_diff)) /
+                             1000;
+              if (time_series[stream].points.size() == 0) {
+                // There were no previusly logged playout for this SSRC.
+                // Generate a point, but place it on the x-axis.
+                y = 0;
+              }
+
+              max_y = (y > max_y) ? y : max_y;
+              min_y = (y < min_y) ? y : min_y;
+              time_series[stream].points.push_back(TimeSeriesPoint(x, y, ""));
+              last_packet[stream] = SendReceiveTime(
+                  parsed_header.extension.absoluteSendTime, timestamp, y);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Set labels and put in graph
+  for (auto& kv : time_series) {
+    kv.second.label = SSRCToString(GetSsrcFromStreamID(kv.first));
+    kv.second.style = LINE_GRAPH;
+    plot->series.push_back(TimeSeries());
+    plot->series.back().swap(kv.second);
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = min_y - 0.05 * (max_y - min_y);
+  plot->yaxis_max = max_y + 0.05 * (max_y - min_y);
+  plot->yaxis_label = "Latency change (ms)";
+  plot->title = "Accumulated network latency change";
+}
+
+// Plot the total bandwitch used by all RTP streams.
+void EventLogAnalyzer::CreateTotalBitrateGraph(
+    PacketDirection desired_direction,
+    Plot* plot) {
+  struct TimestampSize {
+    TimestampSize(uint64_t t, size_t s) : timestamp(t), size(s) {}
+    uint64_t timestamp;
+    size_t size;
+  };
+  std::vector<TimestampSize> packets;
+
+  PacketDirection direction;
+  size_t total_length;
+
+  // Extract timestamps and sizes for the relevant packets.
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, nullptr, nullptr, nullptr,
+                              &total_length);
+      if (direction == desired_direction) {
+        uint64_t timestamp = parsed_log.GetTimestamp(i);
+        packets.push_back(TimestampSize(timestamp, total_length));
+      }
+    }
+  }
+
+  size_t window_index_begin = 0;
+  size_t window_index_end = 0;
+  size_t bytes_in_window = 0;
+  float max_y = 0;
+
+  // Calculate a moving average of the bitrate and store in a TimeSeries.
+  plot->series.push_back(TimeSeries());
+  for (uint64_t time = begin_time; time < end_time + step; time += step) {
+    while (window_index_end < packets.size() &&
+           packets[window_index_end].timestamp < time) {
+      bytes_in_window += packets[window_index_end].size;
+      window_index_end++;
+    }
+    while (window_index_begin < packets.size() &&
+           packets[window_index_begin].timestamp < time - window_duration) {
+      bytes_in_window -= packets[window_index_begin].size;
+      window_index_begin++;
+    }
+    RTC_DCHECK_LE(0ul, bytes_in_window);
+    float window_duration_in_seconds =
+        static_cast<float>(window_duration) / 1000000;
+    float x = static_cast<float>(time - begin_time) / 1000000;
+    float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
+    max_y = (y > max_y) ? y : max_y;
+    plot->series.back().points.push_back(TimeSeriesPoint(x, y));
+  }
+
+  // Set labels
+  if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
+    plot->series.back().label = "Incoming bitrate";
+  } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
+    plot->series.back().label = "Outgoing bitrate";
+  }
+  plot->series.back().style = LINE_GRAPH;
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = -1;
+  plot->yaxis_max = max_y * 1.1;
+  plot->yaxis_label = "Bitrate (kbps)";
+  if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
+    plot->title = "Incoming RTP bitrate";
+  } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
+    plot->title = "Outgoing RTP bitrate";
+  }
+}
+
+// For each SSRC, plot the bandwitch used by that stream.
+void EventLogAnalyzer::CreateStreamBitrateGraph(
+    PacketDirection desired_direction,
+    Plot* plot) {
+  struct TimestampSize {
+    TimestampSize(uint64_t t, size_t s) : timestamp(t), size(s) {}
+    uint64_t timestamp;
+    size_t size;
+  };
+  std::map<uint32_t, std::vector<TimestampSize> > packets;
+
+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;
+
+  // Extract timestamps and sizes for the relevant packets.
+  for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+    ParsedRtcEventLog::EventType event_type = parsed_log.GetEventType(i);
+    if (event_type == ParsedRtcEventLog::RTP_EVENT) {
+      parsed_log.GetRtpHeader(i, &direction, &media_type, header,
+                              &header_length, &total_length);
+      if (direction == desired_direction) {
+        // Parse header to get SSRC
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        // Filter on SSRC
+        if (MatchingSSRC(parsed_header.ssrc, desired_ssrc)) {
+          uint64_t timestamp = parsed_log.GetTimestamp(i);
+          packets[parsed_header.ssrc].push_back(
+              TimestampSize(timestamp, total_length));
+        }
+      }
+    }
+  }
+
+  float max_y = 0;
+
+  for (auto& kv : packets) {
+    size_t window_index_begin = 0;
+    size_t window_index_end = 0;
+    size_t bytes_in_window = 0;
+
+    // Calculate a moving average of the bitrate and store in a TimeSeries.
+    plot->series.push_back(TimeSeries());
+    for (uint64_t time = begin_time; time < end_time + step; time += step) {
+      while (window_index_end < kv.second.size() &&
+             kv.second[window_index_end].timestamp < time) {
+        bytes_in_window += kv.second[window_index_end].size;
+        window_index_end++;
+      }
+      while (window_index_begin < kv.second.size() &&
+             kv.second[window_index_begin].timestamp < time - window_duration) {
+        bytes_in_window -= kv.second[window_index_begin].size;
+        window_index_begin++;
+      }
+      RTC_DCHECK_LE(0ul, bytes_in_window);
+      float window_duration_in_seconds =
+          static_cast<float>(window_duration) / 1000000;
+      float x = static_cast<float>(time - begin_time) / 1000000;
+      float y = bytes_in_window * 8 / window_duration_in_seconds / 1000;
+      max_y = (y > max_y) ? y : max_y;
+      plot->series.back().points.push_back(TimeSeriesPoint(x, y));
+    }
+
+    // Set labels
+    plot->series.back().label = SSRCToString(kv.first);
+    plot->series.back().style = LINE_GRAPH;
+  }
+
+  plot->xaxis_min = -1;
+  plot->xaxis_max = (end_time - begin_time) / 1000000 * 1.02;
+  plot->xaxis_label = "Time (s)";
+  plot->yaxis_min = -1;
+  plot->yaxis_max = max_y * 1.1;
+  plot->yaxis_label = "Bitrate (kbps)";
+  if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
+    plot->title = "Incoming bitrate per stream";
+  } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
+    plot->title = "Outgoing bitrate per stream";
+  }
+}
+
+}  // namespace plotting
+}  // namespace webrtc