Add a chart for packet loss on incoming streams.

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 441 matching lines @@
     bool bitrate_updated = bitrate_updated_;
     bitrate_updated_ = false;
     return bitrate_updated;
   }
 
  private:
   uint32_t last_bitrate_bps_;
   bool bitrate_updated_;
 };
 
-bool EventLogAnalyzer::IsRtxSsrc(StreamId stream_id) {
+bool EventLogAnalyzer::IsRtxSsrc(StreamId stream_id) const {
   return rtx_ssrcs_.count(stream_id) == 1;
 }
 
-bool EventLogAnalyzer::IsVideoSsrc(StreamId stream_id) {
+bool EventLogAnalyzer::IsVideoSsrc(StreamId stream_id) const {
   return video_ssrcs_.count(stream_id) == 1;
 }
 
-bool EventLogAnalyzer::IsAudioSsrc(StreamId stream_id) {
+bool EventLogAnalyzer::IsAudioSsrc(StreamId stream_id) const {
   return audio_ssrcs_.count(stream_id) == 1;
 }
 
+std::string EventLogAnalyzer::GetStreamName(StreamId stream_id) const {
+  std::stringstream name;
+  if (IsAudioSsrc(stream_id)) {
+    name << "Audio ";
+  } else if (IsVideoSsrc(stream_id)) {
+    name << "Video ";
+  } else {
+    name << "Unknown ";
+  }
+  if (IsRtxSsrc(stream_id))
+    name << "RTX ";
+  name << SsrcToString(stream_id.GetSsrc());
+  return name.str();
+}
+
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != desired_direction ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series;
-    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.label = GetStreamName(stream_id);
     time_series.style = BAR_GRAPH;
     Pointwise<PacketSizeBytes>(packet_stream, begin_time_, &time_series);
     plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Packet size (bytes)", kBottomMargin,
                           kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming RTP packets");
@@ skipping 11 matching lines @@
   for (auto& kv : packets) {
     StreamId stream_id = kv.first;
     const std::vector<T>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != desired_direction ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series;
-    time_series.label = label_prefix + " " + SsrcToString(stream_id.GetSsrc());
+    time_series.label = label_prefix + " " + GetStreamName(stream_id);
     time_series.style = LINE_GRAPH;
 
     for (size_t i = 0; i < packet_stream.size(); i++) {
       float x = static_cast<float>(packet_stream[i].timestamp - begin_time_) /
                 1000000;
       time_series.points.emplace_back(x, i);
       time_series.points.emplace_back(x, i + 1);
     }
 
     plot->series_list_.push_back(std::move(time_series));
@@ skipping 61 matching lines @@
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // 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.label = GetStreamName(stream_id);
     time_series.style = BAR_GRAPH;
     Pairwise<SequenceNumberDiff>(packet_stream, begin_time_, &time_series);
     plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Difference since last packet", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Sequence number");
 }
 
+void EventLogAnalyzer::CreateIncomingPacketLossGraph(Plot* plot) {
+  for (auto& kv : rtp_packets_) {
+    StreamId stream_id = kv.first;
+    const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
+    // Filter on direction and SSRC.
+    if (stream_id.GetDirection() != kIncomingPacket ||
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
+      continue;
+    }
+
+    TimeSeries time_series;
+    time_series.label = GetStreamName(stream_id);
+    time_series.style = LINE_DOT_GRAPH;
+    const uint64_t kWindowUs = 1000000;
+    const LoggedRtpPacket* first_in_window = &packet_stream.front();
+    const LoggedRtpPacket* last_in_window = &packet_stream.front();
+    int packets_in_window = 0;
+    for (const LoggedRtpPacket& packet : packet_stream) {
+      if (packet.timestamp > first_in_window->timestamp + kWindowUs) {
+        uint16_t expected = last_in_window->header.sequenceNumber -

[philipel, 2016/09/08 13:05:52]

I guess reordering will show up as packet loss, or even as negative packet loss.
Is there some easy way to fix that?

[philipel, 2016/09/08 13:05:52]

|expected| is kind of generic, |expected_num_packets maybe|?

[stefan-webrtc, 2016/09/09 07:12:25]

Reordering around the window boundaries, yes. It becomes a lot more complicated
to try to solve that, so I think we'll just have to keep that in mind. Maybe we
could add a graph for reordered packets instead.

[stefan-webrtc, 2016/09/09 07:12:25]

Done.

+            first_in_window->header.sequenceNumber + 1;
+        float fraction_lost = (expected - packets_in_window) /
+            static_cast<float>(expected);
+        float y = fraction_lost * 100;
+        float x =
+            static_cast<float>(last_in_window->timestamp - begin_time_) /
+            1000000;
+        time_series.points.emplace_back(x, y);
+        first_in_window = &packet;
+        last_in_window = &packet;
+        packets_in_window = 1;
+        continue;
+      }
+      ++packets_in_window;
+      last_in_window = &packet;
+    }
+    plot->series_list_.push_back(std::move(time_series));
+  }
+
+  plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
+  plot->SetSuggestedYAxis(0, 1, "Loss rate (%)", kBottomMargin,
+                          kTopMargin);
+  plot->SetTitle("Incoming loss rate");
+}
+
 void EventLogAnalyzer::CreateDelayChangeGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
-    uint32_t ssrc = stream_id.GetSsrc();
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
-        !MatchingSsrc(ssrc, desired_ssrc_) || IsAudioSsrc(stream_id) ||
-        !IsVideoSsrc(stream_id) || IsRtxSsrc(stream_id)) {
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
+        IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
+        IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data;
-    capture_time_data.label = SsrcToString(ssrc) + " capture-time";
+    capture_time_data.label = GetStreamName(stream_id) + " capture-time";
     capture_time_data.style = BAR_GRAPH;
     Pairwise<NetworkDelayDiff::CaptureTime>(packet_stream, begin_time_,
                                             &capture_time_data);
     plot->series_list_.push_back(std::move(capture_time_data));
 
     TimeSeries send_time_data;
-    send_time_data.label = SsrcToString(ssrc) + " abs-send-time";
+    send_time_data.label = GetStreamName(stream_id) + " abs-send-time";
     send_time_data.style = BAR_GRAPH;
     Pairwise<NetworkDelayDiff::AbsSendTime>(packet_stream, begin_time_,
                                             &send_time_data);
     plot->series_list_.push_back(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Network latency change between consecutive packets");
 }
 
 void EventLogAnalyzer::CreateAccumulatedDelayChangeGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
-    uint32_t ssrc = stream_id.GetSsrc();
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
-        !MatchingSsrc(ssrc, desired_ssrc_) || IsAudioSsrc(stream_id) ||
-        !IsVideoSsrc(stream_id) || IsRtxSsrc(stream_id)) {
+        !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_) ||
+        IsAudioSsrc(stream_id) || !IsVideoSsrc(stream_id) ||
+        IsRtxSsrc(stream_id)) {
       continue;
     }
 
     TimeSeries capture_time_data;
