Download scripts/flicker.py from conan123/tinydeskoutstanding-guides: direct link, hf CLI and curl.
- Browser
- Download file 5.4 kB
-
https://huggingface.co/datasets/conan123/tinydeskoutstanding-guides/resolve/main/scripts/flicker.py
- Command line
-
hf download hf://datasets/conan123/tinydeskoutstanding-guides/scripts/flicker.py
-
curl -L -o flicker.py https://huggingface.co/datasets/conan123/tinydeskoutstanding-guides/resolve/main/scripts/flicker.py
5.4 kB
| #!/usr/bin/env python3 | |
| """Measure frame-to-frame flicker in a short clip (NumPy + ffmpeg only). | |
| Global flicker: the whole frame gets brighter/darker for a frame or two. | |
| Local flicker: one region (a lamp, a face, a wall) pulses while the rest is steady. | |
| Both are measured inside shots only, so hard cuts don't count as flicker. | |
| usage: python3 flicker.py clip.mp4 [more.mp4 ...] [--grid 4x6] [--json] | |
| """ | |
| import argparse, json, subprocess | |
| import numpy as np | |
| W, H = 180, 320 # 9:16 analysis size, gray | |
| WIN = 9 # trend window (frames) = the "slow" brightness | |
| def frames(path): | |
| cmd = ["ffmpeg", "-v", "error", "-i", path, "-vf", | |
| f"scale={W}:{H}:flags=area,format=gray", "-f", "rawvideo", "-"] | |
| raw = subprocess.run(cmd, capture_output=True, check=True).stdout | |
| return np.frombuffer(raw, np.uint8).reshape(-1, H, W).astype(np.float32) | |
| def fps_of(path): | |
| out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", | |
| "-show_entries", "stream=avg_frame_rate", "-of", "csv=p=0", path], | |
| capture_output=True, text=True, check=True).stdout.strip() | |
| n, d = out.split("/") | |
| return float(n) / float(d) | |
| def cuts(f): | |
| """Indices i where frame i starts a new shot. | |
| A cut is a *spike* in mean absolute frame difference: above max(12, 4x median) | |
| AND more than twice the difference on both neighbouring frame pairs. The spike | |
| rule keeps fast motion (a head turn raises several pairs in a row) from | |
| being counted as a cut. | |
| """ | |
| mad = np.abs(np.diff(f, axis=0)).mean(axis=(1, 2)) # len n-1 | |
| thr = max(12.0, 4 * float(np.median(mad))) | |
| out = [] | |
| for i, v in enumerate(mad): | |
| prev = mad[i - 1] if i > 0 else 0.0 | |
| nxt = mad[i + 1] if i + 1 < len(mad) else 0.0 | |
| if v > thr and v > 2 * prev and v > 2 * nxt: | |
| out.append(i + 1) | |
| return out, mad | |
| def detrend(x): | |
| """x minus its slow trend: what's left is the fast, frame-to-frame part. | |
| The trend is a 9-tap moving average with half-weight end taps. Those weights | |
| cancel a period-2 (every-other-frame) pulse and a period-4 pulse exactly, so | |
| the fastest flicker ends up fully in the residual instead of in the trend. | |
| (A moving *median* would hide an every-other-frame pulse completely.) | |
| """ | |
| k = np.ones(WIN); k[0] = k[-1] = 0.5; k /= k.sum() | |
| pad = WIN // 2 | |
| xp = np.pad(x, pad, mode="edge") | |
| return x - np.convolve(xp, k, mode="valid") | |
| def lag1(x): | |
| """Lag-1 autocorrelation of a residual. Near -1 = strobing every other frame | |
| (true flicker); near 0 or positive = smoother change, usually motion.""" | |
| x = x - x.mean() | |
| d = float((x * x).sum()) | |
| return float((x[1:] * x[:-1]).sum() / d) if d > 0 else 0.0 | |
| def analyse(path, gy=6, gx=4): | |
| f = frames(path) | |
| fps = fps_of(path) | |
| cut_idx, mad = cuts(f) | |
| bounds = [0] + cut_idx + [len(f)] | |
| th, tw = H // gy, W // gx | |
| tiles = f[:, :th * gy, :tw * gx].reshape(len(f), gy, th, gx, tw).mean(axis=(2, 4)) | |
| g_res, t_res, shots = [], [], [] | |
| for a, b in zip(bounds[:-1], bounds[1:]): | |
| if b - a < WIN: # too short to separate slow from fast | |
| continue | |
| m = f[a:b].mean(axis=(1, 2)) | |
| g = detrend(m)[2:-2] # drop 2 frames each side of a cut | |
| t = np.stack([detrend(tiles[a:b, y, x]) for y in range(gy) for x in range(gx)], 1)[2:-2] | |
| g_res.append(g); t_res.append(t) | |
| tile_rms = np.sqrt((t ** 2).mean(axis=0)) | |
| shots.append({"start_s": round(a / fps, 3), "end_s": round(b / fps, 3), | |
| "global_rms": round(float(np.sqrt((g ** 2).mean())), 3), | |
| "worst_tile_rms": round(float(tile_rms.max()), 3), | |
| "worst_tile": int(tile_rms.argmax())}) | |
| g_all = np.concatenate(g_res); t_all = np.concatenate(t_res) | |
| tile_rms = np.sqrt((t_all ** 2).mean(axis=0)) | |
| wt = int(tile_rms.argmax()) | |
| return {"clip": path.split("/")[-1][:12], "fps": round(fps, 3), "frames": len(f), | |
| "cuts_s": [round(i / fps, 3) for i in cut_idx], | |
| "global_rms": round(float(np.sqrt((g_all ** 2).mean())), 3), | |
| "global_p99": round(float(np.percentile(np.abs(g_all), 99)), 3), | |
| "median_tile_rms": round(float(np.median(tile_rms)), 3), | |
| "worst_tile_rms": round(float(tile_rms.max()), 3), | |
| "worst_tile": wt, | |
| "global_lag1": round(lag1(g_all), 2), | |
| "worst_tile_lag1": round(lag1(t_all[:, wt]), 2), | |
| "shots": shots} | |
| if __name__ == "__main__": | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("clips", nargs="+") | |
| ap.add_argument("--grid", default="4x6", help="columns x rows of the tile grid") | |
| ap.add_argument("--json", action="store_true") | |
| a = ap.parse_args() | |
| gx, gy = map(int, a.grid.split("x")) | |
| print(f"{'clip':12} {'fps':>5} {'cuts (s)':22} {'global':>7} {'p99':>6} {'tile med':>8} {'tile max':>8} {'lag1 g':>6} {'lag1 t':>6}") | |
| for c in a.clips: | |
| r = analyse(c, gy, gx) | |
| if a.json: | |
| print(json.dumps(r)) | |
| cs = ",".join(f"{x:g}" for x in r["cuts_s"]) or "-" | |
| print(f"{r['clip']:12} {r['fps']:5.1f} {cs:22} {r['global_rms']:7.3f} {r['global_p99']:6.2f} " | |
| f"{r['median_tile_rms']:8.3f} {r['worst_tile_rms']:8.3f} {r['global_lag1']:6.2f} {r['worst_tile_lag1']:6.2f}") | |