How to add a letter-spacing animation with Claude

Add a letter-spacing (tracking) animation to input.mp4 (540x960): the word "RADIANT" in white (255, 255, 255) Arial Bold (or any bold sans-serif), font size 59 pixels (11% of the frame width), centered horizontally with its vertical middle 144 pixels down (15% of the height). Draw it letter by letter. The gap between letters starts at -3 pixels (-0.05 times the font size, so the letters nearly touch) and widens to 29.5 pixels (0.5 times the font size) between 0.5 and 4.0 seconds, with sine ease-in-out easing ((1 - cos(pi * p)) / 2), then stays at that width to the end; the word stays centered as it widens. The word fades in linearly from invisible at 0.5 seconds to full opacity at 1.3 seconds and stays to the end. Behind the letters put a soft dark plum (40, 20, 60) shadow: the letter shapes blurred with a 5-pixel Gaussian blur at 90% opacity, fading with the text. Before 0.5 seconds the frame is untouched, and nothing below the title ever changes. Use Python with Pillow to draw the text (don't rely on ffmpeg's drawtext filter) and ffmpeg to put it on the video, keep the audio, the 30fps and the 6 second length, and save it as output.mp4.

#!/usr/bin/env python3
"""Letter-spacing animation: a title fades in with its letters packed tight, then they slowly spread wide apart.

Usage: python3 text-tracking-animation.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, ImageFilter, ImageFont

TEXT = "RADIANT"             # the title
START = 0.5                  # second the title starts fading in and spreading
FADE = 0.8                   # seconds the fade in takes
SPREAD = 3.5                 # seconds the letters take to spread to their widest
GAP = -0.05, 0.5             # gap between letters, in font sizes, before and after the spread
SIZE = 0.11                  # font size as a share of the frame width
Y = 0.15                     # title center (0-1 down the frame)
COLOR = (255, 255, 255)      # text color
SHADOW = (40, 20, 60)        # soft shadow color behind the letters
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, start, length):
    """0 before start, 1 after start + length, eased in and out between."""
    p = min(max((t - start) / length, 0), 1)
    return (1 - math.cos(math.pi * p)) / 2


def letters(t):
    """The title drawn on a clear layer, with the letter gap for time t."""
    layer = Image.new("RGBA", (w, h))
    draw = ImageDraw.Draw(layer)
    gap = font.size * (GAP[0] + (GAP[1] - GAP[0]) * progress(t, START, SPREAD))
    widths = [draw.textlength(ch, font=font) for ch in TEXT]
    x = (w - sum(widths) - gap * (len(TEXT) - 1)) / 2
    for ch, cw in zip(TEXT, widths):
        draw.text((x, h * Y), ch, font=font, anchor="lm", fill=COLOR)
        x += cw + gap
    return layer


def overlay(t):
    alpha = min(max((t - START) / FADE, 0), 1)
    img = Image.new("RGBA", (w, h))
    if alpha:
        text = letters(t)
        shadow = Image.new("RGBA", (w, h), SHADOW)
        shadow.putalpha(text.getchannel("A").filter(ImageFilter.GaussianBlur(5)).point(lambda a: a * 0.9))
        img = Image.alpha_composite(shadow, text)
        img.putalpha(img.getchannel("A").point(lambda a: round(a * alpha)))
    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))
render(src, out)