-    capture_time_data.label = SsrcToString(ssrc) + " capture-time";
+    capture_time_data.label = GetStreamName(stream_id) + " capture-time";
     capture_time_data.style = LINE_GRAPH;
     Pairwise<Accumulated<NetworkDelayDiff::CaptureTime>>(
         packet_stream, begin_time_, &capture_time_data);
     plot->series_list_.push_back(std::move(capture_time_data));
 
     TimeSeries send_time_data;
-    send_time_data.label = SsrcToString(ssrc) + " abs-send-time";
+    send_time_data.label = GetStreamName(stream_id) + " abs-send-time";
     send_time_data.style = LINE_GRAPH;
     Pairwise<Accumulated<NetworkDelayDiff::AbsSendTime>>(
         packet_stream, begin_time_, &send_time_data);
     plot->series_list_.push_back(std::move(send_time_data));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Latency change (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Accumulated network latency change");
@@ skipping 105 matching lines @@
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != desired_direction ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
 
     TimeSeries time_series;
-    time_series.label = SsrcToString(stream_id.GetSsrc());
+    time_series.label = GetStreamName(stream_id);
     time_series.style = LINE_GRAPH;
     double bytes_to_kilobits = 8.0 / 1000;
     MovingAverage<PacketSizeBytes>(packet_stream, begin_time_, end_time_,
                                    window_duration_, step_, bytes_to_kilobits,
                                    &time_series);
     plot->series_list_.push_back(std::move(time_series));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
@@ skipping 210 matching lines @@
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Network Delay Change.");
 }
 }  // namespace plotting
 }  // namespace webrtc