DEV Community: Peiguan

How Do You Pick the Cover Frame for a Hit the Road Dude Clip? A Sharpness-and-Exposure Picker With ffmpeg and NumPy

Peiguan — Tue, 10 Nov 2026 01:12:14 +0000

When you post a Hit the Road Dude clip, the State Property meme where a driver at a pickup window repeats "State?" and sends someone off, the cover frame decides whether anyone taps it. Most platforms pick a frame for you, and they often pick a mid-blink or a motion-blurred one. This is a small tool that picks a better one automatically.

I build hittheroaddude.app, an independent studio that turns one photo of an adult or a pet into the 15-second, vertical 9:16 pickup-window clip with a newly generated voice. Which frame to use as a thumbnail is a fair question for anyone posting a remake, so here is a rule of thumb turned into a script. I tested it on a synthetic clip, not on generated customer clips, so the numbers below only show that the picker works, not how it scores any real remake.

What makes a good cover frame

Three things I can measure without a model:

Sharpness. A blurred frame (motion, a transition) has little fine detail. The variance of a Laplacian is the classic cheap measure: the more edges, the higher the variance.
Exposure. Skip frames that are mostly black or blown out. I check the mean brightness and the share of crushed or clipped pixels.
Distance from the edges. The first and last half-second are often a fade, a hard cut or a frozen end frame. If you want to check those separately, see the black-and-frozen-edges check in my guides repo.

What this does not measure is whether the face looks right or whether the driver's expression is the funny one. For a meme with a deadpan pause, the best frame is often the "State?" beat, and no sharpness metric knows that. So the script prints the top few timestamps and you make the final call.

The script

It decodes the clip once with ffmpeg to small grayscale frames (135 by 240, which is plenty for scoring), scores each, and then asks ffmpeg for the winning frame at full resolution:

#!/usr/bin/env python3
"""Pick the best cover frame from a short clip: sharp, well exposed, away from the edges.

usage: python3 pick_cover.py clip.mp4 [--fps 4] [--top 3] [--out cover.jpg]
Needs ffmpeg/ffprobe on PATH and numpy.
"""
import argparse, subprocess, json, sys
import numpy as np

W, H = 135, 240          # analysis size (9:16); scoring does not need full resolution

def duration(path):
    out = subprocess.check_output(["ffprobe", "-v", "error", "-show_entries", "format=duration",
                                   "-of", "json", path])
    return float(json.loads(out)["format"]["duration"])

def frames(path, fps):
    cmd = ["ffmpeg", "-v", "error", "-i", path, "-vf", f"fps={fps},scale={W}:{H},format=gray",
           "-f", "rawvideo", "-"]
    raw = subprocess.run(cmd, capture_output=True, check=True).stdout
    n = len(raw) // (W * H)
    return np.frombuffer(raw[: n * W * H], np.uint8).reshape(n, H, W).astype(np.float32)

def sharpness(f):
    # variance of a 4-neighbour Laplacian: higher = more fine detail
    lap = (-4 * f[1:-1, 1:-1] + f[:-2, 1:-1] + f[2:, 1:-1] + f[1:-1, :-2] + f[1:-1, 2:])
    return float(lap.var())

def score(f):
    mean = float(f.mean())
    clipped = float(((f < 8) | (f > 247)).mean())      # share of crushed/blown pixels
    exposure_ok = 1.0 if 45 <= mean <= 210 else 0.3
    return sharpness(f) * exposure_ok * (1 - clipped)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("clip"); ap.add_argument("--fps", type=float, default=4)
    ap.add_argument("--top", type=int, default=3); ap.add_argument("--out", default="cover.jpg")
    ap.add_argument("--margin", type=float, default=0.5, help="seconds to skip at both ends")
    a = ap.parse_args()
    dur = duration(a.clip); fr = frames(a.clip, a.fps)
    cand = [(score(f), i / a.fps) for i, f in enumerate(fr) if a.margin <= i / a.fps <= dur - a.margin]
    if not cand: sys.exit("clip too short for that margin")
    cand.sort(reverse=True)
    for s, t in cand[: a.top]:
        print(f"t={t:5.2f}s score={s:8.1f}")
    best_t = cand[0][1]
    subprocess.run(["ffmpeg", "-v", "error", "-y", "-ss", f"{best_t:.3f}", "-i", a.clip,
                    "-frames:v", "1", "-q:v", "2", a.out], check=True)
    print(f"wrote {a.out} from t={best_t:.2f}s")

if __name__ == "__main__":
    main()

A test clip with a known answer

Real clips would make a poor test because I would not know the right answer. So I generate a 10-second 9:16 clip made of three parts: seconds 0 to 3 blurred, 3 to 7 sharp, 7 to 10 dark. A correct picker must choose from the middle.

#!/usr/bin/env bash
# 10 s synthetic 9:16 clip: blurry 0-3 s, sharp 3-7 s (detail), dark 7-10 s
set -e
ffmpeg -v error -y -f lavfi -i "testsrc2=s=540x960:r=24:d=10" -f lavfi -i "sine=f=300:d=10" \
  -vf "split=3[a][b][c];[a]trim=0:3,boxblur=12,setpts=PTS-STARTPTS[x];[b]trim=3:7,setpts=PTS-STARTPTS[y];[c]trim=7:10,eq=brightness=-0.7,setpts=PTS-STARTPTS[z];[x][y][z]concat=n=3:v=1:a=0" \
  -c:v libx264 -pix_fmt yuv420p -shortest -an test_cover.mp4
echo wrote test_cover.mp4

Run:

$ ./make_cover_test.sh && python3 pick_cover.py test_cover.mp4 --out cover.jpg
t= 6.75s score=   695.0
t= 6.50s score=   679.2
t= 3.25s score=   678.2
wrote cover.jpg from t=6.75s

The top three all sit in the sharp section (3.25 s is just after the blur ends, 6.50 and 6.75 s are just before the dark part starts). Nothing from the blurred or dark parts made the list. The scores are close because the test pattern is uniformly detailed; I have not measured the gap on real clips.

Why the exposure term is a multiplier

A plain sharpness score can reward a mostly black frame, because hard edges between black and bright areas score high on a Laplacian. Multiplying by an exposure factor (1.0 if the mean brightness is between 45 and 210, otherwise 0.3) and by the share of non-clipped pixels guards against that. It is a hack, and the thresholds are my choice, not a standard. If your clips are intentionally dark, change them.

Tips for using it

Raise --fps (to 8 or 12) if the clip has fast movement. The default of 4 frames per second is enough for a mostly static camera like the pickup window.
Use --margin to skip more of the start. I use 0.5 s by default.
Always look at the top three. The score finds sharp frames, not funny ones. If the "State?" beat is in the top three, take it.
Crop for the platform. A 9:16 cover is cropped to a square on some profile grids, so keep the face in the middle third. My posting check covers the rest of what to look at before you share a remake.
Label the post. Say it is an AI remake. The studio's clips use a new voice, not the original recording (original audio or new voice).

If you want the clip itself

The studio makes one 15-second clip from one photo. It takes no prompt: the pickup-window scene and lines are one saved preset, and you choose 480p or 720p. As of November 10, 2026 the pricing page lists $9.99 at 480p and $12.99 at 720p per clip, paid once. Signed-in accounts can also buy credit packs: $27.99 for 30 credits, $71.99 for 100 credits and $129.99 for 200 credits, where a 480p clip spends 6 credits and a 720p clip 14. There are no free clips, and there is no watermark (FAQ).

The picker works on any short clip, so you can use it on whatever you make or download, as long as you have the right to use it.

Can You Upscale a Malfoid AI Portrait for a Poster? Lanczos vs FSRCNN vs Nearest, Measured With a Round-Trip Test

Peiguan — Mon, 09 Nov 2026 10:36:41 +0000

Short answer: yes for about 2x, and you should measure it, not trust the name of the filter. A small learned upscaler (FSRCNN, 40 KB, runs on a CPU through OpenCV) rebuilt my test portrait better than Lanczos or bicubic at 2x. At 4x every method was close to every other, because the detail simply isn't in the file. The script below does a round-trip test on your own picture: shrink it, enlarge it back with each method, score against the original, and only then enlarge the real thing with the winner.

I run malfoidai.com, a small paid studio that makes still Malfoid (Female Malfoy / Fem Draco) fan portraits. The output is one still 3:4 picture at 1K, and the studio's own check-before-posting guide says plainly that it's "not meant for large prints; enlarging it far past its size will look soft." "Can I upscale it?" is still the most common follow-up question, so here's the honest, measured version.

What "1K" gets you on paper

The site doesn't publish an exact pixel size, so check yours: open the download's file info, or run python -c "from PIL import Image; print(Image.open('portrait.png').size)". For the arithmetic below I use 768×1024, a common 3:4 "1K" size; swap in your own numbers.

Pixels	At 300 ppi (photo print)	At 150 ppi (poster seen from 1 m)
768 × 1024 (as downloaded)	6.5 × 8.7 cm	13 × 17.3 cm
1536 × 2048 (2x upscale)	13 × 17.3 cm	26 × 34.7 cm
3072 × 4096 (4x upscale)	26 × 34.7 cm	52 × 69 cm

An upscaler can't invent the real strands of hair that weren't rendered. What it can do is make edges clean instead of blurry or stair-stepped. That difference is measurable.

The round-trip test

You don't have a "true" 2048-pixel version of your portrait, so you can't score a 2x enlargement directly. You can, however, make a smaller copy of the picture you do have, enlarge that copy back, and compare it with the original. A method that rebuilds 1024 from 512 well will usually build 2048 from 1024 well too. (It's an approximation: real camera-to-model detail isn't the same as an area downscale. It's still far better than eyeballing two blurry PNGs.)

Three scores per method:

PSNR (dB, higher is better): plain pixel error on luma.
SSIM (0–1, higher is better): local structure, closer to what eyes notice.
Ringing: average overshoot in 8-bit levels right next to strong edges. Lanczos and unsharp masks create bright/dark halos there, which look like a "glow" around hair against a dark robe.

Setup

pip install opencv-contrib-python-headless numpy
mkdir models
curl -L -o models/FSRCNN_x2.pb https://raw.githubusercontent.com/Saafke/FSRCNN_Tensorflow/master/models/FSRCNN_x2.pb
curl -L -o models/FSRCNN_x4.pb https://raw.githubusercontent.com/Saafke/FSRCNN_Tensorflow/master/models/FSRCNN_x4.pb

opencv-contrib is needed for cv2.dnn_superres. The two .pb files are about 40 KB each. Without them the script just skips FSRCNN.

The script

#!/usr/bin/env python3
"""Compare ways to enlarge a 1K portrait, with numbers instead of eyeballing.

Round-trip test: shrink the picture 2x (or 4x), enlarge it back with each
method, and score the result against the original (PSNR and SSIM on luma,
plus a ringing score around hard edges). The method that rebuilds the
original best is the one to use for a real 2x/4x enlargement.

    pip install opencv-contrib-python-headless numpy
    python upscale_compare.py portrait.png [--scale 2] [--models DIR] [--out DIR] [--sheet sheet.png]

--models DIR is optional; put FSRCNN_x2.pb / FSRCNN_x4.pb there (from
github.com/Saafke/FSRCNN_Tensorflow/tree/master/models) to include the
small learned upscaler. Without it only the classic filters run.
"""
import argparse, os, sys
import cv2
import numpy as np


def luma(img):
    return cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)[:, :, 0].astype(np.float64)


def psnr(a, b):
    mse = np.mean((luma(a) - luma(b)) ** 2)
    return float("inf") if mse == 0 else 10 * np.log10(255.0 ** 2 / mse)


def ssim(a, b):
    x, y = luma(a), luma(b)
    c1, c2 = (0.01 * 255) ** 2, (0.03 * 255) ** 2
    blur = lambda z: cv2.GaussianBlur(z, (11, 11), 1.5)
    mx, my = blur(x), blur(y)
    sxx, syy, sxy = blur(x * x) - mx * mx, blur(y * y) - my * my, blur(x * y) - mx * my
    m = ((2 * mx * my + c1) * (2 * sxy + c2)) / ((mx * mx + my * my + c1) * (sxx + syy + c2))
    return float(m.mean())


def ringing(ref, out):
    """Mean overshoot (in 8-bit levels) next to strong edges of the reference."""
    e = cv2.Canny(ref, 80, 160) > 0
    band = cv2.dilate(e.astype(np.uint8), np.ones((5, 5), np.uint8)) > 0
    band &= ~e
    lo = cv2.erode(luma(ref), np.ones((5, 5)))
    hi = cv2.dilate(luma(ref), np.ones((5, 5)))
    y = luma(out)
    over = np.maximum(y - hi, 0) + np.maximum(lo - y, 0)
    return float(over[band].mean()) if band.any() else 0.0


def unsharp(img, amount=0.6, sigma=1.0):
    blur = cv2.GaussianBlur(img, (0, 0), sigma)
    return cv2.addWeighted(img, 1 + amount, blur, -amount, 0)


