How to add a wavy text with Claude

Add wavy text to input.mp4: "SO SMOOTH" on one line in a heavy bold font (Arial Black), yellow (255, 214, 0) with a dark purple (40, 12, 60) outline 1% of the frame width thick, the line 80% of the frame width wide, centered horizontally with its center 18% of the way down. It fades in from 0.5 seconds over 0.25 seconds and stays to the end. Move each letter up and down on its own along a sine wave: it rises and falls 3% of the frame height either side of its resting place, one full up-and-down takes 1.2 seconds, starting at 0.5 seconds going up, and each letter runs 0.7 radians behind the letter to its left (spaces don't count), so the bump travels left to right. Letters stay upright and keep their places across; only the text moves, the video behind stays untouched and nothing changes before 0.5 seconds. Draw the text with Python and Pillow (don't rely on ffmpeg's drawtext filter), keep the size and audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Wavy text: a bold yellow line appears and its letters bob up and down in a wave that ripples left to right.

Usage: python3 wavy-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, ImageDraw, ImageFont

TEXT = "SO SMOOTH"              # the line of text
START = 0.5                     # second the text appears
FADE = 0.25                     # seconds the text takes to fade in
Y = 0.18                        # resting center of the line (0 = top, 1 = bottom)
WIDTH = 0.8                     # line width as a share of the frame width
COLOR = (255, 214, 0)           # text color
OUTLINE = 0.01                  # dark outline thickness as a share of the frame width
OUTLINE_COLOR = (40, 12, 60)    # outline color
HEIGHT = 0.03                   # how far a letter rises and falls, as a share of the frame height
PERIOD = 1.2                    # seconds for one letter to go up, down and back
STEP = 0.7                      # how far behind its left neighbour each letter is in the wave, in radians
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 layout():
    """Each letter's picture and resting center, with the font sized so the line fills WIDTH."""
    stroke = round(w * OUTLINE)
    probe_font = ImageFont.truetype(FONT_FILE, 100)
    font = ImageFont.truetype(FONT_FILE, round(100 * w * WIDTH / probe_font.getlength(TEXT)))
    x = (w - font.getlength(TEXT)) / 2
    letters = []
    for ch in TEXT:
        adv = font.getlength(ch)
        if ch != " ":
            pad = stroke + font.size // 4
            img = Image.new("RGBA", (round(adv) + 2 * pad, font.size + 2 * pad))
            ImageDraw.Draw(img).text((img.width / 2, img.height / 2), ch, font=font, anchor="mm",
                                     fill=COLOR, stroke_width=stroke, stroke_fill=OUTLINE_COLOR)
            letters.append((img, x + adv / 2))
        x += adv
    return letters


def overlay(t):
    img = Image.new("RGBA", (w, h))
    if t < START:
        return img
    for i, (pic, cx) in enumerate(letters):
        # a sine wave per letter, each a little later than the one to its left, so the bump travels right
        lift = math.sin(2 * math.pi * (t - START) / PERIOD - i * STEP) * h * HEIGHT
        img.alpha_composite(pic, (round(cx - pic.width / 2), round(h * Y - lift - pic.height / 2)))
    alpha = min((t - START) / FADE, 1)
    if alpha < 1:
        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)
letters = layout()
render(src, out)