Event log visualization tool keeps a map from SSRC to parsed headers

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.
  */
 
@@ skipping 58 matching lines @@
   int64_t min_difference = max_difference - modulus + 1;
   if (difference > max_difference) {
     difference -= modulus;
   }
   if (difference < min_difference) {
     difference += modulus;
   }
   return difference;
 }
 
-class StreamId {
- public:
-  StreamId(uint32_t ssrc,
-           webrtc::PacketDirection direction,
-           webrtc::MediaType media_type)
-      : ssrc_(ssrc), direction_(direction), media_type_(media_type) {}
-
-  bool operator<(const StreamId& other) const {
-    if (ssrc_ < other.ssrc_) {
-      return true;
-    }
-    if (ssrc_ == other.ssrc_) {
-      if (media_type_ < other.media_type_) {
-        return true;
-      }
-      if (media_type_ == other.media_type_) {
-        if (direction_ < other.direction_) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  bool operator==(const StreamId& other) const {
-    return ssrc_ == other.ssrc_ && direction_ == other.direction_ &&
-           media_type_ == other.media_type_;
-  }
-
-  uint32_t GetSsrc() const { return ssrc_; }
-
- private:
-  uint32_t ssrc_;
-  webrtc::PacketDirection direction_;
-  webrtc::MediaType media_type_;
-};
-
 const double kXMargin = 1.02;
 const double kYMargin = 1.1;
 const double kDefaultXMin = -1;
 const double kDefaultYMin = -1;
 
 }  // namespace
 
 namespace webrtc {
 namespace plotting {
 
 EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
     : parsed_log_(log), window_duration_(250000), step_(10000) {
   uint64_t first_timestamp = std::numeric_limits<uint64_t>::max();
   uint64_t last_timestamp = std::numeric_limits<uint64_t>::min();
+
+  // Maps a stream identifier consisting of ssrc, direction and MediaType
+  // to the header extensions used by that stream,
+  std::map<StreamId, RtpHeaderExtensionMap> extension_maps;
+
+  PacketDirection direction;
+  MediaType media_type;
+  uint8_t header[IP_PACKET_SIZE];
+  size_t header_length, total_length;

[philipel, 2016/07/14 14:36:14]

split to two lines

[terelius, 2016/07/18 15:48:13]

Done.

+
   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);
-    first_timestamp = std::min(first_timestamp, timestamp);
-    last_timestamp = std::max(last_timestamp, timestamp);
+    if (event_type != ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT &&
+        event_type != ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT &&
+        event_type != ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT &&
+        event_type != ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT) {
+      uint64_t timestamp = parsed_log_.GetTimestamp(i);
+      first_timestamp = std::min(first_timestamp, timestamp);
+      last_timestamp = std::max(last_timestamp, timestamp);
+    }
+
+    switch (parsed_log_.GetEventType(i)) {
+      case ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT: {
+        VideoReceiveStream::Config config(nullptr);
+        parsed_log_.GetVideoReceiveConfig(i, &config);
+        StreamId stream(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].uri;
+          int id = config.rtp.extensions[j].id;
+          extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                          id);
+        }
+        break;
+      }
+      case ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT: {
+        VideoSendStream::Config config(nullptr);
+        parsed_log_.GetVideoSendConfig(i, &config);
+        for (auto ssrc : config.rtp.ssrcs) {
+          StreamId stream(ssrc, kOutgoingPacket, 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].uri;
+            int id = config.rtp.extensions[j].id;
+            extension_maps[stream].Register(StringToRtpExtensionType(extension),
+                                            id);
+          }
+        }
+        break;
+      }
+      case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
+        AudioReceiveStream::Config config;
+        // TODO(terelius): Parse the audio configs once we have them.
+        break;
+      }
+      case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
+        AudioSendStream::Config config(nullptr);
+        // TODO(terelius): Parse the audio configs once we have them.
+        break;
+      }
+      case ParsedRtcEventLog::RTP_EVENT: {
+        parsed_log_.GetRtpHeader(i, &direction, &media_type, header,
+                                 &header_length, &total_length);
+        // Parse header to get SSRC.
+        RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
+        RTPHeader parsed_header;
+        rtp_parser.Parse(&parsed_header);
+        StreamId stream(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);
+        }
+        uint64_t timestamp = parsed_log_.GetTimestamp(i);
+        rtp_packets_[stream].push_back(
+            LoggedRtpPacket(timestamp, parsed_header));
+        break;
+      }
+      case ParsedRtcEventLog::RTCP_EVENT: {
+        break;
+      }
+      case ParsedRtcEventLog::LOG_START: {
+        break;
+      }
+      case ParsedRtcEventLog::LOG_END: {
+        break;
+      }
+      case ParsedRtcEventLog::BWE_PACKET_LOSS_EVENT: {
+        break;
+      }
+      case ParsedRtcEventLog::BWE_PACKET_DELAY_EVENT: {
+        break;
+      }
+      case ParsedRtcEventLog::AUDIO_PLAYOUT_EVENT: {
+        break;
+      }
+      case ParsedRtcEventLog::UNKNOWN_EVENT: {
+        break;
+      }
+    }
   }
