def testGetFrozenFramesReports(self):
frame_distribution = {1: 2, 2: 2, 3: 569, 6: 1}
expected_frozen_reports = [{'frozen_frames': 5, 'occurrences': 1}]
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
self.assertEqual(
expected_frozen_reports,
stats_parser._GetFrozenFramesReports(frame_distribution))
def testGetDrifTimeStats(self):
fake_events = self._GetFakeEvents()
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
cadence = stats_parser._GetCadence(fake_events)
expected_drift_time = [15585, 30917, 29583, 23915, 17913, 16911, 15909]
expected_rendering_length_error = 29.613733905579398
self.assertEqual((expected_drift_time, expected_rendering_length_error),
stats_parser._GetDrifTimeStats(fake_events, cadence))
def testGetCadence(self): fake_events = self._GetFakeEvents() stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(fake_events) # The events defined in _GetFakeEvents above show that the first source # framee of ideal_instant=1663780179998 is rendered twice, then # the second source frame of ideal_instant=1663780197998 is rendered once # the third source frame of ideal_instant=1663780215998 is rendered twice # and so on. The expected cadence will therefore be [2 1 2 etc..] expected_cadence = [2, 1, 2, 3, 3, 3, 1] self.assertEqual(expected_cadence, stats_parser._GetCadence(fake_events))
def testCorruptData(self): corrupt_events = self._GetCorruptEvents() stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(corrupt_events) stats = stats_parser.GetTimeStats() self.assertTrue(stats.invalid_data) self.assertIsNone(stats.drift_time) self.assertIsNone(stats.percent_badly_out_of_sync) self.assertIsNone(stats.percent_out_of_sync) self.assertIsNone(stats.smoothness_score) self.assertIsNone(stats.freezing_score) self.assertIsNone(stats.rendering_length_error) self.assertIsNone(stats.fps) self.assertIsNone(stats.frame_distribution)
def testNegativeSmoothnessScoreChangedToZero(self):
norm_drift_time = [15948.285714285714, 9383.714285714286,
28049.714285714286, 72381.71428571429, 3620.2857142857138,
4622.285714285714, 35624.28571428572]
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
expected_percent_badly_oos = 28.571428571428573
expected_percent_out_of_sync = 42.857142857142854
expected_smoothness_score = 0.0
expected_smoothness_stats = (expected_percent_badly_oos,
expected_percent_out_of_sync, expected_smoothness_score)
self.assertEqual(expected_smoothness_stats,
stats_parser._GetSmoothnessStats(norm_drift_time))
def testGetSmoothnessStats(self):
norm_drift_time = [5948.2857142857138, 9383.7142857142862,
8049.7142857142862, 2381.7142857142862, 3620.2857142857138,
4622.2857142857138, 5624.2857142857138]
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
expected_percent_badly_oos = 0.0
expected_percent_out_of_sync = 0.0
expected_smoothness_score = 100.0
expected_smoothness_stats = (expected_percent_badly_oos,
expected_percent_out_of_sync, expected_smoothness_score)
self.assertEqual(expected_smoothness_stats,
stats_parser._GetSmoothnessStats(norm_drift_time))
def testInvalidEvents(self):
event_missing_serial = FakeEvent(actual_begin=1655987244074,
actual_end=1655987260740, ideal_instant=1655987204839)
event_missing_actual_begin = FakeEvent(actual_end=1655987260740,
ideal_instant=1655987217999, serial=self.local_stream)
event_missing_actual_end = FakeEvent(actual_end=1655987260740,
ideal_instant=1655987217999, serial=self.remote_stream)
event_missing_ideal_instant = FakeEvent(actual_begin=1655987260740,
actual_end=1655987277406, serial=self.remote_stream)
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(
[event_missing_serial, event_missing_actual_begin,
event_missing_actual_end, event_missing_ideal_instant])
self.assertEqual(0, len(stats_parser.stream_to_events))
def testInitialization(self):
event_local_stream = FakeEvent(actual_begin=1655987203306,
actual_end=1655987219972, ideal_instant=1655987154324,
serial=self.local_stream)
event_remote_stream = FakeEvent(actual_begin=1655987203306,
actual_end=1655987219972, ideal_instant=1655987167999,
serial=self.remote_stream)
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(
[event_local_stream, event_remote_stream])
self.assertEqual(2, len(stats_parser.stream_to_events))
self.assertEqual(event_local_stream.args,
stats_parser.stream_to_events[self.local_stream][0].args)
self.assertEqual(event_remote_stream.args,
stats_parser.stream_to_events[self.remote_stream][0].args)
def AddResults(self, model, renderer_thread, interactions, results):
"""Adding metrics to the results."""
assert interactions
found_events = []
for event in renderer_thread.parent.IterAllEvents(
event_predicate=self.IsMediaPlayerMSEvent):
if timeline_based_metric.IsEventInInteractions(
event, interactions):
found_events.append(event)
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats(
found_events)
rendering_stats = stats_parser.GetTimeStats()
none_reason = None
if not rendering_stats:
# Create a TimeStats object whose members have None values.
rendering_stats = stats_helper.TimeStats()
none_reason = 'No WebMediaPlayerMS::UpdateCurrentFrame event found'
elif rendering_stats.invalid_data:
# Throw away the data.
rendering_stats = stats_helper.TimeStats()
none_reason = 'WebMediaPlayerMS data is corrupted.'
results.AddValue(
list_of_scalar_values.ListOfScalarValues(
results.current_page,
'WebRTCRendering_drift_time',
'us',
rendering_stats.drift_time,
important=True,
description='Drift time for a rendered frame',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.DOWN,
none_value_reason=none_reason))
results.AddValue(
scalar.ScalarValue(
results.current_page,
'WebRTCRendering_percent_badly_out_of_sync',
'%',
rendering_stats.percent_badly_out_of_sync,
important=True,
description=
'Percentage of frame which drifted more than 2 VSYNC',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.DOWN,
none_value_reason=none_reason))
results.AddValue(
scalar.ScalarValue(
results.current_page,
'WebRTCRendering_percent_out_of_sync',
'%',
rendering_stats.percent_out_of_sync,
important=True,
description=
'Percentage of frame which drifted more than 1 VSYNC',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.DOWN,
none_value_reason=none_reason))
# I removed the frame distribution list from stats as it is not a metric,
# rather it is the underlying data. Also there is no sense of improvement
# direction for frame distribution.
results.AddValue(
scalar.ScalarValue(
results.current_page,
'WebRTCRendering_fps',
'fps',
rendering_stats.fps,
important=True,
description='Calculated Frame Rate of video rendering',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.UP,
none_value_reason=none_reason))
results.AddValue(
scalar.ScalarValue(results.current_page,
'WebRTCRendering_smoothness_score',
'%',
rendering_stats.smoothness_score,
important=True,
description='Smoothness score of rendering',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.UP,
none_value_reason=none_reason))
results.AddValue(
scalar.ScalarValue(results.current_page,
'WebRTCRendering_freezing_score',
'%',
rendering_stats.freezing_score,
important=True,
description='Freezing score of rendering',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.UP,
none_value_reason=none_reason))
results.AddValue(
scalar.ScalarValue(
results.current_page,
'WebRTCRendering_rendering_length_error',
'%',
rendering_stats.rendering_length_error,
important=True,
description='Rendering length error rate',
tir_label=interactions[0].label,
improvement_direction=improvement_direction.DOWN,
none_value_reason=none_reason))
def testNegativeFrezingScoreChangedToZero(self):
frame_distribution = {1: 2, 2: 2, 3: 2, 8: 100}
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
self.assertEqual(0.0,
stats_parser._GetFreezingScore(frame_distribution))
def testGetFreezingScore(self):
frame_distribution = {1: 2, 2: 2, 3: 569, 6: 1}
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
expected_freezing_score = 99.94182664339732
self.assertEqual(expected_freezing_score,
stats_parser._GetFreezingScore(frame_distribution))
def testIsRemoteStream(self):
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
self.assertTrue(stats_parser._IsRemoteStream(self.remote_stream))
def testGetFpsFromCadence(self):
frame_distribution = {1: 2, 2: 2, 3: 3}
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
expected_frame_rate = 28.0
self.assertEqual(expected_frame_rate,
stats_parser._GetFpsFromCadence(frame_distribution))
def testGetSourceToOutputDistribution(self):
stats_parser = stats_helper.WebMediaPlayerMsRenderingStats([])
cadence = [2, 1, 2, 3, 3, 3, 1]
expected_frame_distribution = {1: 2, 2: 2, 3: 3}
self.assertEqual(expected_frame_distribution,
stats_parser._GetSourceToOutputDistribution(cadence))
