How to add a stretchy text with Claude

Add stretchy text to input.mp4: two lines in white (255, 255, 255) Arial Black with a dark purple (40, 12, 60) outline 1.5% of the frame width thick, centered horizontally. "SKIN" sits with its baseline 17% of the way down and "BOUNCE" with its baseline 27.5% down; the font size makes "BOUNCE" 80% of the frame width wide, and "SKIN" uses the same size. Animate each letter on its own, scaled from its bottom center on the baseline: the first letter of SKIN starts at 0.4 seconds and the first of BOUNCE at 0.8 seconds, each next letter 0.05 seconds after the one before. A letter takes 0.5 seconds to land, going through these (time, width scale, height scale) keyframes with cosine easing between them: (0, 0.3, 2.2) tall and thin, (0.35, 1.4, 0.55) squashed flat, (0.6, 0.9, 1.2), (0.8, 1.05, 0.95), (1, 1, 1); it fades in over the first 15% of that. At 3.2 seconds the letters leave one by one in reading order, 0.05 seconds apart, each over 0.4 seconds: squash to (1.35, 0.6) at 30% of the way, then stretch to (0.3, 2.8) at the end while rising 12% of the frame height (speeding up) and fading out over the last 70%. Nothing shows before 0.4 seconds, and the frame is untouched once every letter has left. 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
"""Stretchy text: each letter shoots up tall and thin, squashes flat, springs back to shape, then stretches up and away.

Usage: python3 stretchy-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

LINES = [("SKIN", 0.4, 0.17),     # (word, second its first letter lands, where its baseline sits: 0 = top, 1 = bottom)
         ("BOUNCE", 0.8, 0.275)]
STAGGER = 0.05            # seconds between one letter and the next
IN = 0.5                  # seconds a letter takes to land and settle
OUT_START = 3.2           # second the letters start to leave
OUT = 0.4                 # seconds a letter takes to leave
WIDTH = 0.8               # the longest word's width as a share of the frame width
COLOR = (255, 255, 255)   # letter color
OUTLINE = 0.015           # dark outline thickness as a share of the frame width
OUTLINE_COLOR = (40, 12, 60)
# (time 0-1, width scale, height scale): tall and thin, squashed flat, a smaller stretch, then settled
LAND = [(0, 0.3, 2.2), (0.35, 1.4, 0.55), (0.6, 0.9, 1.2), (0.8, 1.05, 0.95), (1, 1, 1)]
# a quick squash, then a tall stretch that rises off the top as it fades
LEAVE = [(0, 1, 1), (0.3, 1.35, 0.6), (1, 0.3, 2.8)]
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 letters():
    """Every letter as its own image, with its settled center x, baseline y and start time."""
    stroke = round(w * OUTLINE)
    longest = max((word for word, _, _ in LINES), key=len)
    probe_font = ImageFont.truetype(FONT_FILE, 100)
    font = ImageFont.truetype(FONT_FILE, round(100 * w * WIDTH / probe_font.getlength(longest)))
    out = []
    for word, start, y in LINES:
        x = (w - font.getlength(word)) / 2
        for i, ch in enumerate(word):
            x0, y0, x1, y1 = font.getbbox(ch, stroke_width=stroke)
            img = Image.new("RGBA", (x1 - x0, y1 - y0))
            ImageDraw.Draw(img).text((-x0, -y0), ch, font=font, fill=COLOR,
                                     stroke_width=stroke, stroke_fill=OUTLINE_COLOR)
            advance = font.getlength(ch)
            out.append((img, x + advance / 2, h * y, start + i * STAGGER, OUT_START + len(out) * STAGGER))
            x += advance
    return out


def shape(keys, p):
    """Width and height scale at time p (0-1) along keyframes, eased between each pair."""
    for (t0, sx0, sy0), (t1, sx1, sy1) in zip(keys, keys[1:]):
        if p <= t1:
            k = (1 - math.cos(math.pi * (p - t0) / (t1 - t0))) / 2
            return sx0 + (sx1 - sx0) * k, sy0 + (sy1 - sy0) * k
    return keys[-1][1:]


def overlay(t):
    img = Image.new("RGBA", (w, h))
    for pic, cx, base, start, leave in pictures:
        if t < start or t >= leave + OUT:
            continue
        if t < leave:
            p = min((t - start) / IN, 1)
            sx, sy = shape(LAND, p)
            fade, rise = min(p / 0.15, 1), 0
        else:
            p = (t - leave) / OUT
            sx, sy = shape(LEAVE, p)
            fade, rise = 1 - max(p - 0.3, 0) / 0.7, h * 0.12 * p * p
        letter = pic.resize((max(1, round(pic.width * sx)), max(1, round(pic.height * sy))), Image.LANCZOS)
        if fade < 1:
            letter.putalpha(letter.getchannel("A").point(lambda a: a * fade))
        img.alpha_composite(letter, (round(cx - letter.width / 2), round(base - rise - letter.height)))
    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)
pictures = letters()
render(src, out)