+
   if (last_timestamp < first_timestamp) {
     // No useful events in the log.
     first_timestamp = last_timestamp = 0;
   }
   begin_time_ = first_timestamp;
   end_time_ = last_timestamp;
 }
 
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
@@ skipping 146 matching lines @@
   plot->xaxis_min = kDefaultXMin;
   plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
   plot->xaxis_label = "Time (s)";
   plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (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<StreamId, RtpHeaderExtensionMap> extension_maps;
-
-  struct SendReceiveTime {
-    SendReceiveTime() = default;
-    SendReceiveTime(uint32_t send_time, uint64_t recv_time)
-        : absolute_send_time(send_time), receive_timestamp(recv_time) {}
-    uint32_t absolute_send_time;  // 24-bit value in units of 2^-18 seconds.
-    uint64_t receive_timestamp;   // In microseconds.
-  };
-  std::map<StreamId, SendReceiveTime> last_packet;
-  std::map<StreamId, 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);
-      StreamId stream(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].uri;
-        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) {
-        StreamId stream(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].uri;
-          int id = config.rtp.extensions[j].id;
-          extension_maps[stream].Register(StringToRtpExtensionType(extension),
-                                          id);
+  for (auto& kv : rtp_packets_) {
+    StreamId stream_id = kv.first;
+    // Filter on direction and SSRC.
+    if (stream_id.GetDirection() != kIncomingPacket ||
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
+      continue;
+    }
+
+    TimeSeries time_series;
+    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.style = BAR_GRAPH;
+    const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
+    int64_t last_abs_send_time = 0;
+    int64_t last_timestamp = 0;
+    for (const LoggedRtpPacket& packet : packet_stream) {
+      if (packet.header.extension.hasAbsoluteSendTime) {
+        int64_t send_time_diff =
+            WrappingDifference(packet.header.extension.absoluteSendTime,

[philipel, 2016/07/14 14:36:14]

You can include base/mod_ops.h and use the MinDiff function instead.

MinDiff<uint64_t, 1 << 24>(packet.header.extension.absoluteSendTime,
last_abs_send_time)

[terelius, 2016/07/18 15:48:13]

That's not quite the same thing though. I want to compute a-b and choose a
representative for the residue class with the smallest possible magnitude.
MinDiff computes either a-b or b-a, and chooses the smallest positive
representative for each residue class.

[philipel, 2016/07/18 16:29:47]

Right, I see.

+                               last_abs_send_time, 1ul << 24);
+        int64_t recv_time_diff = packet.timestamp - last_timestamp;

[philipel, 2016/07/14 14:36:14]

Do we know that |last_timestamp| <= |packet.timestamp| at this point? Maybe add
a DCHECK or use MinDiff if that is the intended diff we want to calculate.

[terelius, 2016/07/18 15:48:13]

The timestamp refers to the logging time. I think we can guarantee that
|last_timestamp| <= |packet.timestamp|, but only because packets belonging to
the same SSRC are logged on the same thread. If incoming packets were logged on
different threads, there could be a race between reading the time and inserting
the header into the log.

If packets were slightly reordered in the log compared to their timestamps
(because they are being delivered on multiple threads simultaneously), that
would just mean that packets don't have a definite arrival order (in any part of
WebRTC). We would then be comparing the network latency change relative to some
nearby packet, rather than to *the* preceding packet. The distinction is not
important in the graph.

I don't think a DCHECK would add much value here, but let me know if you
disagree. As mentioned before, MinDiff does not quite do what I want.

[philipel, 2016/07/18 16:29:48]

Acknowledged.

+
+        last_abs_send_time = packet.header.extension.absoluteSendTime;
+        last_timestamp = packet.timestamp;
+
+        float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
+        double y =
+            static_cast<double>(recv_time_diff -
+                                AbsSendTimeToMicroseconds(send_time_diff)) /
+            1000;
+        if (time_series.points.size() == 0) {
+          // There were no previously logged packets for this SSRC.
+          // Generate a point, but place it on the x-axis.
+          y = 0;
         }
-      }
-    } 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_)) {
-          StreamId stream(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].absolute_send_time, 1ul << 24);
-              int64_t recv_time_diff =
-                  timestamp - last_packet[stream].receive_timestamp;
-
-              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 = std::max(max_y, y);
-              min_y = std::min(min_y, y);
-              time_series[stream].points.push_back(TimeSeriesPoint(x, y));
-              last_packet[stream] = SendReceiveTime(
-                  parsed_header.extension.absoluteSendTime, timestamp);
-            }
-          }
-        }
+        max_y = std::max(max_y, y);
+        min_y = std::min(min_y, y);
+        time_series.points.push_back(TimeSeriesPoint(x, y));

