299 lines
10 KiB
Python
299 lines
10 KiB
Python
"""
|
|
Responsabilities
|
|
|
|
Defines the events that modify media_player state
|
|
Defines which events are potential defects
|
|
Gives the low level support to extract info from the recorded data
|
|
For new code here, keep accepting and returning only data structures,
|
|
never paths or files.
|
|
"""
|
|
|
|
# events definition
|
|
mp_events = {
|
|
"version": 1.1,
|
|
|
|
# <evname>: {
|
|
# "desc": <description used in reports to mention the event>,
|
|
# "update_names": <list of names of fields updated>,
|
|
# "other_fields": <list of additionals fields to show when mention the event in a report>
|
|
# },
|
|
|
|
"crash": {
|
|
"desc": "media_player crashed.",
|
|
"update_names": ["evname", "sample"],
|
|
"other_fields": [],
|
|
"test_cases": [("crash", "small.mp4")]
|
|
},
|
|
|
|
"mp.im": {
|
|
"desc": "Play",
|
|
"update_names": ["evname", "sample"],
|
|
"other_fields": [],
|
|
"test_cases": [("mp.im", 3, "small.mp4")]
|
|
},
|
|
|
|
"p.P._sp": {
|
|
"desc": "Start playing",
|
|
"update_names": ["evname", "wall_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P._sp", 1.23)]
|
|
},
|
|
|
|
"p.P.sk": {
|
|
"desc": "Seek",
|
|
"update_names": ["evname", "seek_to_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.sk", 1.23), ("p.P.sk", None)]
|
|
},
|
|
|
|
"p.P.ut.1.0": {
|
|
"desc": "Enter update_texture",
|
|
"update_names": ["evname", "pyglet_dt", "current_time",
|
|
"audio_time", "wall_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.ut.1.0", 0.02, 2.31, 2.28, 1.21),
|
|
("p.P.ut.1.0", 0.02, None, 2.28, 1.21),
|
|
("p.P.ut.1.0", None, 2.31, 2.28, 1.21)]
|
|
},
|
|
"p.P.ut.1.5": {
|
|
"desc": "Discard video frame too old,",
|
|
"update_names": ["evname", "video_time"],
|
|
"other_fields": ["current_time"],
|
|
"test_cases": [("p.P.ut.1.5", 1.21)]
|
|
},
|
|
"p.P.ut.1.6": {
|
|
"desc": "Current video frame,",
|
|
"update_names": ["evname", "video_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.ut.1.6", 1.21)]
|
|
},
|
|
"p.P.ut.1.7": {
|
|
"desc": "Early return doing nothing because video_time is None (likely EOV),",
|
|
"update_names": ["evname", "rescheduling_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.ut.1.7", 0.02)]
|
|
},
|
|
"p.P.ut.1.8": {
|
|
"desc": "Image frame is None (?)",
|
|
"update_names": ["evname"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.ut.1.8",)]
|
|
},
|
|
# in log_render_anomalies list only if rescheduling_time < 0
|
|
"p.P.ut.1.9": {
|
|
"desc": "Re-scheduling,",
|
|
"update_names": ["evname", "rescheduling_time", "next_video_time"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.ut.1.9", 0.02, None), ("p.P.ut.1.9", 0.02, 2.7)]
|
|
},
|
|
|
|
# crash_detection relies in this being the last event in the log_entries
|
|
"p.P.oe": {
|
|
"desc": ">>> play ends",
|
|
"update_names": ["evname"],
|
|
"other_fields": [],
|
|
"test_cases": [("p.P.oe",)]
|
|
},
|
|
}
|
|
|
|
# events to examine for defects detection
|
|
mp_bads = {"crash", "p.P.ut.1.5", "p.P.ut.1.7", "p.P.ut.1.8"}
|
|
|
|
|
|
class MediaPlayerStateIterator:
|
|
"""Exposes for analysis the sequence of media_player states
|
|
|
|
Typical use
|
|
mp_states = MediaPlayerStateIterator()
|
|
for st in mp_states:
|
|
do something with st, the current media_player state.
|
|
|
|
If desired a callback can be called just before processing an event, the
|
|
signature is
|
|
fn_pre_event(event, state_before_event)
|
|
|
|
The mp state is handled as a dict, with keys in cls.fields
|
|
"""
|
|
fields = {
|
|
# real
|
|
"evname": None,
|
|
"evnum": -1, # synthetic, ordinal last event processed
|
|
"sample": None,
|
|
"wall_time": None,
|
|
"current_time": None,
|
|
"audio_time": None,
|
|
"seek_to_time": None,
|
|
"pyglet_dt": None,
|
|
"video_time": None,
|
|
"rescheduling_time": None,
|
|
"next_video_time": None,
|
|
# synthetics, probably invalid after using seek
|
|
"pyglet_time": 0,
|
|
"frame_num": 0,
|
|
}
|
|
|
|
def __init__(self, recorded_events, events_definition=mp_events, fn_pre_event=None):
|
|
self.fn_pre_event = fn_pre_event
|
|
self.state = dict(self.fields)
|
|
self.events_definition = events_definition
|
|
self.iter_events = iter(recorded_events)
|
|
version_args = next(self.iter_events)
|
|
assert version_args == ("version", self.events_definition["version"])
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
event = next(self.iter_events)
|
|
if self.fn_pre_event is not None:
|
|
self.fn_pre_event(event, self.state)
|
|
event_dict = self.event_as_dict(event)
|
|
self.update(event_dict)
|
|
return self.state
|
|
|
|
def event_as_dict(self, event):
|
|
names = self.events_definition[event[0]]["update_names"]
|
|
updated = {a: b for a, b in zip(names, event)}
|
|
return updated
|
|
|
|
def update(self, event_dict):
|
|
self.state.update(event_dict)
|
|
self.state["evnum"] += 1
|
|
evname = event_dict["evname"]
|
|
if evname == "p.P.ut.1.0":
|
|
self.state["pyglet_time"] += event_dict["pyglet_dt"]
|
|
elif evname == "p.P.ut.1.5" or evname == "p.P.ut.1.9":
|
|
self.state["frame_num"] += 1
|
|
|
|
|
|
class TimelineBuilder:
|
|
"""At each call to player.Player.update_texture we capture selected player
|
|
state, before accepting the changes in the event. This is the same as
|
|
capturing the state at the end of previous update call.
|
|
Output is a sequence of tuples capturing the desired fields.
|
|
Meant to extract info on behalf of other sw, especially visualization.
|
|
"""
|
|
def __init__(self, recorded_events, events_definition=mp_events):
|
|
mp = MediaPlayerStateIterator(recorded_events, events_definition, self.pre)
|
|
self.mp_state_iterator = mp
|
|
self.timeline = []
|
|
|
|
def pre(self, event, st):
|
|
if event[0] == "p.P.ut.1.0":
|
|
p = (st["wall_time"], st["pyglet_time"], st["audio_time"],
|
|
st["current_time"], st["frame_num"], st["rescheduling_time"])
|
|
self.timeline.append(p)
|
|
|
|
def get_timeline(self):
|
|
"""remember video_time and audio_time can be None"""
|
|
# real work is done in rhe callback pre
|
|
for st in self.mp_state_iterator:
|
|
pass
|
|
# The first entry is bogus, because there was no previous call so discard
|
|
return self.timeline[1:]
|
|
|
|
|
|
def timeline_postprocessing(timeline):
|
|
""" Eliminates Nones in timeline so other software don't error.
|
|
Extra lists are built for the vars with nones, each list with one point
|
|
for each None in the form (wall_time, prev_value).
|
|
"""
|
|
current_time_nones = []
|
|
audio_time_nones = []
|
|
old_current_time = 0
|
|
old_audio_time = 0
|
|
filtered_timeline = []
|
|
for wall_time, pt, audio_time, current_time, fnum, rt in timeline:
|
|
if current_time is None:
|
|
current_time = old_current_time
|
|
current_time_nones.append((wall_time, old_current_time))
|
|
else:
|
|
current_time_time = current_time
|
|
|
|
if audio_time is None:
|
|
audio_time = old_audio_time
|
|
audio_time_nones.append((wall_time, old_audio_time))
|
|
else:
|
|
old_audio_time = audio_time
|
|
|
|
filtered_timeline.append((wall_time, pt, audio_time, current_time, fnum, rt))
|
|
|
|
return filtered_timeline, current_time_nones, audio_time_nones
|
|
|
|
|
|
# works for buffered log, needs other implementation if unbuffered
|
|
def crash_detected(recorded_events):
|
|
crashed = recorded_events[-1][0] != "p.P.oe"
|
|
return crashed
|
|
|
|
|
|
class CountBads:
|
|
"""Helper to report anomalies in the media_player states seen when playing
|
|
a sample.
|
|
|
|
- provides .anomalies_description, a dict <anomaly>: <description>
|
|
- calling .count_bads(recorded_events) will return a dict of
|
|
anomaly: <count times anomaly detected>
|
|
- preprocessing: ad-hoc prefiltering the events stream for noise reduction
|
|
"""
|
|
def __init__(self, events_definition=mp_events, bads=mp_bads):
|
|
self.events_definition = events_definition
|
|
self.bads = bads
|
|
self.anomalies_description = self.build_anomalies_description()
|
|
|
|
def build_anomalies_description(self):
|
|
"""builds descriptions for the anomalies"""
|
|
d = self.events_definition
|
|
anomalies_description = {evname: d[evname]["desc"] for evname in self.bads}
|
|
anomalies_description["scheduling_in_past"] = "Scheduling in the past"
|
|
return anomalies_description
|
|
|
|
def preprocessing(self, recorded_events):
|
|
"""
|
|
I see all recordings ending with some potential anomalies in the few
|
|
frames just before the '>>> play ends'; visually the play is perfect so
|
|
I assume they are false positives if just at EOF. Deleting the offending
|
|
events (only if near EOL) to reduce noise in summarize.py
|
|
"""
|
|
recorded_events = list(recorded_events)
|
|
if (len(recorded_events) > 9 and
|
|
recorded_events[-2][0] == "p.P.ut.1.7" and
|
|
recorded_events[-6][0] == "p.P.ut.1.7" and
|
|
recorded_events[-10][0] == "p.P.ut.1.7"):
|
|
del recorded_events[-10]
|
|
del recorded_events[-6]
|
|
del recorded_events[-2]
|
|
|
|
elif (len(recorded_events) > 6 and
|
|
recorded_events[-2][0] == "p.P.ut.1.7" and
|
|
recorded_events[-6][0] == "p.P.ut.1.7"):
|
|
del recorded_events[-6]
|
|
del recorded_events[-2]
|
|
|
|
elif len(recorded_events) > 2 and recorded_events[-2][0] == "p.P.ut.1.7":
|
|
del recorded_events[-2]
|
|
|
|
return recorded_events
|
|
|
|
def count_bads(self, recorded_events):
|
|
"""returns counts of anomalies as a dict of anomaly: count
|
|
|
|
recorded_events: media_player events recorded while playing a sample
|
|
|
|
Notice that 'counters' has one more key than 'bads': "scheduling_in_past"
|
|
"""
|
|
recorded_events = self.preprocessing(recorded_events)
|
|
counters = {k: 0 for k in self.bads}
|
|
cnt_scheduling_in_past = 0
|
|
mp_states = MediaPlayerStateIterator(recorded_events, self.events_definition)
|
|
for st in mp_states:
|
|
evname = st["evname"]
|
|
if evname in counters:
|
|
counters[evname] += 1
|
|
elif ("p.P.ut.1.9" and
|
|
st["rescheduling_time"] is not None and
|
|
st["rescheduling_time"] < 0):
|
|
cnt_scheduling_in_past += 1
|
|
counters["scheduling_in_past"] = cnt_scheduling_in_past
|
|
return counters
|