How to add a hollow outline text with Claude

Add hollow outline text to input.mp4: the word "GLOW" in Arial Black (or another heavy bold font) at a font size of 25% of the frame width, centered horizontally and 12% down the frame. Draw only its outline, 4 pixels thick, in pink (255, 45, 140), with the letters see-through inside; the outline fades in from 0.5 to 0.8 seconds. From 1.5 to 2.7 seconds the insides of the letters fill with the same pink, a hard edge sweeping from the left edge of the word to the right with ease-in-out, and the word stays solid pink to the end. Use Python with Pillow to draw the text (don't use ffmpeg's drawtext filter) and ffmpeg to put it on the video, keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Hollow outline text: a big word appears as thin pink outlines only, then fills solid pink from left to right.

Usage: python3 hollow-outline-text.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, ImageChops, ImageDraw, ImageFont

WORD = "GLOW"
Y = 0.12                      # word center, as a share of the frame height down
SIZE = 0.25                   # font size as a share of the frame width
COLOR = (255, 45, 140)        # outline and fill color
OUTLINE_WIDTH = 4             # outline thickness in pixels
APPEAR, FADE = 0.5, 0.3       # second the outline fades in, and how long the fade takes
FILL_START, FILL_TIME = 1.5, 1.2  # second the fill starts sweeping in, and how long it takes to cross
FONTS = ["/System/Library/Fonts/Supplemental/Arial Black.ttf",    # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/ariblk.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 letter_masks():
    """Two masks of the word: the outline ring alone, and the inside of the letters."""
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE))
    pos = (w / 2, h * Y)
    inside, outer = Image.new("L", (w, h)), Image.new("L", (w, h))
    ImageDraw.Draw(inside).text(pos, WORD, font=font, anchor="mm", fill=255)
    ImageDraw.Draw(outer).text(pos, WORD, font=font, anchor="mm", fill=255, stroke_width=OUTLINE_WIDTH, stroke_fill=255)
    return ImageChops.subtract(outer, inside), inside


def overlay(t):
    img = Image.new("RGBA", (w, h))
    fade = min(max((t - APPEAR) / FADE, 0), 1)
    if fade == 0:
        return img
    p = ease_in_out((t - FILL_START) / FILL_TIME)
    if p > 0:
        sweep = Image.new("L", (w, h))
        ImageDraw.Draw(sweep).rectangle([0, 0, left + (right - left) * p, h], fill=255)
        img.paste(COLOR + (255,), mask=ImageChops.multiply(inside, sweep))
    img.paste(COLOR + (255,), mask=ring.point(lambda v: round(v * fade)))
    return img


def ease_in_out(p):
    p = min(max(p, 0), 1)
    return p * p * (3 - 2 * p)


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)
ring, inside = letter_masks()
left, _, right, _ = inside.getbbox()
render(src, out)