[philipel, 2016/07/14 14:36:14]

Change to 'time_series.points.emplace_back(x, y)'. The TimeSeriesPoint object
will be constructed in place instead of being constructed then copied.

[terelius, 2016/07/18 15:48:13]

The chromium style guide is rather ambiguous about emplace:

"When using emplacement for performance reasons, your type should probably be
movable (since e.g. a vector of it might be resized); given a movable type,
then, consider whether you really need to avoid the move done by push_back().
For readability concerns, treat like auto; sometimes the brevity over
push_back() is a win, sometimes a loss."

TimeSeriesPoint is a small POD structure so constructing it is cheap. Do you
still prefer emplace?

[philipel, 2016/07/18 16:29:47]

Still prefer emplace_back, the reason is that you use two arguments (x and y) so
it's not ambiguous whether an object is being created or not. If it was just one
argument I would prefer push_back.

[terelius, 2016/07/18 16:38:04]

Done.

       }
     }
-  }
-
-  // Set labels and put in graph.
-  for (auto& kv : time_series) {
-    kv.second.label = SsrcToString(kv.first.GetSsrc());
-    kv.second.style = BAR_GRAPH;
-    plot->series.push_back(std::move(kv.second));
+    // Add the data set to the plot.
+    plot->series.push_back(std::move(time_series));
   }
 
   plot->xaxis_min = kDefaultXMin;
   plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
   plot->xaxis_label = "Time (s)";
   plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (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
-
-  // Maps a stream identifier consisting of ssrc, direction and MediaType
-  // to the header extensions used by that stream.
-  std::map<StreamId, RtpHeaderExtensionMap> extension_maps;
-
-  struct SendReceiveTime {
-    SendReceiveTime() = default;
-    SendReceiveTime(uint32_t send_time, uint64_t recv_time, double accumulated)
-        : absolute_send_time(send_time),
-          receive_timestamp(recv_time),
-          accumulated_delay(accumulated) {}
-    uint32_t absolute_send_time;  // 24-bit value in units of 2^-18 seconds.
-    uint64_t receive_timestamp;   // In microseconds.
-    double accumulated_delay;     // In milliseconds.
-  };
-  std::map<StreamId, SendReceiveTime> last_packet;
-  std::map<StreamId, 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);
-      StreamId stream(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].uri;
-        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) {
-        StreamId stream(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].uri;
-          int id = config.rtp.extensions[j].id;
-          extension_maps[stream].Register(StringToRtpExtensionType(extension),
-                                          id);
+  for (auto& kv : rtp_packets_) {

[philipel, 2016/07/14 14:36:14]

Can |kv| be changed to something more descriptive? Not super important since you
define |stream_id| and |packet_stream| shortly after.

[terelius, 2016/07/18 15:48:13]

I agree with you, but for (auto& kv : map) seems to be something of an informal
convention for iterating over maps. It is used in ~80 other places in the code.

Stefan, any input on this?

[philipel, 2016/07/18 16:29:47]

|kv| is fine.

[stefan-webrtc, 2016/07/18 16:58:50]

I think kv is ok the same way "it" is used for iterators. It doesn't add much
value to call something rtp_packet_iterator or, e.g., id_packet_pair. Or maybe
the later is useful... I've used kv a lot in the past.

+    StreamId stream_id = kv.first;
+    // Filter on direction and SSRC.
+    if (stream_id.GetDirection() != kIncomingPacket ||
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
+      continue;
+    }
+    TimeSeries time_series;
+    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.style = LINE_GRAPH;
+    const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
+    int64_t last_abs_send_time = 0;
+    int64_t last_timestamp = 0;
+    double accumulated_delay = 0;

[philipel, 2016/07/14 14:36:14]

accumulated_delay_ms

[terelius, 2016/07/18 15:48:14]

Done.

+    for (const LoggedRtpPacket& packet : packet_stream) {
+      if (packet.header.extension.hasAbsoluteSendTime) {
+        int64_t send_time_diff =
+            WrappingDifference(packet.header.extension.absoluteSendTime,

[philipel, 2016/07/14 14:36:14]

MinDiff()

[terelius, 2016/07/18 15:48:14]

See above.

[philipel, 2016/07/18 16:29:48]

Acknowledged.

+                               last_abs_send_time, 1ul << 24);
+        int64_t recv_time_diff = packet.timestamp - last_timestamp;

[philipel, 2016/07/14 14:36:14]

Maybe DCHECK or MinDiff()?

[terelius, 2016/07/18 15:48:14]

See above. I don't see what a DCHECK would accomplish.

[philipel, 2016/07/18 16:29:47]

Acknowledged.

+
+        last_abs_send_time = packet.header.extension.absoluteSendTime;
+        last_timestamp = packet.timestamp;
+
+        float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
+        accumulated_delay +=
+            static_cast<double>(recv_time_diff -
+                                AbsSendTimeToMicroseconds(send_time_diff)) /
+            1000;
+        if (time_series.points.size() == 0) {
+          // There were no previously logged packets for this SSRC.
+          // Generate a point, but place it on the x-axis.
+          accumulated_delay = 0;
         }
-      }
-    } 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_)) {
-          StreamId stream(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].absolute_send_time, 1ul << 24);
-              int64_t recv_time_diff =
-                  timestamp - last_packet[stream].receive_timestamp;
-
-              float x = static_cast<float>(timestamp - begin_time_) / 1000000;
-              double y = last_packet[stream].accumulated_delay +
-                         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 = std::max(max_y, y);
-              min_y = std::min(min_y, y);
-              time_series[stream].points.push_back(TimeSeriesPoint(x, y));
-              last_packet[stream] = SendReceiveTime(
-                  parsed_header.extension.absoluteSendTime, timestamp, y);
-            }
-          }
-        }
+        max_y = std::max(max_y, accumulated_delay);
+        min_y = std::min(min_y, accumulated_delay);
+        time_series.points.push_back(TimeSeriesPoint(x, accumulated_delay));

[philipel, 2016/07/14 14:36:14]

emplace_back

[terelius, 2016/07/18 15:48:14]

See above.

[philipel, 2016/07/18 16:29:47]

See above :)

[terelius, 2016/07/18 16:38:03]

Done.

       }
     }
-  }
-
-  // Set labels and put in graph.
-  for (auto& kv : time_series) {
-    kv.second.label = SsrcToString(kv.first.GetSsrc());
-    kv.second.style = LINE_GRAPH;
-    plot->series.push_back(std::move(kv.second));
+    // Add the data set to the plot.
+    plot->series.push_back(std::move(time_series));
   }
 
   plot->xaxis_min = kDefaultXMin;
   plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
   plot->xaxis_label = "Time (s)";
   plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_label = "Latency change (ms)";
   plot->title = "Accumulated network latency change";
 }
@@ skipping 153 matching lines @@
   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