Spaces:
Runtime error
Runtime error
File size: 10,798 Bytes
d82cf6a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
"""
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
|