Improvements to bandwidth plot. See Monorail issue for comparison.

webrtc/tools/py_event_log_analyzer/rtp_analyzer.py

 #  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.
 
 """Displays statistics and plots graphs from RTC protobuf dump."""
 
 from __future__ import division
 from __future__ import print_function
 
 import collections
 import optparse
 import sys
 
 import matplotlib.pyplot as plt
 import numpy
 
 import misc
 import pb_parse
 
 
 class RTPStatistics(object):
   """Has methods for calculating and plotting RTP stream statistics."""
 
   BANDWIDTH_SMOOTHING_WINDOW_SIZE = 10
+  PLOT_RESOLUTION_MS = 50
 
   def __init__(self, data_points):
     """Initializes object with data_points and computes simple statistics.
 
     Computes percentages of number of packets and packet sizes by
     SSRC.
 
     Args:
         data_points: list of pb_parse.DataPoints on which statistics are
             calculated.
@@ skipping 124 matching lines @@
     if freq is None or always_query_sample_rate:
       if not always_query_sample_rate:
         print ("Frequency could not be guessed.", end=" ")
       freq = int(misc.get_input("Input frequency (in kHz)> "))
     else:
       print("Guessed frequency: {}kHz".format(freq))
 
     for point in self.data_points:
       point.real_send_time_ms = (point.timestamp -
                                  self.data_points[0].timestamp) / freq
-      point.delay = point.arrival_timestamp_ms -point.real_send_time_ms
+      point.delay = point.arrival_timestamp_ms - point.real_send_time_ms
 
   def print_duration_statistics(self):
     """Prints delay, clock drift and bitrate statistics."""
 
     min_delay = min(point.delay for point in self.data_points)
 
     for point in self.data_points:
       point.absdelay = point.delay - min_delay
 
     stream_duration_sender = self.data_points[-1].real_send_time_ms / 1000
@@ skipping 30 matching lines @@
         last = point
     self.data_points = data_points_ordered
 
   def compute_bandwidth(self):
     """Computes bandwidth averaged over several consecutive packets.
 
     The number of consecutive packets used in the average is
     BANDWIDTH_SMOOTHING_WINDOW_SIZE. Averaging is done with
     numpy.correlate.
     """
-    self.bandwidth_kbps = []
-    for i in range(len(self.data_points) - 1):
-      self.bandwidth_kbps.append(self.data_points[i].size * 8 /
-                                 (self.data_points[i +
-                                                   1].real_send_time_ms -
-                                  self.data_points[i].real_send_time_ms)
-                                )
+    start_ms = self.data_points[0].real_send_time_ms
+    stop_ms = self.data_points[-1].real_send_time_ms
+    (self.bandwidth_kbps, _) = numpy.histogram(
+        [point.real_send_time_ms for point in self.data_points],
+        bins=numpy.arange(start_ms, stop_ms,
+                          RTPStatistics.PLOT_RESOLUTION_MS),
+        weights=[point.size * 8 / RTPStatistics.PLOT_RESOLUTION_MS
+                 for point in self.data_points]
+    )
     correlate_filter = (numpy.ones(
         RTPStatistics.BANDWIDTH_SMOOTHING_WINDOW_SIZE) /
                         RTPStatistics.BANDWIDTH_SMOOTHING_WINDOW_SIZE)
     self.smooth_bw_kbps = numpy.correlate(self.bandwidth_kbps, correlate_filter)
 
   def plot_statistics(self):
     """Plots changes in delay and average bandwidth."""
+
+    start_ms = self.data_points[0].real_send_time_ms
+    stop_ms = self.data_points[-1].real_send_time_ms
+    time_axis = numpy.arange(start_ms / 1000, stop_ms / 1000,
+                             RTPStatistics.PLOT_RESOLUTION_MS / 1000)
+
+    delay = calculate_delay(start_ms, stop_ms,
+                                 RTPStatistics.PLOT_RESOLUTION_MS,

[phoglund, 2016/07/28 06:28:55]

Nit: indent

[aleloi, 2016/07/28 08:41:46]

Done.

+                                 self.data_points)
+
     plt.figure(1)
-    plt.plot([f.real_send_time_ms / 1000 for f in self.data_points],
-             [f.absdelay for f in self.data_points])
+    plt.plot(time_axis, delay)
     plt.xlabel("Send time [s]")
     plt.ylabel("Relative transport delay [ms]")
 
     plt.figure(2)
-    plt.plot([f.real_send_time_ms / 1000 for f in
-              self.data_points][:len(self.smooth_bw_kbps)],
-             self.smooth_bw_kbps[:len(self.data_points)])
+    plt.plot(time_axis[:len(self.smooth_bw_kbps)], self.smooth_bw_kbps)
     plt.xlabel("Send time [s]")
     plt.ylabel("Bandwidth [kbps]")
 
     plt.show()
 
 
+def calculate_delay(start, stop, step, points):
+  """Regularizes the time coordinates for the delay.
+
+  Regularizes points by rounding the timestamps to the nearest point

[phoglund, 2016/07/28 06:28:55]

Isn't this "quantizing"?

[stefan-webrtc, 2016/07/28 07:13:36]

Perhaps you can use numpy's digitize instead?
http://docs.scipy.org/doc/numpy/reference/generated/numpy.digitize.html

[aleloi, 2016/07/28 08:41:46]

I'd rather not use that, I think. Based on the description, it would do a search
in the whole time series for every point and increase complexity.

[aleloi, 2016/07/28 08:41:46]

Wikipedia confirms that "quantizing" is the correct term :)

+  in the time sequence start, start+step, start+2*step... Takes the
+  average of the delays of points rounded to the same. Returns
+  masked array, in which time points with no value are masked.
+  """
+  grouped_delays = [[] for _ in numpy.arange(start, stop, step)]
+  rounded_value_index = lambda x: int((x - start) / step)
+  for point in points:
+    grouped_delays[rounded_value_index(point.real_send_time_ms)
+                  ].append(point.absdelay)
+  regularized_delays = [numpy.average(arr) if arr else None for arr in
+                        grouped_delays]
+  return numpy.ma.masked_values(regularized_delays, None)
+
+
 def main():
   usage = "Usage: %prog [options] <filename of rtc event log>"
   parser = optparse.OptionParser(usage=usage)
   parser.add_option("--dump_header_to_stdout",
                     default=False, action="store_true",
                     help="print header info to stdout; similar to rtp_analyze")
   parser.add_option("--query_sample_rate",
                     default=False, action="store_true",
                     help="always query user for real sample rate")
 
@@ skipping 19 matching lines @@
   print("Statistics:")
   rtp_stats.print_sequence_number_statistics()
   rtp_stats.estimate_frequency(options.query_sample_rate)
   rtp_stats.print_duration_statistics()
   rtp_stats.remove_reordered()
   rtp_stats.compute_bandwidth()
   rtp_stats.plot_statistics()
 
 if __name__ == "__main__":
   main()