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))