How to add a rotating word headline with Claude

Add a rotating word headline to input.mp4: from 0.4 seconds, the line "SKIN THAT FEELS" in white bold text with a thin black outline (text height 7.5% of the frame width), centered 9% of the way down, and directly under it one larger yellow (255, 214, 0) word with a black outline (14% of the frame width), centered across. The word cycles SMOOTH, BRIGHT, HYDRATED, RADIANT and back to SMOOTH, changing every 1.2 seconds (at 0.4, 1.6, 2.8, 4.0 and 5.2 seconds); each change takes 0.3 seconds with an ease-out, the old word rolling up and out while the new one rolls up in from below, both clipped to a strip the height of the word so they vanish at its edges like a slot machine. The top line never moves. Use Python with Pillow to draw the text 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
"""Rotating word headline: a fixed line stays put while the yellow word under it rolls through alternatives.

Usage: python3 rotating-word-headline.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

HEADLINE = "SKIN THAT FEELS"                          # the line that stays put
WORDS = ["SMOOTH", "BRIGHT", "HYDRATED", "RADIANT"]   # the words that take turns under it
START = 0.4              # second the headline appears
HOLD = 1.2               # seconds each word stays
TURN = 0.3               # seconds a word takes to roll out and the next to roll in
SIZE = 0.075             # headline text height as a share of the frame width
WORD_SIZE = 0.14         # rotating word height as a share of the frame width
Y = 0.09                 # center of the headline line (0 = top, 1 = bottom)
WORD_COLOR = (255, 214, 0)   # rotating word color
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 ease_out(p):
    p = min(max(p, 0), 1)
    return 1 - (1 - p) ** 3


def slot(t):
    """The word strip: the current word, or the old one rolling up and out while the new one rolls up in."""
    img = Image.new("RGBA", (w, slot_h))
    draw = ImageDraw.Draw(img)
    k = int((t - START) // HOLD)
    p = ease_out((t - START - k * HOLD) / TURN)
    words = [(WORDS[k % len(WORDS)], (1 - p) * slot_h)]
    if k > 0:
        words.append((WORDS[(k - 1) % len(WORDS)], -p * slot_h))
    for word, dy in words:
        draw.text((w / 2, slot_h / 2 + dy), word, font=word_font, anchor="mm", fill=WORD_COLOR,
                  stroke_width=round(w * 0.008), stroke_fill="black")
    return img


def overlay(t):
    img = Image.new("RGBA", (w, h))
    if t >= START:
        ImageDraw.Draw(img).text((w / 2, h * Y), HEADLINE, font=font, anchor="mm", fill="white",
                                 stroke_width=round(w * 0.006), stroke_fill="black")
        img.alpha_composite(slot(t), (0, round(h * Y + font.size * 0.6)))
    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)
font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
word_font = ImageFont.truetype(FONT_FILE, round(w * WORD_SIZE))
slot_h = round(word_font.size * 1.3)
render(src, out)