def methods(scale, models):
    m = {
        "nearest": lambda im: cv2.resize(im, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST),
        "bilinear": lambda im: cv2.resize(im, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR),
        "bicubic": lambda im: cv2.resize(im, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC),
        "lanczos4": lambda im: cv2.resize(im, None, fx=scale, fy=scale, interpolation=cv2.INTER_LANCZOS4),
        "lanczos4+unsharp": lambda im: unsharp(cv2.resize(im, None, fx=scale, fy=scale, interpolation=cv2.INTER_LANCZOS4)),
    }
    path = os.path.join(models, f"FSRCNN_x{scale}.pb") if models else ""
    if path and os.path.exists(path):
        sr = cv2.dnn_superres.DnnSuperResImpl_create()
        sr.readModel(path)
        sr.setModel("fsrcnn", scale)
        m["fsrcnn"] = sr.upsample
    elif models:
        print(f"note: {path} not found, skipping FSRCNN", file=sys.stderr)
    return m


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("image")
    ap.add_argument("--scale", type=int, default=2, choices=[2, 4])
    ap.add_argument("--models", default="")
    ap.add_argument("--out", default="")
    ap.add_argument("--sheet", default="", help="write a labelled crop sheet (PNG) to look at")
    ap.add_argument("--crop", default="0.35,0.30,0.30,0.20",
                    help="sheet crop as x,y,w,h fractions of the image (default: around the eyes)")
    a = ap.parse_args()
    ref = cv2.imread(a.image, cv2.IMREAD_COLOR)
    if ref is None:
        sys.exit(f"cannot read {a.image}")
    h, w = ref.shape[:2]
    h, w = h - h % a.scale, w - w % a.scale
    ref = ref[:h, :w]
    small = cv2.resize(ref, (w // a.scale, h // a.scale), interpolation=cv2.INTER_AREA)
    print(f"{a.image}: {w}x{h}, round trip via {w // a.scale}x{h // a.scale} (x{a.scale})")
    print(f"{'method':<18}{'PSNR dB':>9}{'SSIM':>8}{'ringing':>9}")
    ms = methods(a.scale, a.models)
    rows, ups = [], {}
    for name, f in ms.items():
        up = f(small)[:h, :w]
        ups[name] = up
        rows.append((name, psnr(ref, up), ssim(ref, up), ringing(ref, up)))
    for name, p, s, r in sorted(rows, key=lambda t: -t[2]):
        print(f"{name:<18}{p:>9.2f}{s:>8.4f}{r:>9.2f}")
    # Nearest-neighbour can top SSIM on fine random texture (it keeps local
    # contrast), but it prints as visible blocks, so it never gets auto-picked.
    best = max((r for r in rows if r[0] != "nearest"), key=lambda t: t[2])[0]
    print(f"best by SSIM (excluding nearest): {best}")
    if a.sheet:
        fx, fy, fw, fh = (float(v) for v in a.crop.split(","))
        x0, y0, cw, ch = int(fx * w), int(fy * h), int(fw * w), int(fh * h)
        tiles = []
        for name in ["original"] + [r[0] for r in rows]:
            src = ref if name == "original" else ups[name]
            t = cv2.resize(src[y0:y0 + ch, x0:x0 + cw], (cw * 2, ch * 2), interpolation=cv2.INTER_NEAREST)
            t = cv2.copyMakeBorder(t, 28, 4, 4, 4, cv2.BORDER_CONSTANT, value=(255, 255, 255))
            cv2.putText(t, name, (6, 21), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 1, cv2.LINE_AA)
            tiles.append(t)
        while len(tiles) % 3:
            tiles.append(np.full_like(tiles[0], 255))
        grid = np.vstack([np.hstack(tiles[i:i + 3]) for i in range(0, len(tiles), 3)])
        cv2.imwrite(a.sheet, grid)
        print(f"wrote {a.sheet} (crop shown at 2x with nearest, so you see pixels)")
    if a.out:
        os.makedirs(a.out, exist_ok=True)
        full = ms[best](cv2.imread(a.image, cv2.IMREAD_COLOR))
        p = os.path.join(a.out, f"x{a.scale}-{best}.png")
        cv2.imwrite(p, full)
        H, W = full.shape[:2]
        print(f"wrote {p} {W}x{H}; at 300 ppi that prints {W / 300 * 2.54:.1f} x {H / 300 * 2.54:.1f} cm")


if __name__ == "__main__":
    main()

Test pictures (no real face)

I don't test on customer pictures or on anyone's face. This draws a synthetic 3:4 "Malfoid-look" card from shapes: dark corridor, candle glow, platinum hair, white shirt, green-and-silver tie, dark robe. --texture adds thin hair strands and fabric grain so there is fine detail to lose:

#!/usr/bin/env python3
"""Draw a synthetic 3:4 'Malfoid-style' test portrait (no real face, no AI).

Shapes only: dark corridor, candle glow, platinum hair, an oval face,
white shirt, green-and-silver striped tie, dark robe. --texture adds thin
hair strands and fabric grain, so resampling and line-art scripts have some
fine detail to chew on. No real face, no AI, nobody's photo.

    python make_test_portrait.py out.png [--seed 1] [--size 768x1024] [--texture]
"""
import argparse
import random
from PIL import Image, ImageDraw, ImageFilter


def face(d, s, fw, skin):
    d.ellipse([int((264 - fw) * s), int(250 * s), int((504 + fw) * s), int(560 * s)], fill=skin)  # face
    for ex in (330, 438):                                                  # eyes
        d.ellipse([int((ex - 16) * s), int(380 * s), int((ex + 16) * s), int(398 * s)], fill=(250, 250, 250))
        d.ellipse([int((ex - 7) * s), int(382 * s), int((ex + 7) * s), int(396 * s)], fill=(110, 130, 120))
    d.arc([int(340 * s), int(450 * s), int(428 * s), int(500 * s)], 20, 160, fill=(150, 80, 80), width=max(2, int(4 * s)))


def portrait(w=768, h=1024, seed=1, texture=False):
    rnd = random.Random(seed)
    img = Image.new("RGB", (w, h))
    px = img.load()
    for y in range(h):                      # corridor: dark warm gradient
        for x in range(w):
            v = 18 + int(30 * (1 - abs(x - w / 2) / (w / 2)) * (1 - y / h))
            px[x, y] = (v + 10, v + 4, v)
    glow = Image.new("RGB", (w, h), (0, 0, 0))
    g = ImageDraw.Draw(glow)
    for _ in range(4):                      # candle glows
        cx, cy, r = rnd.randint(40, w - 40), rnd.randint(60, h // 2), rnd.randint(25, 60)
        g.ellipse([cx - r, cy - r, cx + r, cy + r], fill=(255, 150, 40))
    glow = glow.filter(ImageFilter.GaussianBlur(28))
    img = Image.blend(img, Image.composite(glow, img, glow.convert("L")), 0.6)
    d = ImageDraw.Draw(img)
    s = w / 768
    skin, fw = (222, 182, 156), 0                # seed 1 = the default sitter
    if seed != 1:                                # other seeds: another sitter
        skin = tuple(max(0, c - rnd.randint(0, 70)) for c in skin)
        fw = rnd.randint(-30, 30)
    d.polygon([(int(60 * s), h), (int(130 * s), int(640 * s)), (int(638 * s), int(640 * s)),
               (int(708 * s), h)], fill=(22, 24, 30))                      # robe
    d.polygon([(int(300 * s), int(640 * s)), (int(468 * s), int(640 * s)),
               (int(430 * s), h), (int(338 * s), h)], fill=(240, 240, 236))  # shirt
    tie = [(int(364 * s), int(660 * s)), (int(404 * s), int(660 * s)),
           (int(420 * s), h), (int(348 * s), h)]
    d.polygon(tie, fill=(26, 92, 52))                                      # tie green
    for i in range(6):                                                     # silver stripes
        y0 = int((690 + i * 55) * s)
        d.polygon([(int(340 * s), y0), (int(430 * s), y0 - int(30 * s)),
                   (int(430 * s), y0 - int(14 * s)), (int(340 * s), y0 + int(16 * s))],
                  fill=(176, 180, 184))
    d.polygon(tie, outline=(26, 92, 52))
    d.ellipse([int(170 * s), int(150 * s), int(598 * s), int(760 * s)], fill=(226, 222, 206))  # hair
    face(d, s, fw, skin)
    if texture:
        tr = random.Random(seed * 7919)
        for _ in range(260):                                               # hair strands
            x0 = tr.uniform(180, 588) * s
            side = -1 if x0 < 384 * s else 1
            pts = [(x0, 160 * s)]
            for k in range(1, 9):
                pts.append((x0 + side * k * tr.uniform(1, 5) * s, (160 + k * 70) * s))
            c = tr.randint(170, 250)
            d.line([(int(a), int(b)) for a, b in pts], fill=(c, c - 4, c - 22), width=1)
        face(d, s, fw, skin)                                               # face back on top
        px = img.load()
        for _ in range(int(w * h * 0.05)):                                 # fabric grain on the robe
            x, y = tr.randrange(w), tr.randrange(int(700 * s), h)
            r, g, b = px[x, y]
            if r < 40 and g < 40:
                v = tr.randint(-12, 12)
                px[x, y] = (max(0, r + v), max(0, g + v), max(0, b + v))
    return img


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("out")
    ap.add_argument("--seed", type=int, default=1)
    ap.add_argument("--size", default="768x1024")
    ap.add_argument("--texture", action="store_true")
    a = ap.parse_args()
    w, h = map(int, a.size.lower().split("x"))
    portrait(w, h, a.seed, a.texture).save(a.out)
    print(f"wrote {a.out} {w}x{h}")

python make_test_portrait.py tex.png --texture
python make_test_portrait.py flat.png
python upscale_compare.py tex.png --scale 2 --models models --sheet sheet.png --crop 0.22,0.30,0.30,0.20
python upscale_compare.py tex.png --scale 4 --models models
python upscale_compare.py flat.png --scale 2 --models models

Results (verbatim, OpenCV 5.0, CPU)

Textured card, 2x:

method              PSNR dB    SSIM  ringing
nearest               23.32  0.8806     0.00
fsrcnn                23.23  0.8742     0.35
bicubic               23.14  0.8696     0.91
lanczos4+unsharp      22.95  0.8692     2.46
lanczos4              23.02  0.8670     1.21
bilinear              22.94  0.8583     0.00
best by SSIM (excluding nearest): fsrcnn

Textured card, 4x:

method              PSNR dB    SSIM  ringing
nearest               21.39  0.8036     0.43
fsrcnn                21.54  0.7995     0.47
bicubic               21.43  0.7956     0.56
bilinear              21.35  0.7931     0.64
lanczos4              21.39  0.7923     0.56
lanczos4+unsharp      21.39  0.7921     0.63

Flat card (clean shapes, no strands), 2x:

method              PSNR dB    SSIM  ringing
fsrcnn                36.65  0.9914     1.25
bicubic               33.88  0.9894     3.82
bilinear              33.08  0.9882     0.00
nearest               32.53  0.9882     0.00
lanczos4              33.92  0.9880     4.07
lanczos4+unsharp      34.21  0.9859     7.02

What the numbers say

FSRCNN wins where there are real edges. On the flat card it's almost 3 dB ahead of bicubic with a third of the ringing. Face outline, eyes, tie stripes: that's the kind of content a portrait is mostly made of.
"Lanczos + sharpen" is the halo machine. It has the worst ringing in every run (7.02 on the flat card). The "crisp" look people like in a preview turns into a light outline around dark hair once it's printed.
Nearest neighbour "winning" SSIM on hair texture is a metric trap. On 1-pixel random strands, blocky pixels keep local contrast, and SSIM rewards contrast. Look at sheet.png: the nearest crop is visibly stair-stepped. That's why the script never auto-picks it, and why you should always look at the crop sheet, not just the table.
At 4x, nothing helps much. All six methods land within 0.2 dB. Detail that was never in the 1K file can't be recovered by a 40 KB model, and a big generative upscaler that does add detail is drawing new hair, not recovering yours. For a likeness portrait that's a real trade-off: it can change the face.

A practical recipe

Phone, social post, profile picture: use the file as it is. 1K is plenty there.
A print up to about 13 × 17 cm, or an A4 seen from a distance: run the script, take its 2x pick (--out out/), and print at 300 ppi.
Anything bigger: accept the softness, or choose a poster style that hides it (a halftone, a frame with a wide border). Don't stack 4x upscales and a sharpen filter.
Before you print, check the face and hands at 100% in the enlarged file. Upscalers amplify small artefacts as faithfully as they amplify edges.

Where the portrait comes from

On malfoidai.com a portrait is $4.99 paid once (no account), from your photo or without one, or 2 credits from a one-time pack: $13.99 for 30 credits, $35.99 for 100, $59.99 for 200 (packs need sign-in, don't renew, no subscription). Prices as shown on the pricing page on November 9, 2026. The studio doesn't add a watermark, so there's nothing to "clean up" before enlarging. The portrait is unofficial fan art: not affiliated with the books, films, author or studios, and a portrait made from a photo is not a verified likeness of that person.

Code: MIT. Test images are synthetic; no real face or generated result is used or shown.

What Photo Works Best for a Hit the Road Dude AI Video? A Python Pre-Upload Check for Format, Size, Blur and Exposure

Peiguan — Mon, 09 Nov 2026 07:37:00 +0000

"Which photo should I use?" is the question that decides most AI remakes of the Hit the Road Dude meme, also searched as the State Property meme. One photo goes in, and a 15-second clip comes out. In it, your face (or your dog's) sits at the open window of a white pickup, repeats "State?" and sends the visitor off. The model only knows what's in that one photo. A soft, dark or sideways upload shows up in the result.

I run hittheroaddude.app, one of the generators for this clip. This post covers the small script I use before uploading a photo anywhere. It checks the hard limits first, then flags the soft problems that usually lead to a weak result. It's plain Python with Pillow and NumPy, and I ran it on the synthetic test images below.

The hard rules vs the heuristics

Some rules are the site's, and some are mine. They're different kinds of thing, so the script keeps them apart.

Hard limits (from the driver photo guide, checked 2026-11-09):

JPEG, PNG or WebP
up to 10 MB
one clear photo of one adult or one pet, face visible

Heuristics (my own thresholds, not rules):

short side under 512 px: faces get mushy
low Laplacian variance: the photo is probably soft or motion-blurred
mean brightness far from the middle: too dark or washed out
lots of pure black or pure white pixels: detail is clipped
an EXIF orientation tag: the pixels are stored sideways, and some pipelines ignore the tag

The script can't check "one subject" or "face visible". Those need eyes, or a face detector, which this post skips on purpose. Pets break most face detectors anyway.

The checker

#!/usr/bin/env python3
"""Pre-upload check for a Hit the Road Dude driver photo.

Usage: python3 photo_check.py photo.jpg [more.jpg ...]
Needs: pip install pillow numpy
Hard limits come from the site (JPEG, PNG or WebP, up to 10 MB).
Everything else is a heuristic warning, not a rule.
"""
import os, sys
import numpy as np
from PIL import Image, ImageOps

MAX_BYTES = 10 * 1024 * 1024          # "up to 10 MB"
ALLOWED = {"JPEG", "PNG", "WEBP"}      # "JPEG, PNG or WebP"
MIN_SHORT_SIDE = 512                   # heuristic: below this, faces get mushy
BLUR_MIN = 60.0                        # heuristic: Laplacian variance on 1024 px
DARK, BRIGHT = 60, 200                 # heuristic: mean luma range (0-255)
CLIP_MAX = 0.08                        # heuristic: >8% pure black/white pixels

def laplacian_var(gray):
    g = gray.astype(np.float32)
    lap = (g[1:-1, :-2] + g[1:-1, 2:] + g[:-2, 1:-1] + g[2:, 1:-1]
           - 4 * g[1:-1, 1:-1])
    return float(lap.var())

def check(path):
    errors, warnings, info = [], [], {}
    size = os.path.getsize(path)
    info["bytes"] = size
    if size > MAX_BYTES:
        errors.append(f"file is {size / 1048576:.1f} MB, limit is 10 MB")
    try:
        im = Image.open(path)
        fmt = im.format
    except Exception as e:
        return {"path": path, "errors": [f"not an image Pillow can read: {e}"],
                "warnings": [], "info": info}
    info["format"] = fmt
    if fmt not in ALLOWED:
        errors.append(f"format {fmt}; upload JPEG, PNG or WebP")
    orient = im.getexif().get(0x0112, 1)
    if orient not in (1, None):
        warnings.append(f"EXIF orientation {orient}: the raw pixels are rotated; "
                        "re-save upright if the preview looks sideways")
    im = ImageOps.exif_transpose(im)
    w, h = im.size
    info["size"] = f"{w}x{h}"
    if min(w, h) < MIN_SHORT_SIDE:
        warnings.append(f"short side {min(w, h)} px is small; use the original photo")
    if getattr(im, "n_frames", 1) > 1:
        warnings.append("animated file: only one frame will matter")
    gray = im.convert("L")
    gray.thumbnail((1024, 1024))
    a = np.asarray(gray)
    sharp = laplacian_var(a)
    mean = float(a.mean())
    clipped = float(((a <= 3) | (a >= 252)).mean())
    info.update(sharpness=round(sharp, 1), mean_luma=round(mean, 1),
                clipped=round(clipped, 3))
    if sharp < BLUR_MIN:
        warnings.append(f"looks soft (sharpness {sharp:.0f} < {BLUR_MIN:.0f})")
    if mean < DARK:
        warnings.append(f"looks dark (mean {mean:.0f})")
    elif mean > BRIGHT:
        warnings.append(f"looks washed out (mean {mean:.0f})")
    if clipped > CLIP_MAX:
        warnings.append(f"{clipped:.0%} of pixels are pure black or white")
    return {"path": path, "errors": errors, "warnings": warnings, "info": info}

if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.exit(__doc__)
    worst = 0
    for p in sys.argv[1:]:
        r = check(p)
        status = "FAIL" if r["errors"] else ("WARN" if r["warnings"] else "OK")
        worst = max(worst, {"OK": 0, "WARN": 1, "FAIL": 2}[status])
        print(f"{status:4}  {os.path.basename(p)}  {r['info']}")
        for m in r["errors"]:
            print(f"      error: {m}")
        for m in r["warnings"]:
            print(f"      warn:  {m}")
    sys.exit(worst)

A few implementation notes:

ImageOps.exif_transpose before measuring. Phones often save a portrait shot as landscape pixels plus an "orientation = 6" tag. If you measure or crop before applying it, you're working on a sideways image.
Sharpness on a 1024 px thumbnail. Laplacian variance depends on resolution, so the image is downsized first. That keeps the threshold comparable between a 12 MP phone photo and a 1 MP screenshot.
The Laplacian is four NumPy slices. There's no OpenCV dependency. It's the classic 3×3 kernel (0 1 0 / 1 -4 1 / 0 1 0), written as shifted arrays.
Exit codes: 0 means everything passed, 1 means warnings only, and 2 means a hard limit failed. That makes it easy to use in a shell loop or a pre-commit-style script.

Test images

No real faces were used here. The generator script draws a head-shaped ellipse, shoulders and random line texture, then saves the variants that typically go wrong:

#!/usr/bin/env python3
"""Make synthetic test photos (no real faces) for photo_check.py."""
import os
import numpy as np
from PIL import Image, ImageDraw, ImageFilter

os.makedirs("samples", exist_ok=True)
rng = np.random.default_rng(7)

def portrait(w=1200, h=1600):
    im = Image.new("RGB", (w, h), (120, 150, 170))
    d = ImageDraw.Draw(im)
    d.ellipse((w*0.3, h*0.2, w*0.7, h*0.55), fill=(205, 170, 140))   # "head"
    d.rectangle((w*0.2, h*0.6, w*0.8, h), fill=(40, 60, 90))           # "shoulders"
    for _ in range(400):                                                # texture
        x, y = rng.integers(0, w), rng.integers(0, h)
        c = tuple(int(v) for v in rng.integers(0, 255, 3))
        d.line((x, y, x + rng.integers(-30, 30), y + rng.integers(-30, 30)), fill=c, width=2)
    return im

base = portrait()
base.save("samples/good.jpg", quality=90)
base.filter(ImageFilter.GaussianBlur(6)).save("samples/blurry.jpg", quality=90)
Image.eval(base, lambda v: v // 5).save("samples/dark.jpg", quality=90)
base.resize((300, 400)).save("samples/tiny.png")
base.save("samples/still.gif")
# sideways phone photo: pixels stored rotated, EXIF says "rotate 90 CW"
rot = base.rotate(90, expand=True)
exif = Image.Exif(); exif[0x0112] = 6
rot.save("samples/sideways.jpg", quality=90, exif=exif)
# oversized: 3000x4000 noise PNG is far above 10 MB
Image.fromarray(rng.integers(0, 255, (4000, 3000, 3), dtype=np.uint8)).save("samples/huge.png")
for f in sorted(os.listdir("samples")):
    print(f, os.path.getsize(f"samples/{f}"))

Output from python3 make_samples.py && python3 photo_check.py samples/* (lightly trimmed):

WARN  blurry.jpg   sharpness 0.5  -> looks soft (sharpness 1 < 60)
WARN  dark.jpg     sharpness 6.9, mean_luma 25.3 -> looks soft, looks dark (mean 25)
OK    good.jpg     1200x1600, sharpness 164.8, mean_luma 126.1
FAIL  huge.png     error: file is 34.4 MB, limit is 10 MB
WARN  sideways.jpg EXIF orientation 6: the raw pixels are rotated
FAIL  still.gif    error: format GIF; upload JPEG, PNG or WebP
WARN  tiny.png     short side 300 px is small; use the original photo

One result is worth explaining. The dark photo is also flagged as soft, even though it's the same drawing as good.jpg. Laplacian variance measures edge contrast, so darkening an image lowers it. Fix exposure first, then re-check sharpness. Otherwise you'll go hunting for a sharper photo you don't need.

Fixing what's fixable

Format, size and orientation can be fixed in code. Blur and bad light can't, so use a different photo for those. This helper bakes the rotation into the pixels, caps the long side at 2048 px and re-saves as JPEG:

#!/usr/bin/env python3
"""Re-save a photo upright as a JPEG under 10 MB (long side <= 2048 px).

Usage: python3 fix_photo.py in.ext out.jpg
"""
import os, sys
from PIL import Image, ImageOps

src, dst = sys.argv[1], sys.argv[2]
im = ImageOps.exif_transpose(Image.open(src)).convert("RGB")  # bake in rotation
im.thumbnail((2048, 2048), Image.LANCZOS)                     # never upscales
for q in (92, 85, 78, 70):
    im.save(dst, "JPEG", quality=q, optimize=True)            # no EXIF copied
    if os.path.getsize(dst) <= 10 * 1024 * 1024:
        break
print(dst, im.size, os.path.getsize(dst), "bytes, quality", q)

I ran the fixer on the three failing files, then re-checked them:

samples/fixed-huge.jpg (1536, 2048) 2136089 bytes, quality 92
samples/fixed-sideways.jpg (1200, 1600) 92914 bytes, quality 92
samples/fixed-still.jpg (1200, 1600) 99131 bytes, quality 92
OK    fixed-huge.jpg ...
OK    fixed-sideways.jpg ...
OK    fixed-still.jpg ...

Side effect: Pillow doesn't copy EXIF unless you pass it, so the re-saved JPEG also drops GPS and camera metadata. For a photo you're about to upload to any web service, that's usually what you want.

What the numbers can't tell you

The checks above are necessary but not sufficient. Before uploading, also look at the photo yourself:

One subject. In a group photo the generator may pick the wrong face. Crop down to one person or one pet.
Face and shoulders, not a scene. A wide shot of you next to a truck is the output look, not a useful input. The guide puts it as: "A wide shot of a truck is what the result looks like, not a useful upload."
Your right to use it. Use yourself, an adult who agreed, or your own pet. Don't use a photo just because it's online (acceptable use).
Pets: eyes, nose and mouth visible, roughly facing the camera. The dog and cat guide has a table of photos that do and don't work.

Where the photo goes next

On my studio, the photo is the only creative input. There's no prompt box, and the scene and lines are saved in a preset. You pick 480p or 720p, see the total on the button and pay before anything is generated. The live pricing page on 2026-11-09 listed $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits) per clip. Signed-in accounts can also buy one-time credit packs. There's no subscription and no free clip, so a 30-second photo check costs less than a wasted run.

If you're ready, the create page takes the file directly. If the result still looks off, the help page points out that "Most problems come from the photo." That's why this script exists.

Does the Red Banner Flicker or Change Colour in My Bama Bound AI Clip? Tracking Banner Hue Frame by Frame in Python

Peiguan — Mon, 09 Nov 2026 07:21:00 +0000

Checked November 9, 2026 (15:00 CST, UTC+8) against the live pages linked below. I build bamabound.app, an independent studio that turns one photo of one person into a vertical clip of them holding a red I'M BAMA BOUND banner. The script in this post was written for it and tested on synthetic clips (a drawn red box on a green field), not real people.

The joke in the Bama Bound meme is the sign: a red banner with white capitals reading I'M BAMA BOUND, held up in a sunny field (FAQ). When you generate that clip with an image-to-video model, the part people notice first is the banner. If its red shifts to orange for three frames, or slowly turns pink over eight seconds, the clip looks "AI" in a way a slightly different face does not.

So the question I get, and that people ask AI assistants, is roughly: "Why does the banner in my Bama Bound video flicker?" and "How can I check a clip for that before I post it?" This post answers the second question with about 100 lines of Python and NumPy. It answers the first one briefly.

Why a generated banner can flicker

An image-to-video model doesn't keep a "banner object" with a fixed colour. It predicts each frame, or a block of frames, from noise, guided by your photo and by whatever conditions the pipeline adds (on this site that is a preset with a reference clip; you don't write a prompt). Large flat areas of a saturated colour are where you see the effects of that:

Temporal chunking. Many video models generate in windows of frames. Where two windows meet, colour can jump a little.
Lighting changes. The model is also predicting sunlight and shadows on the cloth. A cloud-like shading change reads as a hue shift on a flat red.
Encoding. After generation the frames are compressed to H.264. Chroma is stored at quarter resolution (4:2:0), so thin white letters on red bleed slightly. That is not flicker, but it does move the average colour a bit.

You can't fix any of that after the fact without regenerating or grading by hand. You can measure it, so you know whether you're looking at a real problem or your phone's auto-brightness.

What we measure

For each frame:

Downscale to 160 px wide (enough for a banner, fast to process).
Convert RGB to HSV and keep pixels that are saturated, bright and within 40° of pure red. The window is wide on purpose: if the banner drifts toward orange, it should stay inside the mask so we can see the drift instead of losing the banner.
Record the mask's area share and its circular mean hue. Hue is an angle, so 355° and 5° are 10° apart, not 350°. The mean has to use sin/cos.

Across the clip we flag three things:

Flag	Meaning	Default
`flicker`	hue jumps more than N degrees between consecutive frames	8°
`missing`	banner area falls below half the clip's median area (occluded, cut, or out of frame)	0.5 × median
`drift`	the median hue of the last second differs from the first second	6°

The thresholds are starting points I picked on synthetic clips. Treat them as knobs, not standards.

The script

#!/usr/bin/env python3
"""Track the red banner's colour frame by frame in a vertical clip.

For every decoded frame (downscaled to 160 px wide) we build a "banner red" mask in HSV,
then record the mask's area share and its circular-mean hue. We flag:
  * flicker: hue jumps more than --jump degrees between consecutive frames
  * missing: banner area drops below --min-area of the clip's median area
  * drift:   median hue of the last second differs from the first second by > --drift deg
Usage: banner_hue.py clip.mp4 [--csv out.csv]   exit 0 = clean, 1 = flagged, 2 = error
Needs ffmpeg/ffprobe on PATH and numpy.
"""
import argparse, csv, json, subprocess, sys
import numpy as np

W = 160

def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                          "stream=width,height,avg_frame_rate", "-of", "json", path],
                         capture_output=True, text=True, check=True).stdout
    s = json.loads(out)["streams"][0]
    num, den = s["avg_frame_rate"].split("/")
    return s["width"], s["height"], float(num) / float(den)

def frames(path, w, h):
    hh = int(round(h * W / w / 2)) * 2
    p = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-vf", f"scale={W}:{hh}",
                          "-f", "rawvideo", "-pix_fmt", "rgb24", "-"], stdout=subprocess.PIPE)
    size = W * hh * 3
    while True:
        buf = p.stdout.read(size)
        if len(buf) < size:
            break
        yield np.frombuffer(buf, np.uint8).reshape(hh, W, 3)
    p.wait()

def hsv(rgb):
    x = rgb.astype(np.float32) / 255.0
    r, g, b = x[..., 0], x[..., 1], x[..., 2]
    mx, mn = x.max(-1), x.min(-1)
    d = mx - mn + 1e-6
    h = np.where(mx == r, ((g - b) / d) % 6, np.where(mx == g, (b - r) / d + 2, (r - g) / d + 4)) * 60
    s = np.where(mx > 0, (mx - mn) / (mx + 1e-6), 0)
    return h, s, mx

def banner_stats(rgb):
    h, s, v = hsv(rgb)
    # "red-ish": hue within 40 deg of 0 (covers crimson..orange so a shift stays inside the mask)
    dist = np.minimum(h, 360 - h)
    mask = (dist < 40) & (s > 0.5) & (v > 0.35)
    area = float(mask.mean())
    if mask.sum() < 20:
        return area, None
    a = np.deg2rad(h[mask])
    hue = float(np.rad2deg(np.arctan2(np.sin(a).mean(), np.cos(a).mean()))) % 360
    return area, hue

def circ_median(hs):
    # hues sit around 0/360, so take the median of offsets from the first value
    ref = hs[0]
    off = [((x - ref + 180) % 360) - 180 for x in hs]
    return (ref + float(np.median(off))) % 360

def hue_diff(a, b):
    d = abs(a - b) % 360
    return min(d, 360 - d)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("clip"); ap.add_argument("--csv")
    ap.add_argument("--jump", type=float, default=8.0)
    ap.add_argument("--drift", type=float, default=6.0)
    ap.add_argument("--min-area", type=float, default=0.5)
    a = ap.parse_args()
    try:
        w, h, fps = probe(a.clip)
    except Exception as e:
        print(f"cannot read {a.clip}: {e}", file=sys.stderr); return 2
    rows = [(i / fps, *banner_stats(f)) for i, f in enumerate(frames(a.clip, w, h))]
    if not rows:
        print("no frames decoded", file=sys.stderr); return 2
    if a.csv:
        with open(a.csv, "w", newline="") as f:
            cw = csv.writer(f); cw.writerow(["t", "area", "hue"])
            cw.writerows([(f"{t:.3f}", f"{ar:.4f}", "" if hu is None else f"{hu:.1f}") for t, ar, hu in rows])
    med_area = float(np.median([r[1] for r in rows]))
    flags = []
    for (t0, _, h0), (t1, ar1, h1) in zip(rows, rows[1:]):
        if h0 is not None and h1 is not None and hue_diff(h0, h1) > a.jump:
            flags.append({"t": round(t1, 3), "kind": "flicker", "detail": f"hue {h0:.1f} -> {h1:.1f}"})
        if med_area > 0 and ar1 < a.min_area * med_area:
            flags.append({"t": round(t1, 3), "kind": "missing", "detail": f"area {ar1:.3f} vs median {med_area:.3f}"})
    n = max(1, int(round(fps)))
    first = [r[2] for r in rows[:n] if r[2] is not None]
    last = [r[2] for r in rows[-n:] if r[2] is not None]
    drift = hue_diff(circ_median(first), circ_median(last)) if first and last else None
    if drift is not None and drift > a.drift:
        flags.append({"t": round(rows[-1][0], 3), "kind": "drift", "detail": f"{drift:.1f} deg first->last second"})
    hues = [r[2] for r in rows if r[2] is not None]
    print(json.dumps({"clip": a.clip, "frames": len(rows), "fps": round(fps, 3),
                      "median_area": round(med_area, 4),
                      "median_hue": None if not hues else round(circ_median(hues), 1),
                      "drift_deg": None if drift is None else round(drift, 1),
                      "flags": flags}, indent=2))
    return 1 if flags else 0

if __name__ == "__main__":
    sys.exit(main())

It reads frames from an ffmpeg pipe (-f rawvideo -pix_fmt rgb24), so it handles anything ffmpeg can decode. It needs no OpenCV, only NumPy.

Test it on synthetic clips first

Never tune a checker on the clip you're worried about. Make clips where you know the answer. This script draws a red box with white text on a sky-and-grass background, with a 440 Hz tone. There are three modes: steady, a 0.2-second orange flash at 4 s, and a slow 2°/s hue rotation.

#!/usr/bin/env bash
# Synthetic stand-in for a vertical banner clip: sky, green field, a red banner with
# white text, a 440 Hz tone. No people, no real footage.
#   ./make_banner_test_clip.sh out.mp4 [steady|flicker|drift]
#   env BX, BY move the banner (default 60, 330)
#   flicker = banner turns orange at 4.0-4.2 s; drift = whole frame hue rotates 2 deg/s
set -euo pipefail
out=${1:-banner_test.mp4}; mode=${2:-steady}
FONT=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf
banner="drawbox=x=${BX:-60}:y=${BY:-330}:w=360:h=150:color=0xC8102E:t=fill"
[ "$mode" = flicker ] && banner="$banner,drawbox=x=${BX:-60}:y=${BY:-330}:w=360:h=150:color=0xF07820:t=fill:enable='between(t,4,4.2)'"
post=""; [ "$mode" = drift ] && post=",hue=h=2*t"
ffmpeg -v error -y -f lavfi -i "color=c=0x3A8A3A:s=480x854:r=30:d=8" \
  -f lavfi -i "sine=frequency=440:duration=8:sample_rate=48000" \
  -filter_complex "[0:v]drawbox=x=0:y=0:w=iw:h=300:color=0x87CEEB:t=fill,${banner},drawtext=fontfile=${FONT}:text='TEST BANNER':fontcolor=white:fontsize=40:x=${BX:-60}+(360-text_w)/2:y=${BY:-330}+55${post},format=yuv420p[v]" \
  -map "[v]" -map 1:a -c:v libx264 -preset veryfast -crf 20 -c:a aac -b:a 128k -shortest "$out"
echo "wrote $out ($mode)"

Results on my box (ffmpeg 7.1, NumPy, 480×854 at 30 fps, 8 s):

$ ./make_banner_test_clip.sh steady.mp4
$ ./make_banner_test_clip.sh flicker.mp4 flicker
$ ./make_banner_test_clip.sh drift.mp4 drift
$ python3 banner_hue.py steady.mp4   -> median_hue 350.4, drift 0.0, flags []                       exit 0
$ python3 banner_hue.py flicker.mp4  -> flags: flicker at 4.0 s (hue -> 25.5), flicker at 4.233 s    exit 1
$ python3 banner_hue.py drift.mp4    -> drift 16.2 deg first->last second                            exit 1

Things worth noticing:

The steady clip's hue is 350°, not 0°. 0xC8102E is a crimson, slightly toward magenta. That is why the hue needs a circular mean and a circular median. A plain np.median over values near 0/360 gives nonsense.
The flicker is caught at both edges (into orange and back), 7 frames apart. That matches the 0.2 s at 30 fps.
Drift is caught only by the first-vs-last comparison. Frame to frame, 2°/s is 0.07° per frame, far under the flicker threshold. You need both checks.

Pass --csv hue.csv to get t, area, hue per frame and plot it in a spreadsheet. A real problem looks like a spike or a ramp. Noise looks like fuzz of ±1–2°.

Reading results on a real clip

Some practical notes for real clips:

A hand or arm crossing the banner shows up as missing (area drops), sometimes with a small hue wobble. That's motion, not a defect.
Hue fuzz of ±2–3° in sunlit scenes is normal. If you see that, raise --jump to 10 before you worry.
If the whole picture warms up (grass and sky shift too), the cause is probably the model's lighting, or a filter you applied when editing. Compare against the untouched download.
Check the file you'll post, not just the original. A TikTok-style edit with a colour filter will "drift" on purpose.

If the original download flickers badly, regenerating is the only real fix. On bamabound.app, that is a new paid generation. A clip that looks different from your photo is not by itself a failed order, while a paid generation that never arrived goes to refund review (help page). Resolution matters less than you'd think for flicker. Higher resolutions give the letters more pixels, not more temporal stability. For reference, today's prices are $7.98 for 480p, $9.98 for 720p, $16.98 for 1080p and $24.98 for 4k per generation, with buyer tax added at checkout.

Why not just eyeball it?

You should eyeball it too. But a 3-frame flash at 30 fps lasts 100 ms. On a phone screen at arm's length, most people won't see it until the third replay, and then they can't stop seeing it. Running a script takes a few seconds and gives you a timestamp you can scrub to.

The same approach works for any meme whose identity is one flat, saturated object: a red banner, a yellow jersey, a blue sign. Change the hue window and you have a "did the AI keep the colour" check.

Related: what the clip is and isn't (FAQ), how to pick the photo (guides).

Who's Who in Our Tiny Desk AI Clip? Sliding Name Cards Into the Last Seconds With ffmpeg overlay (Python, Tested)

Peiguan — Mon, 09 Nov 2026 06:58:12 +0000

Checked November 9, 2026 (12:00 CST, UTC+8) against the live pages linked below. I build tinydeskoutstanding.video, an independent studio that turns one to five photos into a 15-second vertical parody of the "Outstanding" Tiny Desk meme. The script was written for this post and tested on synthetic clips and solid-colour stand-in photos, not real faces.

Once a group clip of the Tiny Desk meme lands in a chat, the first reply is usually a question: "wait, who's on sax?" In the wide band shot the faces are small, and by the time people work out who is who, the clip has ended.

One fix that works well is a reveal: in the last few seconds, a card with each person's original photo and name slides in next to the band. This post builds that reveal with one ffmpeg filter graph, generated by about 80 lines of Python, plus a checker that proves the cards land where they should.

What the clip gives you

From the site's own pages:

Every clip is "15-second vertical video, 9:16", at 480p, 720p, 1080p or 4k, with newly generated sound (FAQ).
The stage has five faces: "lead, sax, keys, back left, and back right", and "a face you leave empty keeps the performer already in the scene" (band and guest slots).
The price doesn't change with the number of faces. Today a clip is $9.98 at 480p, $12.98 at 720p, $24.98 at 1080p or $39.98 at 4k (pricing).

So you get one to five cards to show, and a frame that may be anywhere from about 480 to 4k pixels wide. The script reads the real size with ffprobe and does not assume any of it.

The input: a tiny cast file

{"reveal_at": 11.5,
 "cards": [
  {"spot": "lead", "name": "Maya", "photo": "maya.jpg"},
  {"spot": "sax", "name": "Jordan", "photo": "jordan.jpg"},
  {"spot": "back left", "name": "Biscuit", "photo": "biscuit.jpg"}
 ]}

reveal_at is in seconds. Pick it by watching your own clip: the cards should arrive after the joke has landed and before it ends. Use the same photos you uploaded to the studio, so people see the face that went into each spot.

The filter graph, one piece at a time

For each card:

scale=...:force_original_aspect_ratio=increase,crop=... fills a 3:4 box with the photo and centres it, so a landscape photo is cropped, not squashed.
pad adds a white border and a strip at the bottom; drawtext writes "Maya · lead" into the strip.
overlay puts it on the video with an x expression that changes every frame:

x = if(lt(t, start), W, max(W - w - margin, W - (t - start) * speed))

Before start, the card sits just off the right edge (x = W, invisible). After start, it moves left at speed pixels per second until it reaches its resting place, then max() holds it there. Each card starts 0.35 s after the previous one, which gives the staggered "one, two, three" feel. Overlays are chained, so the graph is [0:v][c0]overlay[v0]; [v0][c1]overlay[v1]; ....

Two details that bite:

Commas inside expressions must be escaped (\,) inside a filter graph, or ffmpeg reads them as filter separators.
eval=frame makes overlay re-evaluate x on every frame. Without it the card would be placed once and never move.

Cards start at a quarter of the frame width and shrink until the whole stack fits the height, so five cards on a 9:16 frame still fit.

The script

#!/usr/bin/env python3
"""Slide a 'who's who' card for each cast member into the last seconds of a clip.

usage: python3 reveal.py clip.mp4 cast.json out.mp4

cast.json: {"reveal_at": 11.5, "cards": [{"spot": "lead", "name": "Maya", "photo": "maya.jpg"}, ...]}
Cards stack down the right edge, each sliding in 0.35 s after the previous one.
Audio is copied untouched; video is re-encoded with libx264 (CRF 18).
"""
import json, os, shutil, subprocess, sys

FONTS = ["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
         "/Library/Fonts/Arial Bold.ttf", "C:/Windows/Fonts/arialbd.ttf"]

def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0",
                          "-show_entries", "stream=width,height:format=duration",
                          "-of", "json", path], capture_output=True, text=True, check=True).stdout
    j = json.loads(out)
    return j["streams"][0]["width"], j["streams"][0]["height"], float(j["format"]["duration"])

def esc(text):  # drawtext text= escaping
    return text.replace("\\", "\\\\").replace(":", "\\:").replace("'", "\u2019")

def layout(W, H, n):
    """Card width, photo height, label height, gap, margin, top for n cards."""
    gap, margin = max(4, H // 120), max(6, W // 40)
    cw = W // 4                      # start at a quarter of the frame width
    while cw > 40:
        ph, label = cw * 4 // 3, max(14, cw // 7)
        top = (H - n * (ph + label) - (n - 1) * gap) // 2
        if top >= margin:
            return cw, ph, label, gap, margin, top
        cw -= 2                      # shrink until the stack fits
    sys.exit("frame too small for this many cards")

def build(W, H, dur, cast, font):
    t0 = float(cast["reveal_at"])
    cards = cast["cards"]
    if not 1 <= len(cards) <= 5:
        sys.exit("1 to 5 cards (the stage has five spots)")
    if not 0 < t0 < dur - 0.5:
        sys.exit(f"reveal_at must be inside the clip (duration {dur:.2f} s)")
    cw, ph, label, gap, margin, top = layout(W, H, len(cards))
    ch = ph + label
    parts, last = [], "[0:v]"
    for i, c in enumerate(cards):
        txt = f"{c['name']} \u00b7 {c['spot']}"
        card = (f"[{i+1}:v]scale={cw-4}:{ph-4}:force_original_aspect_ratio=increase,"
                f"crop={cw-4}:{ph-4},pad={cw}:{ch}:2:2:white")
        if font:
            card += (f",drawtext=fontfile='{font}':text='{esc(txt)}':fontsize={int(label*0.62)}:"
                     f"fontcolor=black:x=(w-tw)/2:y={ph}+({label}-th)/2")
        parts.append(card + f"[c{i}]")
        start = t0 + 0.35 * i
        x = f"if(lt(t\\,{start:.3f})\\,W\\,max(W-w-{margin}\\,W-(t-{start:.3f})*{W*3}))"
        y = top + i * (ch + gap)
        out = f"[v{i}]"
        parts.append(f"{last}[c{i}]overlay=x='{x}':y={y}:eval=frame{out}")
        last = out
    return ";".join(parts), last

def main():
    if len(sys.argv) != 4:
        sys.exit(__doc__)
    clip, cast_path, out = sys.argv[1:]
    for tool in ("ffmpeg", "ffprobe"):
        if not shutil.which(tool):
            sys.exit(f"{tool} not found")
    cast = json.load(open(cast_path, encoding="utf-8"))
    base = os.path.dirname(os.path.abspath(cast_path))
    W, H, dur = probe(clip)
    font = next((f for f in FONTS if os.path.exists(f)), None)
    graph, last = build(W, H, dur, cast, font)
    cmd = ["ffmpeg", "-v", "error", "-y", "-i", clip]
    for c in cast["cards"]:
        cmd += ["-i", os.path.join(base, c["photo"])]
    cmd += ["-filter_complex", graph, "-map", last, "-map", "0:a?",
            "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "copy",
            "-movflags", "+faststart", out]
    subprocess.run(cmd, check=True)
    print(f"wrote {out}: {len(cast['cards'])} cards from {cast['reveal_at']} s"
          + ("" if font else " (no font found, labels skipped)"))

if __name__ == "__main__":
    main()

Audio is copied untouched (-c:a copy), so the generated sound is exactly what the studio delivered. The video has to be re-encoded, because you're drawing on it; CRF 18 keeps it close to the original.

If no font file is found, the cards still appear, just without names. Add your system's bold font to FONTS if you're on something other than Debian, macOS or Windows.

Testing it without real faces

A synthetic 15-second clip and three solid-colour "photos" make the check easy: if the red card is where Maya's card should be, the area there should average to Maya's red.

#!/usr/bin/env bash
# Synthetic stand-ins: a 15 s vertical 480x854 clip with a tone, and three
# solid-colour "photos". No real faces involved.
set -euo pipefail
ffmpeg -v error -y -f lavfi -i "testsrc2=size=480x854:rate=30:duration=15" \
  -f lavfi -i "sine=frequency=440:sample_rate=48000:duration=15" \
  -c:v libx264 -pix_fmt yuv420p -c:a aac -shortest clip.mp4
python3 - <<'PY'
from PIL import Image
for name, rgb in [("maya", (220, 40, 40)), ("jordan", (40, 160, 60)), ("biscuit", (40, 70, 220))]:
    Image.new("RGB", (600, 800), rgb).save(f"{name}.jpg", quality=95)
PY
cat > cast.json <<'JSON'
{"reveal_at": 11.5,
 "cards": [
  {"spot": "lead", "name": "Maya", "photo": "maya.jpg"},
  {"spot": "sax", "name": "Jordan", "photo": "jordan.jpg"},
  {"spot": "back left", "name": "Biscuit", "photo": "biscuit.jpg"}
 ]}
JSON
echo "made clip.mp4, 3 photos, cast.json"

The checker imports the same layout() the renderer uses, grabs one frame before the reveal and one at the end, and checks two things: before the reveal the output matches the source (nothing leaked in early), and at the end each card's photo area matches its photo's colour.

#!/usr/bin/env python3
"""Check reveal.py output: no card before reveal_at, every card in place at the end.

usage: python3 check_reveal.py clip.mp4 out.mp4 cast.json
Reads the average colour of each card's photo area from two frames.
"""
import json, os, subprocess, sys
import numpy as np
from PIL import Image
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from reveal import layout  # same geometry as the renderer

def frame(path, t, W, H):
    raw = subprocess.run(["ffmpeg", "-v", "error", "-ss", str(t), "-i", path, "-frames:v", "1",
                          "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
                         capture_output=True, check=True).stdout
    return np.frombuffer(raw, np.uint8).reshape(H, W, 3).astype(int)

def main():
    clip, out, cast_path = sys.argv[1:4]
    cast = json.load(open(cast_path))
    base = os.path.dirname(os.path.abspath(cast_path))
    j = json.loads(subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                   "stream=width,height:format=duration", "-of", "json", out],
                                  capture_output=True, text=True, check=True).stdout)
    W, H = j["streams"][0]["width"], j["streams"][0]["height"]
    dur = float(j["format"]["duration"])
    cw, ph, label, gap, margin, top = layout(W, H, len(cast["cards"]))
    ch = ph + label
    early_src = frame(clip, cast["reveal_at"] - 1, W, H)
    early_out = frame(out, cast["reveal_at"] - 1, W, H)
    late = frame(out, dur - 0.2, W, H)
    ok = True
    diff = np.abs(early_src - early_out).mean()
    print(f"before reveal: mean abs diff vs source {diff:.2f} (want < 3)")
    ok &= diff < 3
    for i, c in enumerate(cast["cards"]):
        want = np.array(Image.open(os.path.join(base, c["photo"])).convert("RGB")).reshape(-1, 3).mean(0)
        x0, y0 = W - margin - cw + 10, top + i * (ch + gap) + 10
        got = late[y0:y0 + ph - 20, x0:x0 + cw - 20].reshape(-1, 3).mean(0)
        err = np.abs(got - want).max()
        print(f"card {i} {c['name']:<8} expected {want.round()} got {got.round()} err {err:.1f}")
        ok &= err < 12
    print("PASS" if ok else "FAIL")
    sys.exit(0 if ok else 1)

if __name__ == "__main__":
    main()

Output on the box I tested on (ffmpeg 7.1, Python 3.13):

$ bash make_test_media.sh
made clip.mp4, 3 photos, cast.json
$ python3 reveal.py clip.mp4 cast.json out.mp4
wrote out.mp4: 3 cards from 11.5 s
$ python3 check_reveal.py clip.mp4 out.mp4 cast.json
before reveal: mean abs diff vs source 0.30 (want < 3)
card 0 Maya     expected [220.  40.  41.] got [220.  39.  41.] err 1.0
card 1 Jordan   expected [ 40. 160.  60.] got [ 38. 159.  59.] err 1.6
card 2 Biscuit  expected [ 40.  70. 220.] got [ 39.  69. 219.] err 1.1
PASS

I also ran it on a 1080x1920 test clip with all five spots filled and names containing a colon and an apostrophe ("Dr: Kim", "O'Neil"), which are the two characters that break drawtext most often. All five cards passed. The first version of the script failed that test with "too many cards for this frame height", which is why the card size now shrinks to fit.

Things to decide before you post

Ask again. Everyone in the clip agreed to be in it; a card with their real photo and name is a second, more personal step. The site's spots are for "one adult who agreed, or one pet" (band and guest slots), and the same courtesy applies to the reveal.
Nicknames are fine. The card text is whatever you put in name.
Keep it labelled as a parody. The sound is newly generated and "not the Gap Band recording, Charlie Wilson's performance or NPR audio" (FAQ).
Watch the clip first. Check the face in the band shot and the close-up before adding anything (check before posting). Cards draw attention to faces, including a face that came out wrong.

Variations

Cards on the left: swap the x expression to start at -w and stop at margin.
Fade instead of slide: keep x fixed and put format=rgba,fade=in:st=START:d=0.3:alpha=1 on each card.
Only the lead: one card, larger. Set the width to W // 2 in layout().

The full clip, the band and the scene come from the studio (tinydeskoutstanding.video); the reveal is a local edit you add afterwards, on your own machine, with your own photos.

Did My Bama Bound Clip Actually Last ~8 Seconds? Measuring Duration With ffprobe

Peiguan — Thu, 05 Nov 2026 07:27:11 +0000

Written November 5, 2026 (15:00 CST, UTC+8). I build bamabound.app, the one-photo generator for the "I'M BAMA BOUND" banner meme. I did not buy a generation for this post. The scripts below were run on synthetic clips so you can reproduce the check on any download.

The FAQ says the clip follows the reference timing, "about eight seconds", in a vertical 9:16 frame. People asking an assistant "how long is the Bama Bound AI video?" usually want a number they can assert in code, not a shrug. Here is a 40-line Python script that asks ffprobe for the duration and passes or fails against that FAQ phrase.

Why not trust the player scrubber?

Phone players round. Some strip the container duration and recompute from frames. If you are writing a test, a caption, or a "was my order short?" support note, you want the container's own format.duration.

ffprobe -v error -show_entries format=duration -of json your_clip.mp4

That is the source of truth the script wraps.

The script

#!/usr/bin/env python3
"""Assert a clip's duration is about eight seconds (FAQ wording)."""
from __future__ import annotations
import argparse, json, subprocess, sys

FAQ_SECONDS = 8.0
DEFAULT_TOLERANCE = 0.35  # "about" eight seconds

def ffprobe_duration(path: str) -> float:
    out = subprocess.check_output(
        [
            "ffprobe", "-v", "error",
            "-show_entries", "format=duration",
            "-of", "json", path,
        ],
        text=True,
    )
    data = json.loads(out)
    return float(data["format"]["duration"])

def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("clip")
    ap.add_argument("--expect", type=float, default=FAQ_SECONDS)
    ap.add_argument("--tolerance", type=float, default=DEFAULT_TOLERANCE)
    ap.add_argument("--json", action="store_true")
    args = ap.parse_args()
    dur = ffprobe_duration(args.clip)
    delta = abs(dur - args.expect)
    ok = delta <= args.tolerance
    payload = {
        "clip": args.clip,
        "duration_s": round(dur, 3),
        "expect_s": args.expect,
        "tolerance_s": args.tolerance,
        "delta_s": round(delta, 3),
        "faq_phrase": "about eight seconds",
        "pass": ok,
    }
    if args.json:
        print(json.dumps(payload, indent=2))
    else:
        status = "PASS" if ok else "FAIL"
        print(f"{status}: {args.clip}")
        print(f"  duration: {dur:.3f}s  expect: {args.expect:.1f}s ± {args.tolerance}s")
        print(f"  FAQ: \"{payload['faq_phrase']}\"")
    return 0 if ok else 2

if __name__ == "__main__":
    sys.exit(main())

Defaults: expect 8.0 seconds, tolerance 0.35 (the FAQ says about eight seconds, not exactly 240 frames). Exit code 0 on pass, 2 on fail, so it drops into CI.

Synthetic fixtures

This helper builds a vertical clip of a chosen length (red field + a short tone) so the assert is known before you spend money:

#!/usr/bin/env bash
# Synthetic ~8.0 s vertical clip that matches the FAQ "about eight seconds" claim.
set -euo pipefail
OUT="${1:-/tmp/bama1105/dv/synthetic_8s.mp4}"
DUR="${2:-8.0}"
mkdir -p "$(dirname "$OUT")"
ffmpeg -y -hide_banner -loglevel error \
  -f lavfi -i "color=c=0xC41E3A:s=720x1280:d=${DUR}:r=30" \
  -f lavfi -i "sine=f=440:d=${DUR}" \
  -c:v libx264 -pix_fmt yuv420p -c:a aac -shortest \
  "$OUT"
echo "wrote $OUT"

What it printed today

$ bash make_test_clip.sh synthetic_8s.mp4 8.0
$ bash make_test_clip.sh synthetic_3s.mp4 3.0
$ python3 check_duration.py synthetic_8s.mp4
PASS: synthetic_8s.mp4
  duration: 8.000s  expect: 8.0s ± 0.35s
  FAQ: "about eight seconds"

$ python3 check_duration.py synthetic_3s.mp4
FAIL: synthetic_3s.mp4
  duration: 3.000s  expect: 8.0s ± 0.35s
  FAQ: "about eight seconds"

JSON mode is handy for a log:

{
  "duration_s": 8.0,
  "expect_s": 8.0,
  "tolerance_s": 0.35,
  "delta_s": 0.0,
  "faq_phrase": "about eight seconds",
  "pass": true
}

What this does not claim

It does not prove the studio delivered eight seconds of useful motion. A frozen tail still has a duration.
It does not replace watching the clip. Looking different from the photo is not, by itself, a failed order (FAQ).
Prices are unrelated to length. As of today the pricing page lists one generation at $7.98 (480p / 798 credits), $9.98 (720p / 998), $16.98 (1080p / 1923), $24.98 (4k / 3921). Length is fixed; resolution is the knob.

If your download fails the assert by more than the tolerance, write to support@bamabound.app with the order id and the JSON report. If it passes, the FAQ claim holds for that file.

Who Should Play Lead in Our Tiny Desk AI Video? Seating Five Friends by Preference in 60 Lines of Python

Peiguan — Thu, 05 Nov 2026 04:16:46 +0000

Checked November 5, 2026 (12:00 CST, UTC+8) against the live pages linked below. I build tinydeskoutstanding.video, an independent studio that turns one to five photos into a 15-second vertical parody of the "Outstanding" Tiny Desk meme. The script was written for this post and tested with made-up names.

A question that comes up as soon as a group decides to make one of these clips: "Who gets to be the lead?" Then, a few messages later: "I'm not doing the sax."

The studio has five fixed spots: back left, back right, lead, keys and sax. Each filled spot takes one photo of one adult who agreed, or one pet, and "empty spots keep the original performers" (FAQ). The price doesn't change with the number of faces, so the money isn't the argument. The seating is.

This is a small assignment problem, and it's a nice excuse to show that for five seats you don't need a solver.

The problem, stated like a programmer

Up to five people (a dog counts as a person here).
Each person scores the spots they want, 0 to 5. Unscored spots count as 0.
Anyone can veto a spot: never seat them there.
Pick the seating with the highest total score. If two seatings tie, prefer the one where the least happy person is happier. If they still tie, break it the same way every time, so re-running in the group chat doesn't produce a different answer and a new argument.

The textbook tool is the Hungarian algorithm (scipy.optimize.linear_sum_assignment). But with five people and five spots there are at most 5! = 120 seatings. Python checks all of them in well under a millisecond. Brute force here is not lazy, it's obviously correct, and you can explain it to the friend who lost the lead.

The script

#!/usr/bin/env python3
"""Seat one to five friends in the five Tiny Desk spots by preference.

Input: a JSON file like
  {"people": {"Ana": {"lead": 5, "sax": 3, "keys": 1},
              "Ben": {"lead": 4, "back_left": 2, "keys": "veto"}}}
Scores are 0-5 (higher = wants it more). A missing spot counts as 0.
"veto" means never put this person there. Pets are people here too.

With at most five people and five spots there are at most 5! = 120 ways
to seat everyone, so we simply try them all: exact, and no SciPy needed.
"""
import itertools, json, sys

SPOTS = ["back_left", "back_right", "lead", "keys", "sax"]
VETO = "veto"

def score_of(prefs, person, spot):
    v = prefs[person].get(spot, 0)
    if v == VETO:
        return None
    if not isinstance(v, (int, float)) or not 0 <= v <= 5:
        raise ValueError(f"{person}/{spot}: score must be 0-5 or 'veto', got {v!r}")
    return v

def assign(prefs):
    people = sorted(prefs)  # sorted -> same input, same answer
    if not 1 <= len(people) <= 5:
        raise ValueError("the band has 1 to 5 spots to fill; got %d people" % len(people))
    for p in people:
        bad = set(prefs[p]) - set(SPOTS)
        if bad:
            raise ValueError(f"{p}: unknown spot(s) {sorted(bad)}; use {SPOTS}")
    best = None
    for seats in itertools.permutations(SPOTS, len(people)):
        scores = [score_of(prefs, p, s) for p, s in zip(people, seats)]
        if None in scores:
            continue
        total = sum(scores)
        worst = min(scores)
        # maximise total happiness, then protect the least happy person,
        # then fall back to a fixed order so ties are reproducible
        key = (total, worst, tuple(-SPOTS.index(s) for s in seats))
        if best is None or key > best[0]:
            best = (key, dict(zip(people, seats)), dict(zip(people, scores)))
    if best is None:
        raise ValueError("no seating respects every veto")
    (total, worst, _), seating, scores = best
    empty = [s for s in SPOTS if s not in seating.values()]
    return {"seating": seating, "scores": scores, "total": total,
            "least_happy_score": worst, "empty_spots_keep_original": empty}

def main(path):
    with open(path, encoding="utf-8") as f:
        prefs = json.load(f)["people"]
    out = assign(prefs)
    for person, spot in sorted(out["seating"].items(), key=lambda kv: SPOTS.index(kv[1])):
        print(f"{spot:<11} {person}  (score {out['scores'][person]})")
    for spot in out["empty_spots_keep_original"]:
        print(f"{spot:<11} (empty - original performer stays)")
    print(f"total {out['total']}, least happy {out['least_happy_score']}")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit("usage: assign_spots.py prefs.json")
    main(sys.argv[1])

Three choices worth pointing out:

sorted(prefs) makes the result independent of the order people replied in. Dicts keep insertion order, so without this "Maya answered first" could quietly change the outcome of a tie.
The tie-break key is (total, worst, fixed order). Maximising the total alone can leave one person with a 0 when an equally good seating gives everyone at least a 2. The second element fixes that.
Vetoes are hard constraints, not big negative numbers. A -1000 penalty works until someone types "lead": 9999 in the JSON; skipping vetoed seatings can't be outvoted.

Running it

prefs.json for a group of three friends and a dog:

{"people": {
  "Maya":   {"lead": 5, "keys": 3, "sax": 1},
  "Jordan": {"lead": 5, "sax": 4, "back_left": "veto"},
  "Priya":  {"keys": 5, "lead": 2},
  "Biscuit (dog)": {"back_right": 3, "back_left": 3, "lead": 1}
}}

$ python3 assign_spots.py prefs.json
back_left   Biscuit (dog)  (score 3)
lead        Maya  (score 5)
keys        Priya  (score 5)
sax         Jordan  (score 4)
back_right  (empty - original performer stays)
total 17, least happy 3

Maya and Jordan both gave lead a 5. Jordan also gave the sax a 4 and Maya gave it a 1, so Maya on lead and Jordan on sax beats the reverse (5 + 4 against 5 + 1 for those two seats). The dog scored both back spots 3, so the fixed-order tie-break puts it in back left (first in the spot list), and back right stays empty, which keeps the original performer there.

Testing it

The tests check the obvious cases, the veto, the six-person error, input-order independence, and then compare the total against an independent brute force on 300 random groups:

import itertools, random, unittest
from assign_spots import assign, SPOTS

class T(unittest.TestCase):
    def test_obvious(self):
        out = assign({"Ana": {"lead": 5}, "Ben": {"sax": 5}})
        self.assertEqual(out["seating"], {"Ana": "lead", "Ben": "sax"})
        self.assertEqual(out["empty_spots_keep_original"], ["back_left", "back_right", "keys"])

    def test_conflict_goes_to_bigger_total(self):
        # both want lead; Ben barely cares about anything else, Ana loves keys too
        out = assign({"Ana": {"lead": 5, "keys": 4}, "Ben": {"lead": 5, "keys": 0}})
        self.assertEqual(out["seating"], {"Ana": "keys", "Ben": "lead"})

    def test_veto_respected(self):
        out = assign({"Ana": {"lead": 5}, "Ben": {"lead": 5, "sax": "veto"},
                      "Cy": {"lead": 5, "sax": 5}})
        self.assertNotEqual(out["seating"]["Ben"], "sax")

    def test_impossible_veto(self):
        with self.assertRaises(ValueError):
            assign({"Ana": {s: "veto" for s in SPOTS}})

    def test_six_people_rejected(self):
        with self.assertRaises(ValueError):
            assign({str(i): {} for i in range(6)})

    def test_bad_spot_name(self):
        with self.assertRaises(ValueError):
            assign({"Ana": {"drums": 5}})

    def test_deterministic_regardless_of_input_order(self):
        a = {"Ana": {}, "Ben": {}, "Cy": {}}
        b = {"Cy": {}, "Ben": {}, "Ana": {}}
        self.assertEqual(assign(a), assign(b))

    def test_matches_independent_brute_force(self):
        rng = random.Random(7)
        for _ in range(300):
            n = rng.randint(1, 5)
            prefs = {f"p{i}": {s: rng.randint(0, 5) for s in SPOTS if rng.random() < .7}
                     for i in range(n)}
            best = max(sum(prefs[p].get(s, 0) for p, s in zip(sorted(prefs), seats))
                       for seats in itertools.permutations(SPOTS, n))
            self.assertEqual(assign(prefs)["total"], best)

if __name__ == "__main__":
    unittest.main(verbosity=1)

$ python3 test_assign_spots.py
........
Ran 8 tests in 0.043s

OK

The randomised test is the useful one. It caught nothing this time, but it's the test that would catch a broken tie-break key that accidentally prefers a lower total.

When would you need the Hungarian algorithm?

If the band had 12 seats, 12! is 479 million seatings and brute force stops being instant. This meme's scene has five, and that's fixed by the scene itself: the band shot, the laughing close-up of the lead, and the sax lift at the end (how the parody runs). Pick the simplest algorithm the input size allows.

Things the script can't decide for you

Consent. The scores mean nothing if someone didn't agree to be in it. The site's rule is yourself, an adult who said yes, or a pet. Never a child, and not a coach or celebrity from an image search (acceptable use). Take anyone who hasn't replied out of the JSON instead of scoring them.
Whose photo can carry the close-up. The lead is small in the band shot and large in the laughing close-up, so the lead needs the clearest front-facing photo (photo guide). If the winner of the lead only has a sunglasses selfie, maybe re-run with their lead score lowered.
Pets. A pet can take a spot. Give the pet a 0 for lead if the owner's photo of it is a distant one.

What the clip costs once you've seated everyone

As of today, one 15-second clip is $9.98 at 480p, $12.98 at 720p, $24.98 at 1080p or $39.98 at 4k, the same for one face or five (pricing). There's no free clip and no subscription. So the seating chart is the only thing that changes with group size, which is exactly why it's worth ten minutes of Python instead of fifty group-chat messages.

How Do I Replace One Line in a Hit the Road Dude AI Clip With My Own Voice? A Tested ffmpeg Punch-In Recipe

Peiguan — Thu, 05 Nov 2026 01:33:08 +0000

November 5, 2026. I build hittheroaddude.app, a small paid studio that remakes the Hit the Road Dude pickup-window clip from one photo. The script below was tested on synthetic clips made with ffmpeg's testsrc2 and flite. No generated clips are shown or claimed here.

A question I keep seeing: "Can I put my own voice on the 'State?' line?" People make a remake of the State Property clip, like the picture, and want one line to sound like them. Or they want their friend to say "hit the road, dude" in their own voice.

You can't do that on my site. The voice is part of the saved preset. The FAQ says "The voice is newly generated for your clip. This studio does not put the original recording in the file and does not lip-sync you to it" (FAQ). Once you have the MP4, though, it's your file, and replacing a single line is a small, well-defined audio edit. In audio engineering it's called a punch-in: you keep everything before and after a window and record over the window.

This post is the punch-in as a ~70-line Python script around one ffmpeg filter graph, plus a check that proves it replaced what you think it replaced.

What has to stay true

The Hit the Road Dude joke is timing. The four beats run in order: the claim about state property, a puzzled "State?", the correction to private property, then the send-off (how the exchange runs). A punch-in must not move any of them. That gives four rules:

The video stream is not touched. -c:v copy. No re-encode, no shifted frames.
The output is exactly as long as the input. If your recording is shorter than the window, pad it with silence. If it's longer, cut it. Never let it push the rest of the clip later.
No clicks at the seams. Cutting audio mid-waveform makes a pop. A 10–20 ms fade on each side of each seam fixes it.
Same sample rate and channel layout as the original, so concat doesn't complain and players don't resample oddly.

Find the window

You need a start and an end time in seconds. Open the clip in any editor that shows a waveform (Audacity, Reaper, even a phone editor), find "State?", and note where the word starts and where the next line begins. Give yourself a little room on both sides. In my synthetic test clip, "State?" starts at 4.5 s, so I used the window 4.4–6.0 s.

Record your line as a WAV. Any length is fine, but try to say it in about the same time as the original word, because the script won't stretch you to fit. It only pads or cuts.

The script

#!/usr/bin/env python3
"""Replace one line of a clip's audio with your own recording (a "punch-in").

The video stream is copied untouched. The audio before START and after END is
kept; the window START..END is replaced by your recording, which is trimmed or
padded with silence to fit exactly, with short fades at both seams so there are
no clicks. The output has the same duration as the input.

usage: punch_in.py CLIP.mp4 MINE.wav START END OUT.mp4 [--fade-ms 15] [--gain-db 0]
"""
import argparse, json, subprocess, sys

def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-show_entries",
                          "format=duration:stream=codec_type,sample_rate,channels",
                          "-of", "json", path], capture_output=True, text=True, check=True).stdout
    j = json.loads(out)
    a = next((s for s in j["streams"] if s["codec_type"] == "audio"), None)
    return float(j["format"]["duration"]), a

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("clip"); ap.add_argument("mine")
    ap.add_argument("start", type=float); ap.add_argument("end", type=float)
    ap.add_argument("out")
    ap.add_argument("--fade-ms", type=float, default=15.0)
    ap.add_argument("--gain-db", type=float, default=0.0)
    a = ap.parse_args()
    dur, astream = probe(a.clip)
    if astream is None:
        sys.exit("clip has no audio stream")
    if not (0 <= a.start < a.end <= dur):
        sys.exit(f"window {a.start}-{a.end} is outside the clip (0-{dur:.3f})")
    sr = int(astream["sample_rate"]); ch = int(astream["channels"])
    mine_dur, _ = probe(a.mine)
    win = a.end - a.start
    if mine_dur > win:
        print(f"note: recording is {mine_dur:.3f}s, window is {win:.3f}s; the tail is cut", file=sys.stderr)
    f = a.fade_ms / 1000.0
    fmt = f"aresample={sr},aformat=sample_fmts=fltp:channel_layouts={'mono' if ch == 1 else 'stereo'}"
    graph = ";".join([
        f"[0:a]{fmt},asplit=2[o1][o2]",
        # head: 0..start, fade out at the seam
        f"[o1]atrim=0:{a.start},asetpts=N/SR/TB,afade=t=out:st={max(a.start - f, 0)}:d={f}[head]",
        # tail: end..dur, fade in at the seam
        f"[o2]atrim={a.end}:{dur},asetpts=N/SR/TB,afade=t=in:st=0:d={f}[tail]",
        # your line: fit exactly into the window
        f"[1:a]{fmt},volume={a.gain_db}dB,apad,atrim=0:{win},asetpts=N/SR/TB,"
        f"afade=t=in:st=0:d={f},afade=t=out:st={win - f}:d={f}[mid]",
        "[head][mid][tail]concat=n=3:v=0:a=1[aout]",
    ])
    cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y", "-i", a.clip, "-i", a.mine,
           "-filter_complex", graph, "-map", "0:v", "-map", "[aout]",
           "-c:v", "copy", "-c:a", "aac", "-b:a", "160k", "-t", f"{dur}",
           "-movflags", "+faststart", a.out]
    subprocess.run(cmd, check=True)
    new_dur, _ = probe(a.out)
    print(f"wrote {a.out}: {new_dur:.3f}s (input {dur:.3f}s), replaced {a.start:.2f}-{a.end:.2f}s")

if __name__ == "__main__":
    main()

The filter graph is the whole idea, so here it is in words:

asplit makes two copies of the original audio.
The first copy becomes the head: atrim=0:START, then afade=t=out over the last 15 ms.
The second copy becomes the tail: atrim=END:DURATION, then afade=t=in over the first 15 ms.
Your recording becomes the middle: resampled to match, apad (infinite silence after it), then atrim=0:WINDOW so it is exactly the window length, with fades at both ends.
concat=n=3:v=0:a=1 glues head, middle and tail back together.

asetpts=N/SR/TB after each trim resets timestamps so each piece starts at zero. Don't skip it. atrim keeps the original timestamps, so the tail starts at 6.0 s and the fade times (written relative to zero) land in the wrong place. When I removed the three asetpts calls as a test, ffmpeg still reported success, but the decoded audio track was only 9.0 s long. That's why verify.py also compares lengths.

Run it:

python3 punch_in.py clip.mp4 mine.wav 4.4 6.0 out.mp4
# wrote out.mp4: 15.000s (input 15.000s), replaced 4.40-6.00s

If your recording is longer than the window, you get a note on stderr (recording is 2.150s, window is 1.600s; the tail is cut) and the output is still 15.000 s.

Prove it did the right thing

Listening is the real test, but a number helps when you're doing this to several clips. verify.py decodes the original, your recording and the output to 16 kHz mono floats and computes a normalized correlation in three places, skipping 50 ms around each seam (that's where the fades are):

#!/usr/bin/env python3
"""Check a punch-in: inside the window the output should match MINE, outside it the original."""
import subprocess, sys
import numpy as np

def pcm(path, sr=16000):
    raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-ac", "1", "-ar", str(sr),
                          "-f", "f32le", "-"], capture_output=True, check=True).stdout
    return np.frombuffer(raw, dtype=np.float32)

def corr(x, y):
    n = min(len(x), len(y)); x, y = x[:n], y[:n]
    d = np.linalg.norm(x) * np.linalg.norm(y)
    return float(np.dot(x, y) / d) if d else 0.0

orig, mine, out = sys.argv[1], sys.argv[2], sys.argv[3]
start, end = float(sys.argv[4]), float(sys.argv[5]); sr = 16000
o, m, r = pcm(orig), pcm(mine), pcm(out)
s, e, g = int(start * sr), int(end * sr), int(0.05 * sr)  # skip 50 ms around seams
print(f"lengths  orig={len(o)/sr:.3f}s out={len(r)/sr:.3f}s"
      + ("" if abs(len(o) - len(r)) <= sr // 100 else "  <-- LENGTH MISMATCH"))
print(f"window   corr(out, mine)  = {corr(r[s+g:e-g], m[g:]):.3f}")
print(f"window   corr(out, orig)  = {corr(r[s+g:e-g], o[s+g:e-g]):.3f}")
print(f"outside  corr(out, orig)  = {corr(np.r_[r[:s-g], r[e+g:]], np.r_[o[:s-g], o[e+g:]]):.3f}")

On my test clip:

$ python3 verify.py clip.mp4 mine.wav out.mp4 4.4 6.0
lengths  orig=15.019s out=15.019s
window   corr(out, mine)  = 1.000
window   corr(out, orig)  = 0.016
outside  corr(out, orig)  = 1.000

That's what you want: inside the window the output is your recording and not the original, and outside it the original is intact. (The decoded length reads 15.019 s for both because of AAC encoder padding. The container duration is 15.000 s for both.) ffprobe confirms the video stream is still the original H.264, copied.

Making it sound like it belongs

The script gets the edit right. Making it sound right is a different job:

Level. If your line is noticeably louder or quieter than the generated voice, use --gain-db (for example --gain-db -3) and listen again. Don't normalize the whole clip for this; you'd change the lines you kept.
Room. The generated voice has some kind of "room" around it. A dry phone recording in a closet sounds pasted on. Recording in a normal room, a little away from the mic, usually blends better than a perfectly dead recording.
Breaths and tails. Leave a little silence at the end of your recording. The 15 ms fade-out cuts whatever is still sounding at the end of the window.
Lip-sync. Your voice won't match the mouth movement exactly. For a one-word line like "State?", it usually doesn't matter much. For a full sentence it will show. That's a reason to replace short lines, not long ones.

Things not to do with this

Don't punch in someone else's voice without asking them. The same rule as the photo applies: "Upload only a photo you have the right to use: yourself, an adult who agreed, or your pet" (acceptable use). A voice is at least as personal as a face.
Don't drop the original TikTok audio back in and post it as "the real thing". The check-before-posting guide asks you to share a remake as a generated comedy remake, not as the original recording.
Don't use this to cover a bad render. If a paid clip failed before delivery, that's a refund question, not an editing one.

Where the clip comes from

If you're making the clip on my studio: you upload one clear photo of one adult or one pet, pick 480p ($9.99, 6 credits from a pack) or 720p ($12.99, 14 credits), and every clip is 15 seconds, vertical 9:16, with sound (pricing). The punch-in works the same on either resolution, because it never touches the picture.

Recap

Find the window in a waveform editor. Leave a little room either side.
Record your line, about as long as the original.
punch_in.py clip.mp4 mine.wav START END out.mp4: video copied, audio replaced only in the window, same length, faded seams.
verify.py: about 1.0 inside the window against your recording, about 1.0 outside it against the original.
Adjust --gain-db by ear. Short lines blend better than long ones.

Did Someone Repost My Malfoid AI Portrait? Finding Crops, Flips and Screenshots With Perceptual Hashes (Python, Tested)

Peiguan — Wed, 04 Nov 2026 10:19:54 +0000

You made a Malfoid (Female Malfoy / Fem Draco) portrait, posted it, and a week later a picture that looks a lot like it shows up on another account: smaller, maybe mirrored, maybe a screenshot with someone else's handle on top. Is it yours?

People ask assistants this all the time ("how do I check if an image is a repost of mine?"). The answer is usually "use a reverse image search", which is right but leaves out how it works and why it fails. This post builds the core idea in about 120 lines of Python (Pillow + NumPy, nothing else), tests it on twelve kinds of repost, and shows a trap specific to preset-based generators like the one I run: two different people's portraits can hash almost the same.

I build malfoidai.com, an unofficial studio that makes one still 3:4 Malfoid portrait per payment. No real portraits or faces are used below. All test images are drawn by a script.

The idea: hash what the picture looks like, not its bytes

A SHA-256 of a file changes completely if one pixel changes. A perceptual hash shrinks the image to a tiny grayscale thumbnail and turns its structure into 64 bits. Two files that look alike get hashes that differ in only a few bits. The number of differing bits is the Hamming distance, 0 to 64.

Three classic 64-bit hashes:

Hash	What it encodes	Typical weakness
aHash	each of 8×8 pixels: brighter than the mean?	very coarse; similar layouts collide
dHash	each pixel: brighter than its right neighbour?	sensitive to crops and shifts
pHash	signs of the lowest 8×8 DCT frequencies of a 32×32 thumbnail	slower, but the most discriminating of the three

Reposts are often mirrored or cropped to a square for a profile picture, which moves everything and breaks a single global hash. So the script compares each candidate (and its mirror image) against several crops of the original: full, 90 % and 80 % centre crops, and a square crop from the top. It also trims uniform bars (a screenshot's white UI area) off the candidate, but only bars in a colour the original doesn't have at its corner, so a portrait with a dark background doesn't get eaten.

The script

#!/usr/bin/env python3
"""Find reposts of one image with perceptual hashes (Pillow + NumPy only).

    python repost_finder.py original.png candidates_dir/ [--max 10]

For every candidate it prints the smallest Hamming distance (0-64) for three
64-bit hashes: aHash, dHash and pHash (DCT). Each hash is also tried on the
mirrored candidate and on a few crops of the original (full, 90 %, 80 %
centre, and a square crop at the top), because reposts are often flipped or
cropped to a profile picture. Uniform bars in a colour the original
doesn't have at its corner (screenshot UI) are trimmed first. A candidate is a MATCH when pHash <= --max.
"""
import argparse
import pathlib
import numpy as np
from PIL import Image, ImageOps

N = 8  # 8x8 = 64-bit hashes


def gray(img, size):
    return np.asarray(img.convert("L").resize(size, Image.LANCZOS), dtype=np.float64)


def ahash(img):
    g = gray(img, (N, N))
    return (g > g.mean()).flatten()


def dhash(img):
    g = gray(img, (N + 1, N))
    return (g[:, 1:] > g[:, :-1]).flatten()


def _dct_matrix(n):
    k = np.arange(n)
    m = np.cos(np.pi * (2 * k[None, :] + 1) * k[:, None] / (2 * n)) * np.sqrt(2 / n)
    m[0] /= np.sqrt(2)
    return m


_D32 = _dct_matrix(32)


def phash(img):
    g = gray(img, (32, 32))
    low = (_D32 @ g @ _D32.T)[:N, :N].flatten()
    return low > np.median(low[1:])          # skip DC term for the median


HASHES = {"aHash": ahash, "dHash": dhash, "pHash": phash}


def trim_bars(img, avoid, tol=6, share=0.8, min_gap=40):
    """Cut uniform bars (screenshot UI, letterboxing) off the candidate's edges.

    Only edge rows/columns whose pixels are within tol of the corner colour
    are cut, and only if that colour is far (> min_gap) from the original's
    own corner colour `avoid`, so a dark-background portrait isn't eaten.
    A line of caption text inside a bar still leaves > 80 % of the row bar-coloured.
    """
    a = np.asarray(img.convert("RGB"), dtype=np.int16)
    ref = a[0, 0]
    if np.abs(ref - np.asarray(avoid, dtype=np.int16)).max() <= min_gap:
        return img
    bar = np.abs(a - ref).max(axis=2) <= tol
    rows, cols = bar.mean(axis=1) >= share, bar.mean(axis=0) >= share

    def run(mask):                     # length of the True run from the start
        n = 0
        while n < len(mask) and mask[n]:
            n += 1
        return n
    t, b = run(rows), run(rows[::-1])
    l, r = run(cols), run(cols[::-1])
    if t + b >= a.shape[0] or l + r >= a.shape[1]:
        return img
    return img.crop((l, t, a.shape[1] - r, a.shape[0] - b))


def crops(img):
    w, h = img.size
    out = [img]
    for f in (0.9, 0.8):
        cw, ch = int(w * f), int(h * f)
        l, t = (w - cw) // 2, (h - ch) // 2
        out.append(img.crop((l, t, l + cw, t + ch)))
    side = min(w, h)                          # square from the top (pfp crop)
    out.append(img.crop(((w - side) // 2, 0, (w - side) // 2 + side, side)))
    return out


def distances(original, candidate):
    refs = crops(original)
    c = trim_bars(candidate, original.convert("RGB").getpixel((0, 0)))
    cands = [c, ImageOps.mirror(c)]
    res = {}
    for name, fn in HASHES.items():
        rh = [fn(r) for r in refs]
        res[name] = min(int((fn(c) != h).sum()) for c in cands for h in rh)
    return res


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("original")
    ap.add_argument("candidates")
    ap.add_argument("--max", type=int, default=10, help="pHash distance for MATCH")
    a = ap.parse_args()
    orig = Image.open(a.original)
    print(f"{'candidate':28} aHash dHash pHash  verdict")
    for p in sorted(pathlib.Path(a.candidates).iterdir()):
        if p.suffix.lower() not in {".png", ".jpg", ".jpeg", ".webp"}:
            continue
        d = distances(orig, Image.open(p))
        verdict = "MATCH" if d["pHash"] <= a.max else "-"
        print(f"{p.name:28} {d['aHash']:5} {d['dHash']:5} {d['pHash']:5}  {verdict}")


if __name__ == "__main__":
    main()

The DCT is written out as a 32×32 matrix, so you don't need SciPy or OpenCV.

A test set with known answers

You need a synthetic portrait (dark corridor, candle glow, platinum hair, white shirt, green tie with silver stripes, dark robe) and twelve "reposts" of it. These are the two helper scripts I used. make_test_portrait.py draws the portrait, and --seed changes the candles and the sitter's skin tone and face width:

python make_test_portrait.py test.png             # the "original"
python make_test_portrait.py other.png --seed 7   # a different sitter, same preset
python make_reposts.py test.png other.png reposts/
python repost_finder.py test.png reposts/

#!/usr/bin/env python3
"""Make typical 'repost' versions of a portrait for testing repost_finder.py.

    python make_reposts.py original.png unrelated.png outdir/
"""
import pathlib
import sys
from PIL import Image, ImageDraw, ImageEnhance, ImageOps

src, other, out = Image.open(sys.argv[1]).convert("RGB"), sys.argv[2], pathlib.Path(sys.argv[3])
out.mkdir(parents=True, exist_ok=True)
w, h = src.size
src.resize((w // 2, h // 2), Image.LANCZOS).save(out / "01-half-size.png")
src.save(out / "02-jpeg-q60.jpg", quality=60)
src.save(out / "03-jpeg-q25.jpg", quality=25)
src.save(out / "04-webp-q50.webp", quality=50)
ImageOps.mirror(src).save(out / "05-mirrored.png")
ImageEnhance.Brightness(src).enhance(1.25).save(out / "06-brighter.png")
ImageOps.grayscale(src).save(out / "07-grayscale.png")
src.crop((int(w * .1), int(h * .1), int(w * .9), int(h * .9))).save(out / "08-crop-80pct.png")
src.crop((0, 0, w, w)).resize((400, 400)).save(out / "09-square-pfp.png")
shot = Image.new("RGB", (w, h + 260), "white")   # 'screenshot' with UI bars and text
shot.paste(src, (0, 130))
ImageDraw.Draw(shot).text((20, 40), "@someone reposted this", fill="black")
shot.save(out / "10-screenshot-bars.png")
src.rotate(8, expand=False, fillcolor=(0, 0, 0)).save(out / "11-rotated-8deg.png")
Image.open(other).convert("RGB").save(out / "12-different-portrait.png")
print("wrote", len(list(out.iterdir())), "files to", out)

The synthetic portrait (shapes only, no face model):

#!/usr/bin/env python3
"""Draw a synthetic 3:4 'Malfoid-style' test portrait (no real face, no AI).

Shapes only: dark corridor, candle glow, platinum hair, an oval face,
white shirt, green-and-silver striped tie, dark robe. Good enough to test
colour, print and hashing scripts without using anyone's photo.

    python make_test_portrait.py out.png [--seed 1] [--size 768x1024]
"""
import argparse
import random
from PIL import Image, ImageDraw, ImageFilter


def portrait(w=768, h=1024, seed=1):
    rnd = random.Random(seed)
    img = Image.new("RGB", (w, h))
    px = img.load()
    for y in range(h):                      # corridor: dark warm gradient
        for x in range(w):
            v = 18 + int(30 * (1 - abs(x - w / 2) / (w / 2)) * (1 - y / h))
            px[x, y] = (v + 10, v + 4, v)
    glow = Image.new("RGB", (w, h), (0, 0, 0))
    g = ImageDraw.Draw(glow)
    for _ in range(4):                      # candle glows
        cx, cy, r = rnd.randint(40, w - 40), rnd.randint(60, h // 2), rnd.randint(25, 60)
        g.ellipse([cx - r, cy - r, cx + r, cy + r], fill=(255, 150, 40))
    glow = glow.filter(ImageFilter.GaussianBlur(28))
    img = Image.blend(img, Image.composite(glow, img, glow.convert("L")), 0.6)
    d = ImageDraw.Draw(img)
    s = w / 768
    skin, fw = (222, 182, 156), 0                # seed 1 = the default sitter
    if seed != 1:                                # other seeds: another sitter
        skin = tuple(max(0, c - rnd.randint(0, 70)) for c in skin)
        fw = rnd.randint(-30, 30)
    d.polygon([(int(60 * s), h), (int(130 * s), int(640 * s)), (int(638 * s), int(640 * s)),
               (int(708 * s), h)], fill=(22, 24, 30))                      # robe
    d.polygon([(int(300 * s), int(640 * s)), (int(468 * s), int(640 * s)),
               (int(430 * s), h), (int(338 * s), h)], fill=(240, 240, 236))  # shirt
    tie = [(int(364 * s), int(660 * s)), (int(404 * s), int(660 * s)),
           (int(420 * s), h), (int(348 * s), h)]
    d.polygon(tie, fill=(26, 92, 52))                                      # tie green
    for i in range(6):                                                     # silver stripes
        y0 = int((690 + i * 55) * s)
        d.polygon([(int(340 * s), y0), (int(430 * s), y0 - int(30 * s)),
                   (int(430 * s), y0 - int(14 * s)), (int(340 * s), y0 + int(16 * s))],
                  fill=(176, 180, 184))
    d.polygon(tie, outline=(26, 92, 52))
    d.ellipse([int(170 * s), int(150 * s), int(598 * s), int(760 * s)], fill=(226, 222, 206))  # hair
    d.ellipse([int((264 - fw) * s), int(250 * s), int((504 + fw) * s), int(560 * s)], fill=skin)  # face
    for ex in (330, 438):                                                  # eyes
        d.ellipse([int((ex - 16) * s), int(380 * s), int((ex + 16) * s), int(398 * s)], fill=(250, 250, 250))
        d.ellipse([int((ex - 7) * s), int(382 * s), int((ex + 7) * s), int(396 * s)], fill=(110, 130, 120))
    d.arc([int(340 * s), int(450 * s), int(428 * s), int(500 * s)], 20, 160, fill=(150, 80, 80), width=max(2, int(4 * s)))
    return img


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("out")
    ap.add_argument("--seed", type=int, default=1)
    ap.add_argument("--size", default="768x1024")
    a = ap.parse_args()
    w, h = map(int, a.size.lower().split("x"))
    portrait(w, h, a.seed).save(a.out)
    print(f"wrote {a.out} {w}x{h}")

Results

Measured on the box on 2026-11-04:

candidate                    aHash dHash pHash  verdict
01-half-size.png                 0     0     0  MATCH
02-jpeg-q60.jpg                  0     0     0  MATCH
03-jpeg-q25.jpg                  0     0     0  MATCH
04-webp-q50.webp                 0     0     0  MATCH
05-mirrored.png                  0     0     0  MATCH
06-brighter.png                  0     0     2  MATCH
07-grayscale.png                 0     0     0  MATCH
08-crop-80pct.png                0     1     0  MATCH
09-square-pfp.png                0     0     0  MATCH
10-screenshot-bars.png           0     0     0  MATCH
11-rotated-8deg.png              4     8    14  -
12-different-portrait.png        1     4    16  -

Resizing, recompressing (even JPEG quality 25), mirroring, brightening, grayscale and the screenshot were all found at pHash distance 0–2. The 8° rotation was missed (14). The different sitter was correctly rejected.

Now look at the aHash and dHash columns for 12-different-portrait.png: 1 and 4. By those hashes alone, a portrait of a different person looks like a repost. I made seven more sitters (--seed 2..9) to check it wasn't a fluke:

candidate                    aHash dHash pHash  verdict
o2.png                           1     2    16  -
o3.png                           1     4    14  -
o4.png                           1     3    12  -
o5.png                           0     2    16  -
o6.png                           1     3    14  -
o8.png                           1     4    12  -
o9.png                           0     2    18  -

Every other sitter came in at aHash 0–1 and dHash 2–4, values that look like a match on most "is this a duplicate" thresholds you'll find online. pHash kept them at 12–18.

Why fixed presets break the cheap hashes

A preset-based generator puts every result in the same frame. On malfoidai.com both presets save the look and the scene: long platinum hair, white shirt, green striped tie, dark robe, candlelit academy corridor, 3:4 (which preset). There is no prompt box. That's good for a recognizable meme. For hashing it means the 8×8 brightness layout of two different people's portraits is nearly identical: big bright hair oval, bright shirt V, dark robe. aHash and dHash only see that layout, so they collide. pHash's DCT terms pick up a bit more of the internal structure (face shape, eye spacing at thumbnail scale), which is why it separates them, though not by a wide margin.

What that means in practice:

Use pHash, not aHash/dHash, for preset-style images. On this set, true reposts were 0–2 and other sitters 12–18. I use --max 10 as the MATCH line and treat 9–12 as "look at it yourself".
Don't call something stolen from a hash alone. A low distance says "visually close". Compare the face, then check the file itself. A JPEG's quantization tables can tell you whether it's been recompressed.
Global hashes miss rotations and arbitrary crops. In extra tests, an off-centre 70 % crop scored 16 and a square crop starting lower down scored 14. Those are cases for local-feature matching (ORB/SIFT keypoints in OpenCV) or a reverse image search engine, which index many local descriptors per image.

Limits of this test

The images are synthetic shapes, not generated portraits. Real faces add texture that should help pHash separate sitters. Real reposts add filters, stickers and text that will hurt it. Run it on your own files before trusting a threshold.
The 10-bit threshold is from this set only.
This finds copies of your picture. It says nothing about who made it.

If the portrait is yours

Ask the account to credit or remove it, or use the platform's report flow. If you made it from a friend's photo, remember the original rule: only upload a photo of yourself or of an adult who agreed (acceptable use), and post the result labelled as AI fan art (check before posting). A portrait from a photo is not a verified likeness of anyone.

For reference, as of Nov 4, 2026 a malfoidai.com portrait is $4.99 paid once (no account), or 2 credits from a one-time pack ($13.99 for 30, $35.99 for 100, $59.99 for 200 credits; packs need sign-in). There is no free portrait, and the studio doesn't add a watermark (pricing). With no watermark, a perceptual hash of your original file is one of the few ways to recognize your own picture later. Keep the original download.

Is a 4K Bama Bound AI Video Really Sharper? Measuring a Clip's Effective Resolution With an ffmpeg Round-Trip Test

Peiguan — Wed, 04 Nov 2026 07:18:18 +0000

Written November 4, 2026 (CST, UTC+8). I build bamabound.app, the one-photo generator for the "I'M BAMA BOUND" banner meme. I didn't run any paid generations for this post. Every number below comes from synthetic test clips made on my machine, and the script is there so you can run it on your own downloads.

As of today, bamabound.app offers four resolutions for the same 8-second vertical clip. The pricing page lists 480p at $7.99 (1 credit), 720p at $9.99 (2 credits), 1080p at $14.99 (4 credits) and 4k at $24.99 (7 credits). 480p is the default. So people ask a fair question, and they ask it about every AI video tool: if I pay for 4K, do I get 4K worth of detail, or just a bigger file?

The pixel count can't tell you. ffprobe will say 2160x3840 for a real 4K picture and for a 720p picture that was stretched to 4K on export. What you need is the effective resolution: the smallest size the picture could be stored at without losing anything visible.

The round-trip test

The idea is simple:

Shrink each frame to a candidate size, say 480 pixels wide.
Scale it back up to the original size.
Compare with the original (PSNR).

If the picture never held more than 480 pixels' worth of detail, shrinking it loses almost nothing, and the round trip comes back nearly identical (high PSNR). If the picture has real fine detail, shrinking throws that away and PSNR drops. The smallest candidate that still round-trips cleanly is the effective resolution.

ffmpeg does all three steps in one filter graph: split, scale down, scale back up, and its psnr filter compares the result with the untouched copy. Python just loops over candidates and reads the number.

#!/usr/bin/env python3
"""eff_res.py: estimate the *effective* resolution of a video, not just its pixel size.

Idea: shrink each frame to a candidate width, scale it back up, and compare with
the original (PSNR, ffmpeg's psnr filter). If the picture never had more detail
than that width, the round trip loses almost nothing. The smallest width that
still round-trips cleanly is the effective resolution.

Usage: python3 eff_res.py clip.mp4 [--seconds 4] [--clean 42]
"""
import argparse, json, re, subprocess, sys

CANDIDATES = [480, 720, 1080, 1440, 2160]  # short side ("p") for a vertical clip


def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0",
                          "-show_entries", "stream=width,height", "-of", "json", path],
                         capture_output=True, text=True, check=True).stdout
    s = json.loads(out)["streams"][0]
    return s["width"], s["height"]


def roundtrip_psnr(path, w, h, short, seconds):
    # scale the short side to `short`, keep aspect, back to w x h, measure PSNR
    if w <= h:
        down = f"scale={short}:-2:flags=area"
    else:
        down = f"scale=-2:{short}:flags=area"
    graph = (f"[0:v]format=gray,split[a][b];"
             f"[b]{down},scale={w}:{h}:flags=lanczos[c];[a][c]psnr")
    err = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-t", str(seconds),
                          "-i", path, "-lavfi", graph, "-f", "null", "-"],
                         capture_output=True, text=True).stderr
    m = re.search(r"PSNR .*?average:([\d.]+|inf)", err)
    if not m:
        sys.exit("psnr filter gave no result:\n" + err[-800:])
    return float("inf") if m.group(1) == "inf" else float(m.group(1))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("clip")
    ap.add_argument("--seconds", type=float, default=4.0)
    ap.add_argument("--clean", type=float, default=42.0,
                    help="round-trip PSNR (dB) that counts as 'no detail lost'")
    a = ap.parse_args()
    w, h = probe(a.clip)
    native = min(w, h)
    cands = [c for c in CANDIDATES if c < native]
    rows = [(c, roundtrip_psnr(a.clip, w, h, c, a.seconds)) for c in cands]
    print(f"{a.clip}: {w}x{h} (labelled {native}p)")
    for c, p in rows:
        print(f"  via {c}p: PSNR {p:6.2f} dB")
    if not rows:
        print("  nothing smaller to test"); return
    clean = [c for c, p in rows if p >= a.clean]
    if not clean:
        print(f"  effective: ~{native}p (no smaller size round-trips above {a.clean} dB)")
    else:
        print(f"  effective: ~{min(clean)}p (smallest size that round-trips above {a.clean} dB)")


if __name__ == "__main__":
    main()

A few choices worth explaining:

Grey only (format=gray). Chroma is already stored at half resolution in yuv420p, so it would blur the signal. Luma carries the detail you see.
area down, lanczos up. Area averaging is the honest way to shrink. Lanczos is a sharp upscaler, so a clean round trip really means "nothing was there", not "the upscaler was blurry too".
"p" means the short side. A vertical 1080p clip is 1080 pixels wide, so candidates scale the width.
First 4 seconds by default. That's half of an 8-second clip, and it keeps a 4K run fast. Use --seconds 8 for the whole thing.

Testing it on clips where I know the answer

To check that it works, I need clips whose true detail I know. This script makes three 1080×1920 clips from the same busy test pattern (ffmpeg's testsrc2 plus a little noise). One really has 1080p detail. The other two were shrunk to 480 and 720 wide and then stretched back to 1080×1920 with bicubic scaling, which is what a careless export does.

#!/bin/sh
# Synthetic 1080x1920 test clips: one with real 1080p detail, two upscaled from smaller sizes.
set -e
SRC="testsrc2=size=1080x1920:rate=30,noise=alls=10:allf=t"
ffmpeg -v error -y -f lavfi -i "$SRC" -t 4 -c:v libx264 -crf 16 -pix_fmt yuv420p native1080.mp4
ffmpeg -v error -y -f lavfi -i "$SRC" -t 4 -vf "scale=480:854:flags=area,scale=1080:1920:flags=bicubic" \
  -c:v libx264 -crf 16 -pix_fmt yuv420p up_from_480.mp4
ffmpeg -v error -y -f lavfi -i "$SRC" -t 4 -vf "scale=720:1280:flags=area,scale=1080:1920:flags=bicubic" \
  -c:v libx264 -crf 16 -pix_fmt yuv420p up_from_720.mp4

All three files report the same size to ffprobe. Here's what the script printed (ffmpeg 7.1, Debian):

native1080.mp4: 1080x1920 (labelled 1080p)
  via 480p: PSNR  30.41 dB
  via 720p: PSNR  32.06 dB
  effective: ~1080p (no smaller size round-trips above 42.0 dB)
up_from_480.mp4: 1080x1920 (labelled 1080p)
  via 480p: PSNR  45.36 dB
  via 720p: PSNR  48.76 dB
  effective: ~480p (smallest size that round-trips above 42.0 dB)
up_from_720.mp4: 1080x1920 (labelled 1080p)
  via 480p: PSNR  38.86 dB
  via 720p: PSNR  44.95 dB
  effective: ~720p (smallest size that round-trips above 42.0 dB)

Three files, one label, three different answers, and each one is right. The real 1080p clip loses about 30 dB worth of detail when squeezed through 480 wide. The clip that was secretly 480p barely notices.

Then I re-encoded all three at CRF 28 (ffmpeg -i X.mp4 -c:v libx264 -crf 28 -preset veryfast q28_X.mp4), which is closer to what a social app does to an upload. Output condensed to one line per file:

q28_native1080.mp4:  via 480p 34.84 dB, via 720p 37.31 dB -> ~1080p
q28_up_from_480.mp4: via 480p 46.87 dB, via 720p 51.25 dB -> ~480p
q28_up_from_720.mp4: via 480p 41.85 dB, via 720p 47.73 dB -> ~720p

Still right, but look at the 720p case: 41.85 dB through 480 wide, just under the 42 dB line. Heavy compression smooths fine detail away, so a heavily compressed clip starts to look "lower resolution" to this test. That's honest, because it's true of what you see, but it means the threshold isn't a law of nature. If you're near the line, look at the curve, not just the verdict.

How to read the result on a real clip

Run it on the file you downloaded, before any app re-compresses it:

python3 eff_res.py my_bama_bound_4k.mp4 --seconds 8

What it measures is detail present in the picture, which is not quite the same as "was it upscaled". Three things lower the effective number without anyone cheating:

A soft source photo. The generator works from one photo of one adult (photo requirements). A blurry or small photo can't produce fine skin and fabric detail at any output size.
Smooth content. A sunny lawn and a flat red banner have big areas with little texture. A clip with less texture round-trips better at small sizes, so it's best to compare two resolutions of the same scene rather than judge one in isolation.
Motion blur. The banner moves, and blurred frames carry less detail. Averaging over all frames dilutes this, and --seconds lets you pick a calmer stretch.

So the useful experiment is: make the same photo at two resolutions, run both, and see whether the higher one's curve actually moves. If 4K round-trips cleanly through 1080, the extra pixels on your file aren't carrying extra detail for that clip.

Do you even need it?

For most people posting this meme, the honest answer comes before any measurement: where will it be watched? Most phone screens are somewhere around 1,080 to 1,440 physical pixels wide, and the app you post to will re-encode whatever you upload. The higher tiers matter when you'll crop or zoom, show it on a big screen, or pull still frames from it.

On bamabound.app, 480p is the default and the cheapest at $7.99 per clip, and the higher tiers are there for those cases (prices, FAQ). The clip itself is the same 8-second scene at every tier: one photo in, a words-only red banner that reads I'M BAMA BOUND, generated cheering, no prompt box. Higher tiers also spend more credits per clip if you're using a pack, so check the pricing table before you spend a pack on 4K.

Limits of this script

It needs ffmpeg/ffprobe on PATH and Python 3.8+. No other dependencies.
PSNR is a blunt measure. It's fine for "is the detail there", but it isn't a quality score.
The 42 dB threshold was tuned on these test clips. Treat it as a default, and use --clean to change it.
It tests candidate sizes 480, 720, 1080, 1440 and 2160. Odd sizes in between will round to the nearest one below.

If you try it on a clip and the result surprises you, I'd like to hear about it. The help page has the support address.

Why Won't My Tiny Desk AI Clip Send in a Group Chat? Fitting a Video Under a File-Size Cap With Two-Pass ffmpeg (Tested Python)

Peiguan — Wed, 04 Nov 2026 04:12:04 +0000

Checked November 4, 2026 (12:00 CST, UTC+8) against the live pages linked below. I build tinydeskoutstanding.video, an independent studio that turns one to five photos into a 15-second vertical parody of the "Outstanding" Tiny Desk meme. The script here was written for this post and run on a synthetic test clip, not on a customer's video.

A question people ask assistants after they've made one of these clips: "My Tiny Desk AI video is too big to send. How do I make it smaller without it looking terrible?" Discord, email, some work chats and a few messaging apps have an upload cap. The clip is short, so the fix is usually one ffmpeg command away, as long as you pick the bitrate from the cap instead of guessing a CRF and trying again.

This post is a small tested Python wrapper around two-pass x264 at a computed bitrate, plus the numbers it produced on a test clip.

Why CRF is the wrong knob for a size cap

-crf 23 asks for a quality and lets the size land wherever it lands. That's usually what you want, but with a hard cap it turns into a loop of encode, check, encode again. Bitrate is the knob that maps to size:

size_bits ≈ (video_kbps + audio_kbps) × 1000 × duration_s

So for a cap you solve for video_kbps, leave a few percent for the MP4 container, and run two passes: the first pass measures where the bits are needed (the laughing close-up, the sax lift), the second spends the budget there. A single pass at a fixed bitrate tends to overshoot or waste bits on the easy frames.

The duration is fixed for this meme: every clip from my studio is "15-second vertical video, 9:16, at 480p or 720p, with sound" (FAQ). That makes the budget easy to reason about: 8 MiB over 15 s is about 4.3 Mb/s total.

The script

#!/usr/bin/env python3
"""Re-encode a clip so the output file stays under a size cap.

Usage: python3 fit_size.py in.mp4 out.mp4 --max-mb 8 [--audio-kbps 96] [--max-height 0]

Bitrate math: total_bits = max_bytes * 8 * safety; video_kbps = total_bits / duration / 1000 - audio_kbps.
Encodes two-pass libx264, checks the real size, and retries with a lower
bitrate if the container overhead pushed it over the cap.
"""
import argparse, json, os, subprocess, sys, tempfile

def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-show_entries",
                          "format=duration,size:stream=codec_type,width,height",
                          "-of", "json", path], capture_output=True, text=True, check=True).stdout
    j = json.loads(out)
    v = next(s for s in j["streams"] if s["codec_type"] == "video")
    has_audio = any(s["codec_type"] == "audio" for s in j["streams"])
    return float(j["format"]["duration"]), int(j["format"]["size"]), v["width"], v["height"], has_audio

def plan(max_bytes, duration, audio_kbps, safety=0.96):
    total_kbps = max_bytes * 8 * safety / duration / 1000
    video_kbps = int(total_kbps - audio_kbps)
    if video_kbps < 150:
        raise SystemExit(f"cap too small: only {video_kbps} kb/s left for video; "
                         f"lower --audio-kbps or --max-height, or raise --max-mb")
    return video_kbps

def encode(src, dst, video_kbps, audio_kbps, has_audio, max_height):
    vf = ["-vf", f"scale=-2:'min({max_height},ih)'"] if max_height else []
    with tempfile.TemporaryDirectory() as tmp:
        log = os.path.join(tmp, "x264")
        common = ["ffmpeg", "-v", "error", "-y", "-i", src, *vf, "-c:v", "libx264",
                  "-preset", "medium", "-b:v", f"{video_kbps}k", "-pix_fmt", "yuv420p",
                  "-passlogfile", log]
        subprocess.run(common + ["-pass", "1", "-an", "-f", "mp4", os.devnull], check=True)
        audio = ["-c:a", "aac", "-b:a", f"{audio_kbps}k"] if has_audio else ["-an"]
        subprocess.run(common + ["-pass", "2", *audio, "-movflags", "+faststart", dst], check=True)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("src"); ap.add_argument("dst")
    ap.add_argument("--max-mb", type=float, required=True, help="cap in MiB (1 MiB = 1048576 bytes)")
    ap.add_argument("--audio-kbps", type=int, default=96)
    ap.add_argument("--max-height", type=int, default=0, help="downscale if taller, 0 = keep")
    a = ap.parse_args()
    max_bytes = int(a.max_mb * 1024 * 1024)
    duration, size, w, h, has_audio = probe(a.src)
    print(f"input: {w}x{h}, {duration:.2f} s, {size/1048576:.2f} MiB")
    if size <= max_bytes and not a.max_height:
        print("already under the cap; copying without re-encoding")
        subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", a.src, "-c", "copy",
                        "-movflags", "+faststart", a.dst], check=True)
        return
    kbps = plan(max_bytes, duration, a.audio_kbps if has_audio else 0)
    for attempt in range(1, 4):
        print(f"attempt {attempt}: video {kbps} kb/s, audio {a.audio_kbps if has_audio else 0} kb/s")
        encode(a.src, a.dst, kbps, a.audio_kbps, has_audio, a.max_height)
        out = os.path.getsize(a.dst)
        print(f"  -> {out/1048576:.2f} MiB ({out} bytes, cap {max_bytes})")
        if out <= max_bytes:
            print("OK under cap"); return
        kbps = int(kbps * max_bytes / out * 0.97)
    sys.exit("still over the cap after 3 attempts")

if __name__ == "__main__":
    main()

Notes on the choices:

safety=0.96 reserves 4 % for container overhead. On the test runs below the outputs landed at 92 to 94 % of the cap, so the retry loop never fired. It's there for clips with a lot of tiny frames where the overhead is larger.
It refuses rather than producing mush. Below 150 kb/s of video a 720×1280 clip falls apart, so the script tells you to drop the height or the audio bitrate instead.
It copies when the file already fits. No point re-encoding a 480p clip that's under the cap; -c copy with +faststart just moves the index to the front so it starts playing before it has fully downloaded.
MiB, not MB. --max-mb 8 means 8 × 1,048,576 bytes. Some apps mean 8,000,000. If you're right at the edge, pass a slightly smaller number.

Tested on a synthetic clip

I made a stand-in for a 720p download: testsrc2 at 720×1280, 30 fps, 15 s, with a sine tone as audio, encoded at CRF 18 (about 8.9 MiB). That's harder to compress than a real clip in some ways (moving test pattern, fine detail everywhere) and easier in others (no faces). Then:

ffmpeg -f lavfi -i "testsrc2=size=720x1280:rate=30:duration=15" \
       -f lavfi -i "sine=frequency=330:duration=15,volume=0.5" \
       -filter_complex "[1:a]aformat=channel_layouts=stereo[a]" -map 0:v -map "[a]" \
       -c:v libx264 -pix_fmt yuv420p -crf 18 -c:a aac -b:a 128k -shortest test720.mp4

for mb in 8 4 2; do python3 fit_size.py test720.mp4 out_$mb.mp4 --max-mb $mb; done

Output (trimmed to the result lines):

input: 720x1280, 15.00 s, 8.93 MiB
attempt 1: video 4198 kb/s, audio 96 kb/s
  -> 7.78 MiB (8158417 bytes, cap 8388608)
attempt 1: video 2051 kb/s, audio 96 kb/s
  -> 3.86 MiB (4048541 bytes, cap 4194304)
attempt 1: video 977 kb/s, audio 96 kb/s
  -> 1.96 MiB (2052414 bytes, cap 2097152)

And the two guard cases:

$ python3 fit_size.py test480.mp4 out_copy.mp4 --max-mb 8
input: 480x854, 15.00 s, 2.77 MiB
already under the cap; copying without re-encoding

$ python3 fit_size.py test720.mp4 x.mp4 --max-mb 0.25
cap too small: only 38 kb/s left for video; lower --audio-kbps or --max-height, or raise --max-mb

For a really small cap, drop to 480p height and trim the audio:

$ python3 fit_size.py test720.mp4 out_1.mp4 --max-mb 1.5 --audio-kbps 64 --max-height 854
attempt 1: video 741 kb/s, audio 64 kb/s
  -> 1.45 MiB (1523871 bytes, cap 1572864)

To see what each cap costs in picture, I compared each output with the source using ffmpeg's ssim filter (outputs scaled back to 720×1280 first):

Cap	Video bitrate	SSIM vs source
4 MiB	2051 kb/s	0.990
2 MiB	977 kb/s	0.980
1.5 MiB at 854p	741 kb/s	0.955

SSIM on a test pattern isn't a verdict on faces, so treat it as "relative damage", not "looks fine". The pattern is what matters: halving the size from 4 to 2 MiB cost much less than squeezing a 720p clip down to 1.5 MiB, and at that point downscaling first is the better trade.

Where the bits matter in this clip

The desk-concert parody runs as a band shot, a laughing close-up and a sax lift. When you squeeze the file, check those three moments in particular:

the lead's face in the wide band shot, which is small to begin with,
teeth and the hair edge in the close-up, where blocking shows first,
the last frame, which people screenshot.

The check-before-posting guide lists the same weak spots for the generated clip itself. Run it once on the original and once on your squeezed copy.

Do you even need 720p for this?

If the destination is a group chat, probably not. My own 480p or 720p guide says it plainly: "Messaging apps compress video again before sending," and 480p is the default for phone feeds. A 480p download is often under the cap already, which is the -c copy path above. If you made a 720p clip for a TV and also want to send it to the group, run this script for the chat copy and keep the original for the big screen.

The clip itself

On my studio, one clip is $9.99 at 480p or $12.99 at 720p, the same for one face or five (pricing, checked today). There are no free clips. A re-encode like the one above is something you do afterwards on your own machine; the studio doesn't add a watermark, so there's nothing to crop out before you send it.

Why Does My Hit the Road Dude Clip Look Washed Out After Editing? Checking Color Range Tags With ffprobe and Python

Peiguan — Wed, 04 Nov 2026 01:26:40 +0000

Checked November 4, 2026 (09:00 CST, UTC+8) against the live pages linked below. I build hittheroaddude.app, an independent studio that remakes the Hit the Road Dude (State Property) pickup-window clip from one photo. The script in this post works on any H.264 MP4. It doesn't depend on my studio.

A question I keep getting, in different words: "My Hit the Road Dude clip looked fine on my phone, then I ran it through an editor and now it's grey and flat." Or the reverse: "the black truck interior turned into a black blob and the sky is blown out."

Neither one is usually the AI's fault. The pixels didn't change. What changed is how a player was told to read them. Every H.264 file carries (or fails to carry) a few small colour tags, and when the tags and the pixels disagree, the same file looks different in every app.

This post shows how to check that in 15 seconds with ffprobe, a raw read of the luma plane, and a 90-line Python script. It also shows the two fixes, and which one re-encodes.

The short version

Limited range ("tv") means luma lives between 16 and 235. That's what almost all phone and web video uses.
Full range ("pc") means luma uses 0 to 255. Some cameras, screen recorders and image-to-video exports write this.
If a limited file is tagged full, black is drawn at 16 instead of 0 and it looks washed out.
If a full file is tagged limited, everything under 16 and over 235 clips: crushed blacks, blown whites.
If the file is untagged, each app guesses. That's why it can look right in one place and wrong in the next.

You can't tell which of these you have by looking. You can measure it.

Step 1: read the tags

ffprobe -v error -select_streams v:0 \
  -show_entries stream=pix_fmt,color_range,color_space,color_primaries,color_transfer \
  -of default=nw=1 clip.mp4

A healthy phone-ready file prints something like color_range=tv, color_space=bt709, color_primaries=bt709, color_transfer=bt709. unknown on any of these lines means "nobody said, the app will guess."

Step 2: look at the pixels, not just the label

Tags are claims. To check them, read the actual Y (luma) plane and count how many samples fall outside 16..235. Two things matter here:

Use the raw plane. -vf extractplanes=y -pix_fmt gray hands you the stored luma bytes as they are. If you convert to RGB first, ffmpeg applies a range conversion and you end up measuring your own conversion.
Use a share, not min/max. My first version used signalstats YMIN/YMAX. x264 ringing at sharp edges (text, the window frame) pushes a few samples to 0 or 255 even in a perfectly normal limited-range file, so min/max said "full range" for everything. Counting the share of samples outside 16..235 and using a 1% threshold fixed that.

The script

#!/usr/bin/env python3
"""color_check.py - why does my vertical clip look washed out or too contrasty?

Compares the colour tags an MP4 declares (ffprobe) with the luma levels its
pixels actually use (raw Y plane sampled at 2 fps), then prints a fix.

usage: python3 color_check.py clip.mp4
exit 0 = tags present and consistent, 1 = something to fix
"""
import json, subprocess, sys
import numpy as np

UNSET = ("unknown", "unspecified", "reserved", None)


def probe(path):
    out = subprocess.run(
        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
         "stream=codec_name,width,height,pix_fmt,color_range,color_space,"
         "color_primaries,color_transfer", "-of", "json", path],
        check=True, capture_output=True, text=True).stdout
    return json.loads(out)["streams"][0]


def luma_outside_limited(path, w, h):
    """Share of luma samples below 16 or above 235, read straight from the Y plane."""
    raw = subprocess.run(
        ["ffmpeg", "-v", "error", "-i", path, "-an", "-vf", "fps=2,extractplanes=y",
         "-f", "rawvideo", "-pix_fmt", "gray", "-"],
        check=True, capture_output=True).stdout
    y = np.frombuffer(raw, np.uint8)
    frames = y.size // (w * h)
    return float(np.mean((y < 16) | (y > 235))), frames


def main(path):
    s = probe(path)
    share, frames = luma_outside_limited(path, s["width"], s["height"])
    tags = {k: s.get(k) for k in
            ("color_range", "color_space", "color_primaries", "color_transfer")}
    print(f"{path}: {s['codec_name']} {s['pix_fmt']} {s['width']}x{s['height']}, "
          f"{frames} frames sampled")
    for k, v in tags.items():
        print(f"  {k:<16} {v or 'unknown'}")
    print(f"  luma outside 16..235: {share:.1%}")

    uses_full = share > 0.01          # >1% of samples outside limited range
    problems = []
    missing = [k for k, v in tags.items() if v in UNSET]
    if missing:
        problems.append("untagged " + ", ".join(missing) + ": each app guesses")
    if tags["color_range"] == "tv" and uses_full:
        problems.append("tagged limited (tv) but pixels use full range: "
                        "blacks crush and whites clip")
    if tags["color_range"] == "pc" and not uses_full:
        problems.append("tagged full (pc) but pixels sit in 16..235: looks washed out")
    if not problems:
        print("OK: tags present and consistent with the pixels")
        return 0
    for p in problems:
        print("FIX:", p)
    flag = 1 if uses_full else 0
    print("\nRe-tag only (no re-encode, H.264, BT.709):")
    print(f"  ffmpeg -i {path} -c copy -bsf:v h264_metadata=colour_primaries=1:"
          f"transfer_characteristics=1:matrix_coefficients=1:video_full_range_flag={flag} "
          f"fixed.mp4")
    if uses_full:
        print("Or convert to limited range, the safe default for social apps "
              "(re-encodes video, copies audio):")
        print(f"  ffmpeg -i {path} -vf \"scale=in_range=full:out_range=limited,"
              f"format=yuv420p,setparams=range=tv:color_primaries=bt709:"
              f"color_trc=bt709:colorspace=bt709\" -c:v libx264 -crf 18 -c:a copy "
              f"limited.mp4")
    return 1


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit(__doc__)
    sys.exit(main(sys.argv[1]))

It needs Python 3, numpy and ffmpeg/ffprobe on your PATH (pip install numpy). Sampling at 2 fps means a 15-second clip is 30 frames, which took under half a second on my box.

What it printed on four test files

I made four 15-second 720×1280 test clips with testsrc2, a black bar and a white bar, and a synthetic voice track. One is untagged, one is tagged correctly, one is limited range tagged as full, and one is full range tagged as limited. Here's the output, trimmed:

untagged.mp4: h264 yuv420p 720x1280, 30 frames sampled
  color_range      unknown
  ...
  luma outside 16..235: 0.0%
FIX: untagged color_range, color_space, color_primaries, color_transfer: each app guesses
  ffmpeg -i untagged.mp4 -c copy -bsf:v h264_metadata=colour_primaries=1:transfer_characteristics=1:matrix_coefficients=1:video_full_range_flag=0 fixed.mp4

good.mp4: ... color_range tv ... luma outside 16..235: 0.0%
OK: tags present and consistent with the pixels

washed.mp4: h264 yuvj420p ... color_range pc ... luma outside 16..235: 0.0%
FIX: tagged full (pc) but pixels sit in 16..235: looks washed out

crushed.mp4: ... color_range tv ... luma outside 16..235: 25.0%
FIX: tagged limited (tv) but pixels use full range: blacks crush and whites clip

The 25% on crushed.mp4 is the black and white bars: a quarter of the frame was stored at full-range values under a limited-range label.

Fix A: re-tag only (no re-encode)

If the pixels are fine and only the label is wrong or missing, rewrite the label. The h264_metadata bitstream filter edits the stream's VUI fields in place, with -c copy, so nothing is re-encoded and the picture is bit-identical:

ffmpeg -i washed.mp4 -c copy \
  -bsf:v h264_metadata=colour_primaries=1:transfer_characteristics=1:matrix_coefficients=1:video_full_range_flag=0 \
  fixed.mp4

The 1s are the H.264 code points for BT.709, and video_full_range_flag is 0 for limited and 1 for full. After this, washed.mp4 and crushed.mp4 (re-tagged with flag 1) both printed OK.

Fix B: convert to limited range (re-encodes)

Re-tagging a full-range file as full is correct, but some apps and editors still handle full-range H.264 badly. If you're going to post it anyway, the safer move is to convert the pixels to limited range once:

ffmpeg -i crushed.mp4 \
  -vf "scale=in_range=full:out_range=limited,format=yuv420p,setparams=range=tv:color_primaries=bt709:color_trc=bt709:colorspace=bt709" \
  -c:v libx264 -crf 18 -c:a copy limited.mp4

Two details that cost me time:

in_range=full is needed here because the file claims to be limited. Without it, scale trusts the wrong tag and converts nothing.
On ffmpeg 7.1, passing -color_primaries bt709 -color_trc bt709 as output options did not end up in the H.264 VUI for me (ffprobe still said unknown). Setting them on the frames with setparams did. Check with ffprobe after any fix rather than trusting the command line.

The result was 15.000 s with video and audio both present, and the checker printed OK with 0.0% outside 16..235.

Where this fits with a Hit the Road Dude clip

My studio's output is a fixed format: every clip is "15 seconds, vertical 9:16, at 480p or 720p, with sound" (FAQ), with a newly generated voice (original audio or a new voice). I'm not going to claim what tags any particular downloaded file carries, because players, browsers and "save to Photos" paths can rewrite containers. Run the checker on the file you actually have, and run it again on the file your editor exports. The second run is where problems usually show up.

A few practical notes:

Check before and after editing. If the original says OK and the export doesn't, your editor or a re-save step changed the tags.
Re-tagging is free, so try it first. It doesn't touch the picture, so you can't make things worse. Keep the original.
Resolution doesn't change any of this. 480p ($9.99) and 720p ($12.99) differ in sharpness, not colour handling (480p or 720p, pricing). Paying for 720p won't fix a range mismatch, and re-tagging works the same on both.
A washed-out look is not a failed render. If the colours are fine in one player and wrong in another, it's a labelling problem. The help page covers the things that really are generation issues (faces, mouths, hands).

Then do the normal pre-post pass from check before posting: the "State?" pause, the send-off, the face, and a caption that says it's an AI remake.

Recap

ffprobe the four colour tags.
Measure the share of luma outside 16..235 from the raw Y plane.
Tags missing or wrong, pixels fine: re-tag with h264_metadata and -c copy.
Full-range pixels you want to post safely: convert with scale=in_range=full:out_range=limited, then set tags with setparams.
ffprobe again. Trust the output, not the command line.