Video/Screenshare loopback tool.

webrtc/rtc_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 491 matching lines @@
       }
       case ParsedRtcEventLog::BWE_PROBE_CLUSTER_CREATED_EVENT: {
         bwe_probe_cluster_created_events_.push_back(
             parsed_log_.GetBweProbeClusterCreated(i));
         break;
       }
       case ParsedRtcEventLog::BWE_PROBE_RESULT_EVENT: {
         bwe_probe_result_events_.push_back(parsed_log_.GetBweProbeResult(i));
         break;
       }
+      case ParsedRtcEventLog::BWE_ACKED_BITRATE_EVENT: {
+        acked_bitrate_events_.push_back(parsed_log_.GetAckedBitrate(i));
+        break;
+      }
+      case ParsedRtcEventLog::ALR_STATE_EVENT: {
+        alr_state_events_.push_back(parsed_log_.GetAlrState(i));
+        break;
+      }
+      case ParsedRtcEventLog::PACKET_QUEUE_TIME: {
+        packet_queue_time_events_.push_back(parsed_log_.GetQueueTime(i));
+        break;
+      }
       case ParsedRtcEventLog::UNKNOWN_EVENT: {
         break;
       }
     }
   }
 
   if (last_timestamp < first_timestamp) {
     // No useful events in the log.
     first_timestamp = last_timestamp = 0;
   }
@@ skipping 494 matching lines @@
 
     TimeSeries result_series("Probing results.", DOT_GRAPH);
     for (auto& result : bwe_probe_result_events_) {
       if (result.bitrate_bps) {
         float x = static_cast<float>(result.timestamp - begin_time_) / 1000000;
         float y = static_cast<float>(*result.bitrate_bps) / 1000;
         result_series.points.emplace_back(x, y);
       }
     }
 
+    TimeSeries acked_bitrate("Acked bitrate", LINE_GRAPH);
+    for (auto& ab : acked_bitrate_events_) {
+      float x = static_cast<float>(ab.timestamp - begin_time_) / 1000000;
+      float y = static_cast<float>(ab.bitrate_bps / 1000);
+      acked_bitrate.points.emplace_back(x, y);
+    }
+
+    TimeSeries alr_usage("Bitrate usage", LINE_GRAPH);
+    IntervalSeries alr_state("ALR", "#555555", IntervalSeries::kHorizontal);
+    bool in_alr = false;
+    int64_t alr_start = 0;
+    for (auto& alr : alr_state_events_) {
+      float y = static_cast<float>(alr.timestamp - begin_time_) / 1000000;
+      alr_usage.points.emplace_back(y, alr.usage_bps / 1000);
+      if (!in_alr && alr.in_alr) {
+        alr_start = alr.timestamp;
+        in_alr = true;
+      } else if (in_alr && !alr.in_alr) {
+        float x = static_cast<float>(alr_start - begin_time_) / 1000000;
+        alr_state.intervals.emplace_back(x, y);
+        in_alr = false;
+      }
+    }
+
+    if (in_alr) {
+      float x = static_cast<float>(alr_start - begin_time_) / 1000000;
+      float y = static_cast<float>(end_time_ - begin_time_) / 1000000;
+      alr_state.intervals.emplace_back(x, y);
+    }
+
     if (show_detector_state) {
       plot->AppendIntervalSeries(std::move(overusing_series));
       plot->AppendIntervalSeries(std::move(underusing_series));
       plot->AppendIntervalSeries(std::move(normal_series));
+      plot->AppendIntervalSeries(std::move(alr_state));
     }
 
     plot->AppendTimeSeries(std::move(bitrate_series));
     plot->AppendTimeSeries(std::move(loss_series));
     plot->AppendTimeSeries(std::move(delay_series));
     plot->AppendTimeSeries(std::move(created_series));
     plot->AppendTimeSeries(std::move(result_series));
+    plot->AppendTimeSeries(std::move(acked_bitrate));
+    plot->AppendTimeSeries(std::move(alr_usage));
   }
 
   // Overlay the incoming REMB over the outgoing bitrate
   // and outgoing REMB over incoming bitrate.
   PacketDirection remb_direction =
       desired_direction == kOutgoingPacket ? kIncomingPacket : kOutgoingPacket;
   TimeSeries remb_series("Remb", LINE_STEP_GRAPH);
   std::multimap<uint64_t, const LoggedRtcpPacket*> remb_packets;
   for (const auto& kv : rtcp_packets_) {
     if (kv.first.GetDirection() == remb_direction) {
@@ skipping 17 matching lines @@
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   if (desired_direction == webrtc::PacketDirection::kIncomingPacket) {
     plot->SetTitle("Incoming RTP bitrate");
   } else if (desired_direction == webrtc::PacketDirection::kOutgoingPacket) {
     plot->SetTitle("Outgoing RTP bitrate");
   }
 }
 
+void EventLogAnalyzer::CreateQueueDelayGraph(Plot* plot) {
+  std::map<uint32_t, TimeSeries> series;
+  float max = 0;
+  for (auto& qt : packet_queue_time_events_) {
+    auto it = series.find(qt.ssrc);
+    if (it == series.end()) {
+      std::stringstream ss;
+      ss << "SSRC " << qt.ssrc;
+      it = series
+               .insert(std::make_pair(qt.ssrc,
+                                      TimeSeries(ss.str(), LINE_DOT_GRAPH)))
+               .first;
+    }
+
+    float x = static_cast<float>(qt.timestamp - begin_time_) / 1000000;
+    float y = static_cast<float>(qt.queue_time_ms);
+    max = y > max ? y : max;
+    it->second.points.emplace_back(x, y);
+  }
+
+  for (auto& ts : series)
+    plot->AppendTimeSeries(std::move(ts.second));
+  plot->SetTitle("Pacer queue time");
+  plot->SetXAxis(0, call_duration_s_, "Time (s)");
+  plot->SetYAxis(0, max * 1.1, "Time (ms)");
+}
+
 // For each SSRC, plot the bandwidth used by that stream.
 void EventLogAnalyzer::CreateStreamBitrateGraph(
     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_)) {
@@ skipping 634 matching lines @@
     plot->AppendTimeSeries(std::move(series.second));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetYAxis(min_y_axis, max_y_axis, "Relative delay (ms)", kBottomMargin,
                  kTopMargin);
   plot->SetTitle("NetEq timing");
 }
 }  // namespace plotting
 }  // namespace webrtc