Remove unsupported python event log analyzer
The tool doesn't support current event log format. Use rtc_tools/rtc_event_log_visualizer or rtc_tools/rtc_event_log_to_text instead. Bug: None Change-Id: Ieca3ba581a102f7a28a5480b45c53bad2622d606 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/456180 Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Björn Terelius <terelius@webrtc.org> Reviewed-by: Jeremy Leconte <jleconte@google.com> Cr-Commit-Position: refs/heads/main@{#47134}
This commit is contained in:
Björn Terelius
WebRTC LUCI CQ
parent
447a59dcd8
commit
63cadb1c4f
@ -832,10 +832,7 @@ def RunPythonTests(input_api, output_api):
|
||||
'process_perf_results_test.py',
|
||||
]
|
||||
|
||||
test_directories = [
|
||||
input_api.PresubmitLocalPath(),
|
||||
Join('rtc_tools', 'py_event_log_analyzer'),
|
||||
] + [
|
||||
test_directories = [input_api.PresubmitLocalPath()] + [
|
||||
root for root, _, files in os.walk(Join('tools_webrtc')) if any(
|
||||
f.endswith('_test.py') and f not in excluded_files for f in files)
|
||||
]
|
||||
|
||||
@ -29,10 +29,7 @@ group("rtc_tools") {
|
||||
deps += [ ":tools_unittests" ]
|
||||
}
|
||||
if (rtc_include_tests && rtc_enable_protobuf) {
|
||||
deps += [
|
||||
":rtp_analyzer",
|
||||
"network_tester",
|
||||
]
|
||||
deps += [ "network_tester" ]
|
||||
}
|
||||
if (rtc_include_tests && rtc_enable_protobuf && !build_with_chromium) {
|
||||
deps += [
|
||||
@ -623,17 +620,4 @@ if (rtc_include_tests) {
|
||||
} # unpack_aecdump
|
||||
}
|
||||
}
|
||||
|
||||
if (rtc_enable_protobuf) {
|
||||
copy("rtp_analyzer") {
|
||||
sources = [
|
||||
"py_event_log_analyzer/misc.py",
|
||||
"py_event_log_analyzer/pb_parse.py",
|
||||
"py_event_log_analyzer/rtp_analyzer.py",
|
||||
"py_event_log_analyzer/rtp_analyzer.sh",
|
||||
]
|
||||
outputs = [ "$root_build_dir/{{source_file_part}}" ]
|
||||
deps = [ "../logging:rtc_event_log_proto" ]
|
||||
} # rtp_analyzer
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
# RTP log analyzer
|
||||
This file describes how to set up and use the RTP log analyzer.
|
||||
|
||||
## Build
|
||||
|
||||
```shell
|
||||
$ autoninja -C out/my_build webrtc:rtp_analyzer
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```shell
|
||||
./out/my_build/rtp_analyzer.sh [options] /path/to/rtc_event.log
|
||||
```
|
||||
|
||||
where `/path/to/rtc_event.log` is a recorded RTC event log, which is stored in
|
||||
protobuf format. Such logs are generated in multiple ways, e.g. by Chrome
|
||||
through the chrome://webrtc-internals page.
|
||||
|
||||
Use `--help` for the options.
|
||||
|
||||
The script requires Python (2.7 or 3+) and it has the following dependencies:
|
||||
Dependencies (available on pip):
|
||||
- matplotlib (http://matplotlib.org/)
|
||||
- numpy (http://www.numpy.org/)
|
||||
- protobuf (https://pypi.org/project/protobuf/)
|
||||
@ -1,85 +0,0 @@
|
||||
# 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.
|
||||
"""Utility functions for calculating statistics.
|
||||
"""
|
||||
|
||||
from __future__ import division
|
||||
import collections
|
||||
import sys
|
||||
|
||||
|
||||
def CountReordered(sequence_numbers):
|
||||
"""Returns number of reordered indices.
|
||||
|
||||
A reordered index is an index `i` for which sequence_numbers[i] >=
|
||||
sequence_numbers[i + 1]
|
||||
"""
|
||||
return sum(1 for (s1, s2) in zip(sequence_numbers, sequence_numbers[1:])
|
||||
if s1 >= s2)
|
||||
|
||||
|
||||
def SsrcNormalizedSizeTable(data_points):
|
||||
"""Counts proportion of data for every SSRC.
|
||||
|
||||
Args:
|
||||
data_points: list of pb_parse.DataPoint
|
||||
|
||||
Returns:
|
||||
A dictionary mapping from every SSRC in the data points. The
|
||||
value of an SSRC `s` is the proportion of sizes of packets with
|
||||
SSRC `s` to the total size of all packets.
|
||||
|
||||
"""
|
||||
mapping = collections.defaultdict(int)
|
||||
for point in data_points:
|
||||
mapping[point.ssrc] += point.size
|
||||
return NormalizeCounter(mapping)
|
||||
|
||||
|
||||
def NormalizeCounter(counter):
|
||||
"""Returns a normalized version of the dictionary `counter`.
|
||||
|
||||
Does not modify `counter`.
|
||||
|
||||
Returns:
|
||||
A new dictionary, in which every value in `counter`
|
||||
has been divided by the total to sum up to 1.
|
||||
"""
|
||||
total = sum(counter.values())
|
||||
return {key: counter[key] / total for key in counter}
|
||||
|
||||
|
||||
def Unwrap(data, mod):
|
||||
"""Returns `data` unwrapped modulo `mod`. Does not modify data.
|
||||
|
||||
Adds integer multiples of mod to all elements of data except the
|
||||
first, such that all pairs of consecutive elements (a, b) satisfy
|
||||
-mod / 2 <= b - a < mod / 2.
|
||||
|
||||
E.g. Unwrap([0, 1, 2, 0, 1, 2, 7, 8], 3) -> [0, 1, 2, 3,
|
||||
4, 5, 4, 5]
|
||||
"""
|
||||
lst = data[:]
|
||||
for i in range(1, len(data)):
|
||||
lst[i] = lst[i - 1] + (lst[i] - lst[i - 1] + mod // 2) % mod - (mod //
|
||||
2)
|
||||
return lst
|
||||
|
||||
|
||||
def SsrcDirections(data_points):
|
||||
ssrc_is_incoming = {}
|
||||
for point in data_points:
|
||||
ssrc_is_incoming[point.ssrc] = point.incoming
|
||||
return ssrc_is_incoming
|
||||
|
||||
|
||||
# Python 2/3-compatible input function
|
||||
if sys.version_info[0] <= 2:
|
||||
get_input = raw_input # pylint: disable=invalid-name
|
||||
else:
|
||||
get_input = input # pylint: disable=invalid-name
|
||||
@ -1,74 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# 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.
|
||||
"""Run the tests with
|
||||
|
||||
python misc_test.py
|
||||
or
|
||||
python3 misc_test.py
|
||||
"""
|
||||
|
||||
from __future__ import division
|
||||
from __future__ import absolute_import
|
||||
import random
|
||||
import unittest
|
||||
from six.moves import range
|
||||
from six.moves import zip
|
||||
|
||||
import misc
|
||||
|
||||
class TestMisc(unittest.TestCase):
|
||||
def testUnwrapMod3(self):
|
||||
data = [0, 1, 2, 0, -1, -2, -3, -4]
|
||||
unwrapped_3 = misc.Unwrap(data, 3)
|
||||
self.assertEqual([0, 1, 2, 3, 2, 1, 0, -1], unwrapped_3)
|
||||
|
||||
def testUnwrapMod4(self):
|
||||
data = [0, 1, 2, 0, -1, -2, -3, -4]
|
||||
unwrapped_4 = misc.Unwrap(data, 4)
|
||||
self.assertEqual([0, 1, 2, 0, -1, -2, -3, -4], unwrapped_4)
|
||||
|
||||
def testDataShouldNotChangeAfterUnwrap(self):
|
||||
data = [0, 1, 2, 0, -1, -2, -3, -4]
|
||||
_ = misc.Unwrap(data, 4)
|
||||
|
||||
self.assertEqual([0, 1, 2, 0, -1, -2, -3, -4], data)
|
||||
|
||||
def testRandomlyMultiplesOfModAdded(self):
|
||||
# `unwrap` definition says only multiples of mod are added.
|
||||
random_data = [random.randint(0, 9) for _ in range(100)]
|
||||
|
||||
for mod in range(1, 100):
|
||||
random_data_unwrapped_mod = misc.Unwrap(random_data, mod)
|
||||
|
||||
for (old_a, a) in zip(random_data, random_data_unwrapped_mod):
|
||||
self.assertEqual((old_a - a) % mod, 0)
|
||||
|
||||
def testRandomlyAgainstInequalityDefinition(self):
|
||||
# Data has to satisfy -mod/2 <= difference < mod/2 for every
|
||||
# difference between consecutive values after unwrap.
|
||||
random_data = [random.randint(0, 9) for _ in range(100)]
|
||||
|
||||
for mod in range(1, 100):
|
||||
random_data_unwrapped_mod = misc.Unwrap(random_data, mod)
|
||||
|
||||
for (a, b) in zip(random_data_unwrapped_mod,
|
||||
random_data_unwrapped_mod[1:]):
|
||||
self.assertTrue(-mod / 2 <= b - a < mod / 2)
|
||||
|
||||
def testRandomlyDataShouldNotChangeAfterUnwrap(self):
|
||||
random_data = [random.randint(0, 9) for _ in range(100)]
|
||||
random_data_copy = random_data[:]
|
||||
for mod in range(1, 100):
|
||||
_ = misc.Unwrap(random_data, mod)
|
||||
|
||||
self.assertEqual(random_data, random_data_copy)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@ -1,51 +0,0 @@
|
||||
# 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.
|
||||
"""Parses protobuf RTC dumps."""
|
||||
|
||||
from __future__ import division
|
||||
import struct
|
||||
import pyproto.logging.rtc_event_log.rtc_event_log_pb2 as rtc_pb
|
||||
|
||||
|
||||
class DataPoint(object):
|
||||
"""Simple container class for RTP events."""
|
||||
|
||||
def __init__(self, rtp_header_str, packet_size, arrival_timestamp_us,
|
||||
incoming):
|
||||
"""Builds a data point by parsing an RTP header, size and arrival time.
|
||||
|
||||
RTP header structure is defined in RFC 3550 section 5.1.
|
||||
"""
|
||||
self.size = packet_size
|
||||
self.arrival_timestamp_ms = arrival_timestamp_us / 1000
|
||||
self.incoming = incoming
|
||||
header = struct.unpack_from("!HHII", rtp_header_str, 0)
|
||||
(first2header_bytes, self.sequence_number, self.timestamp,
|
||||
self.ssrc) = header
|
||||
self.payload_type = first2header_bytes & 0b01111111
|
||||
self.marker_bit = (first2header_bytes & 0b10000000) >> 7
|
||||
|
||||
|
||||
def ParseProtobuf(file_path):
|
||||
"""Parses RTC event log from protobuf file.
|
||||
|
||||
Args:
|
||||
file_path: path to protobuf file of RTC event stream
|
||||
|
||||
Returns:
|
||||
all RTP packet events from the event stream as a list of DataPoints
|
||||
"""
|
||||
event_stream = rtc_pb.EventStream()
|
||||
with open(file_path, "rb") as f:
|
||||
event_stream.ParseFromString(f.read())
|
||||
|
||||
return [
|
||||
DataPoint(event.rtp_packet.header, event.rtp_packet.packet_length,
|
||||
event.timestamp_us, event.rtp_packet.incoming)
|
||||
for event in event_stream.stream if event.HasField("rtp_packet")
|
||||
]
|
||||
@ -1,340 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# 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
|
||||
|
||||
from __future__ import absolute_import
|
||||
import collections
|
||||
import optparse
|
||||
import os
|
||||
import sys
|
||||
from six.moves import range
|
||||
from six.moves import zip
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy
|
||||
|
||||
import misc
|
||||
import pb_parse
|
||||
|
||||
|
||||
class RTPStatistics:
|
||||
"""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.
|
||||
|
||||
"""
|
||||
|
||||
self.data_points = data_points
|
||||
self.ssrc_frequencies = misc.NormalizeCounter(
|
||||
collections.Counter([pt.ssrc for pt in self.data_points]))
|
||||
self.ssrc_size_table = misc.SsrcNormalizedSizeTable(self.data_points)
|
||||
self.bandwidth_kbps = None
|
||||
self.smooth_bw_kbps = None
|
||||
|
||||
def PrintHeaderStatistics(self):
|
||||
print("{:>6}{:>14}{:>14}{:>6}{:>6}{:>3}{:>11}".format(
|
||||
"SeqNo", "TimeStamp", "SendTime", "Size", "PT", "M", "SSRC"))
|
||||
for point in self.data_points:
|
||||
print("{:>6}{:>14}{:>14}{:>6}{:>6}{:>3}{:>11}".format(
|
||||
point.sequence_number, point.timestamp,
|
||||
int(point.arrival_timestamp_ms), point.size, point.payload_type,
|
||||
point.marker_bit, "0x{:x}".format(point.ssrc)))
|
||||
|
||||
def PrintSsrcInfo(self, ssrc_id, ssrc):
|
||||
"""Prints packet and size statistics for a given SSRC.
|
||||
|
||||
Args:
|
||||
ssrc_id: textual identifier of SSRC printed beside statistics for it.
|
||||
ssrc: SSRC by which to filter data and display statistics
|
||||
"""
|
||||
filtered_ssrc = [point for point in self.data_points if point.ssrc == ssrc]
|
||||
payloads = misc.NormalizeCounter(
|
||||
collections.Counter([point.payload_type for point in filtered_ssrc]))
|
||||
|
||||
payload_info = "payload type(s): {}".format(", ".join(
|
||||
str(payload) for payload in payloads))
|
||||
print("{} 0x{:x} {}, {:.2f}% packets, {:.2f}% data".format(
|
||||
ssrc_id, ssrc, payload_info, self.ssrc_frequencies[ssrc] * 100,
|
||||
self.ssrc_size_table[ssrc] * 100))
|
||||
print(" packet sizes:")
|
||||
(bin_counts,
|
||||
bin_bounds) = numpy.histogram([point.size for point in filtered_ssrc],
|
||||
bins=5,
|
||||
density=False)
|
||||
bin_proportions = bin_counts / sum(bin_counts)
|
||||
print("\n".join([
|
||||
" {:.1f} - {:.1f}: {:.2f}%".format(bin_bounds[i], bin_bounds[i + 1],
|
||||
bin_proportions[i] * 100)
|
||||
for i in range(len(bin_proportions))
|
||||
]))
|
||||
|
||||
def ChooseSsrc(self):
|
||||
"""Queries user for SSRC."""
|
||||
|
||||
if len(self.ssrc_frequencies) == 1:
|
||||
chosen_ssrc = list(self.ssrc_frequencies.keys())[0]
|
||||
self.PrintSsrcInfo("", chosen_ssrc)
|
||||
return chosen_ssrc
|
||||
|
||||
ssrc_is_incoming = misc.SsrcDirections(self.data_points)
|
||||
incoming = [ssrc for ssrc in ssrc_is_incoming if ssrc_is_incoming[ssrc]]
|
||||
outgoing = [ssrc for ssrc in ssrc_is_incoming if not ssrc_is_incoming[ssrc]]
|
||||
|
||||
print("\nIncoming:\n")
|
||||
for (i, ssrc) in enumerate(incoming):
|
||||
self.PrintSsrcInfo(i, ssrc)
|
||||
|
||||
print("\nOutgoing:\n")
|
||||
for (i, ssrc) in enumerate(outgoing):
|
||||
self.PrintSsrcInfo(i + len(incoming), ssrc)
|
||||
|
||||
while True:
|
||||
chosen_index = int(misc.get_input("choose one> "))
|
||||
if 0 <= chosen_index < len(self.ssrc_frequencies):
|
||||
return (incoming + outgoing)[chosen_index]
|
||||
print("Invalid index!")
|
||||
|
||||
def FilterSsrc(self, chosen_ssrc):
|
||||
"""Filters and wraps data points.
|
||||
|
||||
Removes data points with `ssrc != chosen_ssrc`. Unwraps sequence
|
||||
numbers and timestamps for the chosen selection.
|
||||
"""
|
||||
self.data_points = [
|
||||
point for point in self.data_points if point.ssrc == chosen_ssrc
|
||||
]
|
||||
unwrapped_sequence_numbers = misc.Unwrap(
|
||||
[point.sequence_number for point in self.data_points], 2**16 - 1)
|
||||
for (data_point, sequence_number) in zip(self.data_points,
|
||||
unwrapped_sequence_numbers):
|
||||
data_point.sequence_number = sequence_number
|
||||
|
||||
unwrapped_timestamps = misc.Unwrap(
|
||||
[point.timestamp for point in self.data_points], 2**32 - 1)
|
||||
|
||||
for (data_point, timestamp) in zip(self.data_points, unwrapped_timestamps):
|
||||
data_point.timestamp = timestamp
|
||||
|
||||
def PrintSequenceNumberStatistics(self):
|
||||
seq_no_set = set(point.sequence_number for point in self.data_points)
|
||||
missing_sequence_numbers = max(seq_no_set) - min(seq_no_set) + (
|
||||
1 - len(seq_no_set))
|
||||
print("Missing sequence numbers: {} out of {} ({:.2f}%)".format(
|
||||
missing_sequence_numbers, len(seq_no_set),
|
||||
100 * missing_sequence_numbers / len(seq_no_set)))
|
||||
print("Duplicated packets: {}".format(
|
||||
len(self.data_points) - len(seq_no_set)))
|
||||
print("Reordered packets: {}".format(
|
||||
misc.CountReordered(
|
||||
[point.sequence_number for point in self.data_points])))
|
||||
|
||||
def EstimateFrequency(self, always_query_sample_rate):
|
||||
"""Estimates frequency and updates data.
|
||||
|
||||
Guesses the most probable frequency by looking at changes in
|
||||
timestamps (RFC 3550 section 5.1), calculates clock drifts and
|
||||
sending time of packets. Updates `self.data_points` with changes
|
||||
in delay and send time.
|
||||
"""
|
||||
delta_timestamp = (self.data_points[-1].timestamp -
|
||||
self.data_points[0].timestamp)
|
||||
delta_arr_timestamp = float((self.data_points[-1].arrival_timestamp_ms -
|
||||
self.data_points[0].arrival_timestamp_ms))
|
||||
freq_est = delta_timestamp / delta_arr_timestamp
|
||||
|
||||
freq_vec = [8, 16, 32, 48, 90]
|
||||
freq = None
|
||||
for f in freq_vec:
|
||||
if abs((freq_est - f) / f) < 0.05:
|
||||
freq = f
|
||||
|
||||
print("Estimated frequency: {:.3f}kHz".format(freq_est))
|
||||
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
|
||||
|
||||
def PrintDurationStatistics(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
|
||||
print("Stream duration at sender: {:.1f} seconds".format(
|
||||
stream_duration_sender))
|
||||
|
||||
arrival_timestamps_ms = [
|
||||
point.arrival_timestamp_ms for point in self.data_points
|
||||
]
|
||||
stream_duration_receiver = (max(arrival_timestamps_ms) -
|
||||
min(arrival_timestamps_ms)) / 1000
|
||||
print("Stream duration at receiver: {:.1f} seconds".format(
|
||||
stream_duration_receiver))
|
||||
|
||||
print("Clock drift: {:.2f}%".format(
|
||||
100 * (stream_duration_receiver / stream_duration_sender - 1)))
|
||||
|
||||
total_size = sum(point.size for point in self.data_points) * 8 / 1000
|
||||
print("Send average bitrate: {:.2f} kbps".format(total_size /
|
||||
stream_duration_sender))
|
||||
|
||||
print("Receive average bitrate: {:.2f} kbps".format(
|
||||
total_size / stream_duration_receiver))
|
||||
|
||||
def RemoveReordered(self):
|
||||
last = self.data_points[0]
|
||||
data_points_ordered = [last]
|
||||
for point in self.data_points[1:]:
|
||||
if point.sequence_number > last.sequence_number and (
|
||||
point.real_send_time_ms > last.real_send_time_ms):
|
||||
data_points_ordered.append(point)
|
||||
last = point
|
||||
self.data_points = data_points_ordered
|
||||
|
||||
def ComputeBandwidth(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.
|
||||
"""
|
||||
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 PlotStatistics(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 = CalculateDelay(start_ms, stop_ms, RTPStatistics.PLOT_RESOLUTION_MS,
|
||||
self.data_points)
|
||||
|
||||
plt.figure(1)
|
||||
plt.plot(time_axis, delay[:len(time_axis)])
|
||||
plt.xlabel("Send time [s]")
|
||||
plt.ylabel("Relative transport delay [ms]")
|
||||
|
||||
plt.figure(2)
|
||||
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 CalculateDelay(start, stop, step, points):
|
||||
"""Quantizes the time coordinates for the delay.
|
||||
|
||||
Quantizes points by rounding the timestamps downwards to the nearest
|
||||
point 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, 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 -1 for arr in grouped_delays
|
||||
]
|
||||
return numpy.ma.masked_values(regularized_delays, -1)
|
||||
|
||||
|
||||
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")
|
||||
|
||||
parser.add_option("--working_directory",
|
||||
default=None,
|
||||
action="store",
|
||||
help="directory in which to search for relative paths")
|
||||
|
||||
(options, args) = parser.parse_args()
|
||||
|
||||
if len(args) < 1:
|
||||
parser.print_help()
|
||||
sys.exit(0)
|
||||
|
||||
input_file = args[0]
|
||||
|
||||
if options.working_directory and not os.path.isabs(input_file):
|
||||
input_file = os.path.join(options.working_directory, input_file)
|
||||
|
||||
data_points = pb_parse.ParseProtobuf(input_file)
|
||||
rtp_stats = RTPStatistics(data_points)
|
||||
|
||||
if options.dump_header_to_stdout:
|
||||
print("Printing header info to stdout.", file=sys.stderr)
|
||||
rtp_stats.PrintHeaderStatistics()
|
||||
sys.exit(0)
|
||||
|
||||
chosen_ssrc = rtp_stats.ChooseSsrc()
|
||||
print("Chosen SSRC: 0X{:X}".format(chosen_ssrc))
|
||||
|
||||
rtp_stats.FilterSsrc(chosen_ssrc)
|
||||
|
||||
print("Statistics:")
|
||||
rtp_stats.PrintSequenceNumberStatistics()
|
||||
rtp_stats.EstimateFrequency(options.query_sample_rate)
|
||||
rtp_stats.PrintDurationStatistics()
|
||||
rtp_stats.RemoveReordered()
|
||||
rtp_stats.ComputeBandwidth()
|
||||
rtp_stats.PlotStatistics()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,10 +0,0 @@
|
||||
#!/bin/bash
|
||||
# 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.
|
||||
BASE_DIR=`dirname $0`
|
||||
python "${BASE_DIR}/rtp_analyzer.py" $@ --working_dir $BASE_DIR
|
||||
@ -1,62 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# 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.
|
||||
"""Run the tests with
|
||||
|
||||
python rtp_analyzer_test.py
|
||||
or
|
||||
python3 rtp_analyzer_test.py
|
||||
"""
|
||||
|
||||
from __future__ import absolute_import
|
||||
from __future__ import print_function
|
||||
import collections
|
||||
import unittest
|
||||
|
||||
MISSING_NUMPY = False # pylint: disable=invalid-name
|
||||
try:
|
||||
import numpy
|
||||
import rtp_analyzer
|
||||
except ImportError:
|
||||
MISSING_NUMPY = True
|
||||
|
||||
FakePoint = collections.namedtuple("FakePoint",
|
||||
["real_send_time_ms", "absdelay"])
|
||||
|
||||
|
||||
class TestDelay(unittest.TestCase):
|
||||
def AssertMaskEqual(self, masked_array, data, mask):
|
||||
self.assertEqual(list(masked_array.data), data)
|
||||
|
||||
if isinstance(masked_array.mask, numpy.bool_):
|
||||
array_mask = masked_array.mask
|
||||
else:
|
||||
array_mask = list(masked_array.mask)
|
||||
self.assertEqual(array_mask, mask)
|
||||
|
||||
def testCalculateDelaySimple(self):
|
||||
points = [FakePoint(0, 0), FakePoint(1, 0)]
|
||||
mask = rtp_analyzer.CalculateDelay(0, 1, 1, points)
|
||||
self.AssertMaskEqual(mask, [0, 0], False)
|
||||
|
||||
def testCalculateDelayMissing(self):
|
||||
points = [FakePoint(0, 0), FakePoint(2, 0)]
|
||||
mask = rtp_analyzer.CalculateDelay(0, 2, 1, points)
|
||||
self.AssertMaskEqual(mask, [0, -1, 0], [False, True, False])
|
||||
|
||||
def testCalculateDelayBorders(self):
|
||||
points = [FakePoint(0, 0), FakePoint(2, 0)]
|
||||
mask = rtp_analyzer.CalculateDelay(0, 3, 2, points)
|
||||
self.AssertMaskEqual(mask, [0, 0, -1], [False, False, True])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if MISSING_NUMPY:
|
||||
print("Missing numpy, skipping test.")
|
||||
else:
|
||||
unittest.main()
|
||||
Loading…
Reference in New Issue
Block a user