How to add a circular progress ring with Claude

Add a circular progress ring to input.mp4: from 0.5 seconds, a black disc at 65% opacity, 50% of the frame width across, centered across and 74% down the frame. Inside it, a ring 6% of the frame width thick whose outer edge sits 4.5% of the frame width in from the disc's edge: a faint white track (white at 27% opacity) all the way round, and over it a yellow (255, 214, 0) arc with round ends that starts at 12 o'clock and fills clockwise to 92% of the circle over 2 seconds, easing out (share = 0.92 * (1 - (1 - p)^3), p going 0 to 1, so it is full at 2.5 seconds). In the middle of the disc, the percentage in bold yellow (255, 214, 0), 13% of the frame width tall, counts up with the arc from 0% to 92% (round(100 * share) followed by %). Under the disc, "SAW BRIGHTER SKIN" in bold white, 5% of the frame width tall, on a black rounded pill at 65% opacity, centered across. Draw the ring at 3x size and scale it down so its edges are smooth. Nothing shows before 0.5 seconds, and the ring holds at 92% until 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
"""Circular progress ring: a yellow ring fills clockwise from 12 o'clock while the percentage in its center counts up to 92%.

Usage: python3 circular-progress-ring.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

TARGET = 92                  # the percentage it lands on
LABEL = "SAW BRIGHTER SKIN"  # the line under the ring
START = 0.5                  # second the ring appears, empty, at 0%
FILL = 2.0                   # seconds the fill takes
SIZE = 0.50                  # ring diameter as a share of the frame width
THICKNESS = 0.06             # ring thickness as a share of the frame width
X, Y = 0.5, 0.74             # ring center (0-1 across and down the frame)
COLOR = (255, 214, 0)        # the filled part of the ring and the percentage
TRACK = (255, 255, 255, 70)  # the unfilled part (last number is opacity, 0-255)
SS = 3                       # draw the ring this many times larger, then shrink it, for smooth edges
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 progress(t):
    """Share of the way to TARGET at t: fast at first, easing out (cubic) as it lands."""
    p = min(max((t - START) / FILL, 0), 1)
    return 1 - (1 - p) ** 3


def ring(share):
    """The ring with `share` (0-1) of the full circle filled, as a square RGBA image."""
    d = round(w * SIZE) * SS
    stroke = round(w * THICKNESS) * SS
    img = Image.new("RGBA", (d, d))
    draw = ImageDraw.Draw(img)
    draw.ellipse([0, 0, d - 1, d - 1], fill=(0, 0, 0, 165))
    box = [stroke * 0.75, stroke * 0.75, d - stroke * 0.75, d - stroke * 0.75]
    draw.arc(box, 0, 360, fill=TRACK, width=stroke)
    if share > 0:
        end = -90 + 360 * share
        draw.arc(box, -90, end, fill=COLOR, width=stroke)
        r, c = (box[2] - box[0]) / 2 - stroke / 2, d / 2  # radius of the stroke's middle line
        for a in (-90, end):  # round caps on both ends
            x, y = c + r * math.cos(math.radians(a)), c + r * math.sin(math.radians(a))
            draw.ellipse([x - stroke / 2, y - stroke / 2, x + stroke / 2, y + stroke / 2], fill=COLOR)
    return img.resize((d // SS, d // SS), Image.LANCZOS)


def overlay(t):
    img = Image.new("RGBA", (w, h))
    if t < START:
        return img
    e = progress(t)
    r = ring(e * TARGET / 100)
    cx, cy = w * X, h * Y
    img.alpha_composite(r, (round(cx - r.width / 2), round(cy - r.height / 2)))
    draw = ImageDraw.Draw(img)
    draw.text((cx, cy), f"{round(e * TARGET)}%", font=digits, anchor="mm", fill=COLOR)
    label_y = cy + r.height / 2 + label.size * 1.4
    x0, y0, x1, y1 = draw.textbbox((cx, label_y), LABEL, font=label, anchor="mm")
    pad = label.size * 0.6
    draw.rounded_rectangle([x0 - pad, y0 - pad, x1 + pad, y1 + pad], radius=pad, fill=(0, 0, 0, 165))
    draw.text((cx, label_y), LABEL, font=label, anchor="mm", fill="white")
    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)
digits = ImageFont.truetype(FONT_FILE, round(w * 0.13))
label = ImageFont.truetype(FONT_FILE, round(w * 0.05))
render(src, out)