How to add trust badges with Claude

Add trust badges to input.mp4: a dark navy (15, 23, 42) rounded bar at 85% opacity, 94% of the frame width and 33% of the frame width tall with corners 4% of the frame width round, centered horizontally with its center 84% of the way down. It fades in over 0.25 seconds at 0.5 seconds. On it sit three badges, centered at 20%, 50% and 80% across: a white disc 16% of the frame width across with a green (22, 163, 74) icon drawn on it (a delivery truck, a padlock, a shield with a white tick), and under it two lines of white bold capitals 3.4% of the frame width tall: "FREE" / "SHIPPING", "SECURE" / "CHECKOUT" and "MONEY-BACK" / "GUARANTEE". Each badge (disc and label together, centered on the bar) pops in from nothing over 0.35 seconds with a slight overshoot, starting at 0.65, 1.0 and 1.35 seconds. Everything stays on to the end. Use Python with Pillow to draw it and ffmpeg to put it on the video (don't rely on ffmpeg's drawtext filter), keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Trust badges: a dark bar along the bottom where free shipping, secure checkout and money-back badges pop in one by one.

Usage: python3 trust-badges.py input.mp4 output.mp4
Needs ffmpeg and Pillow (pip install pillow).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

from PIL import Image, ImageDraw, ImageFont

BADGES = [("truck", "FREE", "SHIPPING"),         # (icon, top line, bottom line), left to right;
          ("lock", "SECURE", "CHECKOUT"),        # icons: truck, lock, shield
          ("shield", "MONEY-BACK", "GUARANTEE")]  # only claim what the store really offers
START = 0.5               # second the bar fades in
GAP = 0.35                # seconds between badges
POP = 0.35                # seconds each badge's pop takes
Y = 0.84                  # where the bar's center sits (0 = top, 1 = bottom)
BAR = (15, 23, 42, 217)   # bar color and opacity (0-255)
ICON = (22, 163, 74)      # icon color, on a white disc
FONTS = ["/System/Library/Fonts/Supplemental/Arial Bold.ttf",     # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/arialbd.ttf"]                          # Windows
FONT_FILE = next((f for f in FONTS if Path(f).exists()), None) or sys.exit("No bold font found: add one to FONTS")


def icon(kind, d):
    """A white disc d px across with the icon on it, drawn 4x larger and shrunk for smooth edges."""
    s = d * 4
    img = Image.new("RGBA", (s, s))
    draw = ImageDraw.Draw(img)
    draw.ellipse([0, 0, s - 1, s - 1], fill="white")
    u = s / 100  # icon drawn on a 100 x 100 grid
    box = lambda *p: [v * u for v in p]
    if kind == "truck":
        draw.rounded_rectangle(box(20, 34, 60, 64), radius=3 * u, fill=ICON)
        draw.polygon(box(62, 42, 74, 42, 82, 53, 82, 64, 62, 64), fill=ICON)
        for cx in (33, 71):
            draw.ellipse(box(cx - 8, 58, cx + 8, 74), fill=ICON, outline="white", width=round(3 * u))
    elif kind == "lock":
        draw.arc(box(35, 22, 65, 56), 180, 360, fill=ICON, width=round(7 * u))
        draw.line(box(38.5, 39, 38.5, 48), fill=ICON, width=round(7 * u))
        draw.line(box(61.5, 39, 61.5, 48), fill=ICON, width=round(7 * u))
        draw.rounded_rectangle(box(28, 46, 72, 78), radius=5 * u, fill=ICON)
        draw.ellipse(box(46, 55, 54, 63), fill="white")
        draw.rectangle(box(48, 60, 52, 70), fill="white")
    else:
        draw.polygon(box(50, 20, 76, 30, 74, 56, 50, 80, 26, 56, 24, 30), fill=ICON)
        draw.line(box(38, 50, 47, 59, 63, 41), fill="white", width=round(7 * u), joint="curve")
    return img.resize((d, d), Image.LANCZOS)


def badge(kind, top, bottom):
    """One badge: the icon disc with its two label lines underneath."""
    d, cw = round(w * 0.16), round(w * 0.30)
    font = ImageFont.truetype(FONT_FILE, round(w * 0.034))
    img = Image.new("RGBA", (cw, round(d + w * 0.11)))
    img.alpha_composite(icon(kind, d), ((cw - d) // 2, 0))
    draw = ImageDraw.Draw(img)
    draw.text((cw / 2, d + w * 0.035), top, font=font, anchor="mm", fill="white")
    draw.text((cw / 2, d + w * 0.078), bottom, font=font, anchor="mm", fill="white")
    return img


def ease_out_back(p):
    """0 -> 1 with a small overshoot past 1 before settling, which reads as a 'pop'."""
    p = min(max(p, 0), 1)
    return 1 + 2.70158 * (p - 1) ** 3 + 1.70158 * (p - 1) ** 2


def overlay(t):
    img = Image.new("RGBA", (w, h))
    fade = min(max((t - START) / 0.25, 0), 1)
    if fade == 0:
        return img
    bw, bh = round(w * 0.94), round(w * 0.33)
    bar = Image.new("RGBA", (w, h))
    ImageDraw.Draw(bar).rounded_rectangle([(w - bw) / 2, h * Y - bh / 2, (w + bw) / 2, h * Y + bh / 2],
                                          radius=w * 0.04, fill=BAR[:3] + (round(BAR[3] * fade),))
    img.alpha_composite(bar)
    for i, b in enumerate(badges):
        scale = ease_out_back((t - START - 0.15 - i * GAP) / POP)
        if scale > 0.02:
            s = b.resize((max(1, round(b.width * scale)), max(1, round(b.height * scale))), Image.LANCZOS)
            cx = w / 2 + (i - 1) * w * 0.30
            img.alpha_composite(s, (round(cx - s.width / 2), round(h * Y - s.height / 2)))
    return img


def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height,r_frame_rate:format=duration", "-of", "json", path]))
    s = info["streams"][0]
    num, den = s["r_frame_rate"].split("/")
    return s["width"], s["height"], s["r_frame_rate"], float(num) / float(den), float(info["format"]["duration"])


def render(src, out):
    """Draw overlay(t) on every frame of src and save to out, keeping the audio."""
    ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-i", src,
                           "-f", "rawvideo", "-pix_fmt", "rgba", "-s", f"{w}x{h}", "-r", rate, "-i", "-",
                           "-filter_complex", "[0:v][1:v]overlay=shortest=1,format=yuv420p[v]",
                           "-map", "[v]", "-map", "0:a?", "-c:v", "libx264", "-crf", "18", "-c:a", "copy", out],
                          stdin=subprocess.PIPE)
    for i in range(math.ceil(duration * fps)):
        ff.stdin.write(overlay(i / fps).tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


src, out = sys.argv[1:3]
w, h, rate, fps, duration = probe(src)
badges = [badge(*b) for b in BADGES]
render(src, out)