def identify_video_subregion(self, ww, wh, damage_events_count, last_damage_events, starting_at=0): if not self.enabled or not self.supported: self.novideoregion("disabled") return if not self.detection: return sslog("%s.identify_video_subregion(..)", self) sslog("identify_video_subregion(%s, %s, %s, %s)", ww, wh, damage_events_count, last_damage_events) if damage_events_count < self.set_at: #stats got reset self.set_at = 0 #validate against window dimensions: rect = self.rectangle if rect and (rect.width > ww or rect.height > wh): #region is now bigger than the window! return self.novideoregion( "window is now smaller than current region") #arbitrary minimum size for regions we will look at: #(we don't want video regions smaller than this - too much effort for little gain) if ww < MIN_W or wh < MIN_H: return self.novideoregion("window is too small: %sx%s", MIN_W, MIN_H) def update_markers(): self.counter = damage_events_count self.time = time.time() def few_damage_events(event_types, event_count): elapsed = time.time() - self.time #how many damage events occurred since we chose this region: event_count = max(0, damage_events_count - self.set_at) #make the timeout longer when the region has worked longer: slow_region_timeout = 2 + math.log(2 + event_count, 1.5) if rect and elapsed >= slow_region_timeout: update_markers() return self.novideoregion( "too much time has passed (%is for %s %s events)", elapsed, event_types, event_count) sslog( "identify video: waiting for more %s damage events (%s) counters: %s / %s", event_types, event_count, self.counter, damage_events_count) if self.counter + 10 > damage_events_count: #less than 10 events since last time we called update_markers: event_count = damage_events_count - self.counter few_damage_events("total", event_count) return from_time = max(starting_at, time.time() - MAX_TIME) #create a list (copy) to work on: lde = [x for x in list(last_damage_events) if x[0] >= from_time] dc = len(lde) if dc <= MIN_EVENTS: return self.novideoregion("not enough damage events yet (%s)", dc) #structures for counting areas and sizes: wc = {} hc = {} dec = {} #count how many times we see each area, each width/height and where, #after removing any exclusion zones: for _, x, y, w, h in lde: r = rectangle(x, y, w, h) rects = [r] if self.exclusion_zones: for e in self.exclusion_zones: new_rects = [] for r in rects: ex, ey, ew, eh = e.get_geometry() if ex < 0 or ey < 0: #negative values are relative to the width / height of the window: if ex < 0: ex = max(0, ww - ew) if ey < 0: ey = max(0, wh - eh) new_rects += r.substract(ex, ey, ew, eh) rects = new_rects for r in rects: dec.setdefault(r, MutableInteger()).increase() if w >= MIN_W: wc.setdefault(w, dict()).setdefault(x, set()).add(r) if h >= MIN_H: hc.setdefault(h, dict()).setdefault(y, set()).add(r) #we can shortcut the damaged ratio if the whole window got damaged at least once: all_damaged = dec.get(rectangle(0, 0, ww, wh), 0) > 0 def inoutcount(region, ignore_size=0): #count how many pixels are in or out if this region incount, outcount = 0, 0 for r, count in dec.items(): inregion = r.intersection_rect(region) if inregion: incount += inregion.width * inregion.height * int(count) outregions = r.substract_rect(region) for x in outregions: if ignore_size > 0 and x.width * x.height < ignore_size: #skip small region outside rectangle continue outcount += x.width * x.height * int(count) return incount, outcount def damaged_ratio(rect): if all_damaged: return 1 rects = [rect] for _, x, y, w, h in lde: r = rectangle(x, y, w, h) new_rects = [] for cr in rects: new_rects += cr.substract_rect(r) if not new_rects: #nothing left: damage covered the whole rect return 1.0 rects = new_rects not_damaged_pixels = sum((r.width * r.height) for r in rects) rect_pixels = rect.width * rect.height #sslog("damaged_ratio: not damaged pixels(%s)=%i, rect pixels(%s)=%i", rects, not_damaged_pixels, rect, rect_pixels) return max( 0, min(1, 1.0 - float(not_damaged_pixels) / float(rect_pixels))) scores = {None: 0} def score_region(info, region, ignore_size=0, d_ratio=0): score = scores.get(region) if score is not None: return score #check if the region given is a good candidate, and if so we use it #clamp it: if region.width < MIN_W or region.height < MIN_H: #too small, ignore it: return 0 #and make sure this does not end up much bigger than needed: if ww * wh < (region.width * region.height): return 0 incount, outcount = inoutcount(region, ignore_size) total = incount + outcount score = scoreinout(ww, wh, region, incount, outcount) #discount score if the region contains areas that were not damaged: #(apply sqrt to limit the discount: 50% damaged -> multiply by 0.7) if d_ratio == 0: d_ratio = damaged_ratio(region) score = int(score * math.sqrt(d_ratio)) sslog( "testing %12s video region %34s: %3i%% in, %3i%% out, %3i%% of window, damaged ratio=%.2f, score=%2i", info, region, 100 * incount // total, 100 * outcount // total, 100 * region.width * region.height / ww / wh, d_ratio, score) scores[region] = score return score def updateregion(rect): self.rectangle = rect self.time = time.time() self.inout = inoutcount(rect) self.score = scoreinout(ww, wh, rect, *self.inout) self.fps = int(self.inout[0] / (rect.width * rect.height) / (time.time() - from_time)) self.damaged = int(100 * damaged_ratio(self.rectangle)) self.last_scores = scores sslog("score(%s)=%s, damaged=%i%%", self.inout, self.score, self.damaged) def setnewregion(rect, msg="", *args): if not self.rectangle or self.rectangle != rect: sslog("setting new region %s: " + msg, rect, *args) self.set_at = damage_events_count self.counter = damage_events_count if not self.enabled: #could have been disabled since we started this method! self.novideoregion("disabled") return if not self.detection: return updateregion(rect) update_markers() if len(dec) == 1: rect, count = dec.items()[0] return setnewregion(rect, "only region damaged") #see if we can keep the region we already have (if any): cur_score = 0 if rect: cur_score = score_region("current", rect) if cur_score >= KEEP_SCORE: sslog("keeping existing video region %s with score %s", rect, cur_score) return #split the regions we really care about (enough pixels, big enough): damage_count = {} min_count = max(2, len(lde) / 40) for r, count in dec.items(): #ignore small regions: if count > min_count and r.width >= MIN_W and r.height >= MIN_H: damage_count[r] = count c = sum([int(x) for x in damage_count.values()]) most_damaged = -1 most_pct = 0 if c > 0: most_damaged = int(sorted(damage_count.values())[-1]) most_pct = 100 * most_damaged / c sslog("identify video: most=%s%% damage count=%s", most_pct, damage_count) #is there a region that stands out? #try to use the region which is responsible for most of the large damage requests: most_damaged_regions = [ r for r, v in damage_count.items() if v == most_damaged ] if len(most_damaged_regions) == 1: r = most_damaged_regions[0] score = score_region("most-damaged", r, d_ratio=1.0) sslog("identify video: score most damaged area %s=%i%%", r, score) if score > 120: setnewregion(r, "%s%% of large damage requests, score=%s", most_pct, score) return elif score >= 100: scores[r] = score #try harder: try combining regions with the same width or height: #(some video players update the video region in bands) for w, d in wc.items(): for x, regions in d.items(): if len(regions) >= 2: #merge regions of width w at x min_count = max(2, len(regions) / 25) keep = [ r for r in regions if int(dec.get(r, 0)) >= min_count ] sslog( "vertical regions of width %i at %i with at least %i hits: %s", w, x, min_count, keep) if keep: merged = merge_all(keep) scores[merged] = score_region("vertical", merged, 48 * 48) for h, d in hc.items(): for y, regions in d.items(): if len(regions) >= 2: #merge regions of height h at y min_count = max(2, len(regions) / 25) keep = [ r for r in regions if int(dec.get(r, 0)) >= min_count ] sslog( "horizontal regions of height %i at %i with at least %i hits: %s", h, y, min_count, keep) if keep: merged = merge_all(keep) scores[merged] = score_region("horizontal", merged, 48 * 48) sslog("merged regions scores: %s", scores) highscore = max(scores.values()) #a score of 100 is neutral if highscore >= 120: region = [r for r, s in scores.items() if s == highscore][0] return setnewregion(region, "very high score: %s", highscore) #retry existing region, tolerate lower score: if cur_score >= 90 and (highscore < 100 or cur_score >= highscore): sslog("keeping existing video region %s with score %s", rect, cur_score) return setnewregion(self.rectangle, "existing region with score: %i" % cur_score) if highscore >= 100: region = [r for r, s in scores.items() if s == highscore][0] return setnewregion(region, "high score: %s", highscore) #FIXME: re-add some scrolling detection #try harder still: try combining all the regions we haven't discarded #(flash player with firefox and youtube does stupid unnecessary repaints) if len(damage_count) >= 2: merged = merge_all(damage_count.keys()) score = score_region("merged", merged) if score >= 110: return setnewregion(merged, "merged all regions, score=%s", score) self.novideoregion("failed to identify a video region") self.last_scores = scores
def identify_video_subregion(self, ww, wh, damage_events_count, last_damage_events, starting_at=0): if not self.detection: return if not self.enabled: #could have been disabled since we started this method! self.novideoregion("disabled") sslog("%s.identify_video_subregion(..)", self) sslog("identify_video_subregion(%s, %s, %s, %s)", ww, wh, damage_events_count, last_damage_events) def setnewregion(rect, msg="", *args): if rect.x <= 0 and rect.y <= 0 and rect.width >= ww and rect.height >= wh: #same size as the window, don't use a region! self.novideoregion("region is full window") return sslog("setting new region %s: " + msg, rect, *args) self.set_at = damage_events_count self.counter = damage_events_count if not self.enabled: #could have been disabled since we started this method! self.novideoregion("disabled") return if not self.detection: return self.rectangle = rect if damage_events_count < self.set_at: #stats got reset self.set_at = 0 #validate against window dimensions: rect = self.rectangle if rect and (rect.width > ww or rect.height > wh): #region is now bigger than the window! return self.novideoregion( "window is now smaller than current region") #arbitrary minimum size for regions we will look at: #(we don't want video regions smaller than this - too much effort for little gain) if ww < MIN_W or wh < MIN_H: return self.novideoregion("window is too small: %sx%s", MIN_W, MIN_H) def update_markers(): self.counter = damage_events_count self.time = time.time() def few_damage_events(event_types, event_count): elapsed = time.time() - self.time #how many damage events occurred since we chose this region: event_count = max(0, damage_events_count - self.set_at) #make the timeout longer when the region has worked longer: slow_region_timeout = 2 + math.log(2 + event_count, 1.5) if rect and elapsed >= slow_region_timeout: update_markers() return self.novideoregion( "too much time has passed (%is for %s %s events)", elapsed, event_types, event_count) sslog( "identify video: waiting for more %s damage events (%s) counters: %s / %s", event_types, event_count, self.counter, damage_events_count) if self.counter + 10 > damage_events_count: #less than 10 events since last time we called update_markers: event_count = damage_events_count - self.counter few_damage_events("total", event_count) return from_time = max(starting_at, time.time() - MAX_TIME) #create a list (copy) to work on: lde = [x for x in list(last_damage_events) if x[0] >= from_time] dc = len(lde) if dc <= MIN_EVENTS: return self.novideoregion("not enough damage events yet (%s)", dc) #structures for counting areas and sizes: wc = {} hc = {} dec = {} #count how many times we see each area, each width/height and where: for _, x, y, w, h in lde: r = rectangle(x, y, w, h) dec.setdefault(r, MutableInteger()).increase() if w >= MIN_W: wc.setdefault(w, dict()).setdefault(x, set()).add(r) if h >= MIN_H: hc.setdefault(h, dict()).setdefault(y, set()).add(r) def score_region(info, region, ignore_size=0): #check if the region given is a good candidate, and if so we use it #clamp it: width = min(ww, region.width) height = min(wh, region.height) if width < MIN_W or height < MIN_H: #too small, ignore it: return 0 #and make sure this does not end up much bigger than needed: insize = width * height if ww * wh < insize: return 0 #count how many pixels are in or out if this region incount, outcount = 0, 0 for r, count in dec.items(): inregion = r.intersection_rect(region) if inregion: incount += inregion.width * inregion.height * int(count) outregions = r.substract_rect(region) for x in outregions: if ignore_size > 0 and x.width * x.height < ignore_size: #skip small region outside rectangle continue outcount += x.width * x.height * int(count) total = incount + outcount assert total > 0 inpct = 100 * incount / total outpct = 100 * outcount / total #devaluate by taking into account the number of pixels in the area #so that a large video region only wins if it really #has a larger proportion of the pixels #(offset the "insize" to even things out a bit: # if we have a series of vertical or horizontal bands that we merge, # we would otherwise end up excluding the ones on the edge # if they ever happen to have a slightly lower hit count) score = inpct * ww * wh * 2 / (ww * wh + insize) sslog( "testing %12s video region %34s: %3i%% in, %3i%% out, %3i%% of window, score=%2i", info, region, inpct, outpct, 100 * width * height / ww / wh, score) return score update_markers() #see if we can keep the region we already have (if any): cur_score = 0 if rect: cur_score = score_region("current", rect) if cur_score >= 125: sslog("keeping existing video region %s with score %s", rect, cur_score) return scores = {None: 0} #split the regions we really care about (enough pixels, big enough): damage_count = {} min_count = max(2, len(lde) / 40) for r, count in dec.items(): #ignore small regions: if count > min_count and r.width >= MIN_W and r.height >= MIN_H: damage_count[r] = count c = sum([int(x) for x in damage_count.values()]) most_damaged = -1 most_pct = 0 if c > 0: most_damaged = int(sorted(damage_count.values())[-1]) most_pct = 100 * most_damaged / c sslog("identify video: most=%s%% damage count=%s", most_pct, damage_count) #is there a region that stands out? #try to use the region which is responsible for most of the large damage requests: most_damaged_regions = [ r for r, v in damage_count.items() if v == most_damaged ] if len(most_damaged_regions) == 1: r = most_damaged_regions[0] score = score_region("most-damaged", r) sslog("identify video: score most damaged area %s=%s%%", r, score) if score > 120: setnewregion(r, "%s%% of large damage requests, score=%s", most_pct, score) return elif score >= 100: scores[r] = score #try harder: try combining regions with the same width or height: #(some video players update the video region in bands) for w, d in wc.items(): for x, regions in d.items(): if len(regions) >= 2: #merge regions of width w at x min_count = max(2, len(regions) / 25) keep = [ r for r in regions if int(dec.get(r, 0)) >= min_count ] sslog( "vertical regions of width %i at %i with at least %i hits: %s", w, x, min_count, keep) if keep: merged = merge_all(keep) scores[merged] = score_region("vertical", merged, 48 * 48) for h, d in hc.items(): for y, regions in d.items(): if len(regions) >= 2: #merge regions of height h at y min_count = max(2, len(regions) / 25) keep = [ r for r in regions if int(dec.get(r, 0)) >= min_count ] sslog( "horizontal regions of height %i at %i with at least %i hits: %s", h, y, min_count, keep) if keep: merged = merge_all(keep) scores[merged] = score_region("horizontal", merged, 48 * 48) sslog("merged regions scores: %s", scores) highscore = max(scores.values()) #a score of 100 is neutral if highscore >= 120: region = [r for r, s in scores.items() if s == highscore][0] return setnewregion(region, "very high score: %s", highscore) #retry existing region, tolerate lower score: if cur_score >= 90: sslog("keeping existing video region %s with score %s", rect, cur_score) return if highscore >= 100: region = [r for r, s in scores.items() if s == highscore][0] return setnewregion(region, "high score: %s", highscore) #FIXME: re-add some scrolling detection #try harder still: try combining all the regions we haven't discarded #(flash player with firefox and youtube does stupid unnecessary repaints) if len(damage_count) >= 2: merged = merge_all(damage_count.keys()) score = score_region("merged", merged) if score >= 110: return setnewregion(merged, "merged all regions, score=%s", score, 48 * 48) self.novideoregion("failed to identify a video region")