How to add an echo text with Claude

Add echo text to input.mp4: the word "GLOW" in Arial Black (or any heavy bold font) at a font size of 24% of the frame width, hot pink (235, 40, 120), centered across the frame with its center 22% of the way down. It fades in from transparent to fully opaque over 0.2 seconds starting at 0.5 seconds; nothing is on screen before that. Behind it are 4 copies of the word, drawn under it and centered across the frame. Copy i (1 to 4) has a font size of (1 - 0.08 i) times the word's, opacity 0.6 times 0.6^(i-1) (so 0.6, 0.36, 0.22, 0.13) and a Gaussian blur of 1.5 i pixels. Each copy starts hidden behind the word at 0.5 + 0.12 i seconds and slides straight up over 0.5 seconds with a cubic ease-out to sit 4 i% of the frame height above the word's center, then stays there to the end along with the word. 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
"""Echo text: a pink word appears and fainter, smaller, softer copies of it fan out upward behind it.

Usage: python3 echo-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, ImageFilter, ImageFont

TEXT = "GLOW"
START = 0.5                # second the word appears
FADE = 0.2                 # seconds the word takes to fade in
ECHOES = 4                 # copies trailing behind the word
DELAY = 0.12               # seconds between one copy setting off and the next
SPREAD = 0.5               # seconds each copy takes to slide out to its place
SIZE = 0.24                # word height as a share of the frame width
Y = 0.22                   # where the word's center sits (0 = top, 1 = bottom)
GAP = 0.04                 # how far up each copy sits from the one in front, as a share of the frame height
SHRINK = 0.08              # each copy is this much smaller than the one in front
OPACITY = 0.6              # opacity of the nearest copy; each farther copy has 0.6 times the one before
BLUR = 1.5                 # blur radius in pixels added per copy
COLOR = (235, 40, 120)     # text color, a hot pink
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 copy_of_word(i):
    """Copy i of the word (0 is the word itself), smaller, fainter and softer the farther back it is, cropped tight."""
    font = ImageFont.truetype(FONT_FILE, round(w * SIZE * (1 - SHRINK * i)))
    pad = font.size // 4
    x0, y0, x1, y1 = font.getbbox(TEXT)
    img = Image.new("RGBA", (x1 - x0 + 2 * pad, y1 - y0 + 2 * pad))
    alpha = 255 if i == 0 else round(255 * OPACITY * 0.6 ** (i - 1))
    ImageDraw.Draw(img).text((pad - x0, pad - y0), TEXT, font=font, fill=COLOR + (alpha,))
    return img.filter(ImageFilter.GaussianBlur(BLUR * i)) if i else img


def overlay(t):
    """The word fades in; copy i sets off from behind it i * DELAY later and eases up to i * GAP above it."""
    img = Image.new("RGBA", (w, h))
    if t < START:
        return img
    fade = min((t - START) / FADE, 1)
    for i in range(ECHOES, -1, -1):        # farthest copy first, so the word ends up on top
        p = min(max((t - START - i * DELAY) / SPREAD, 0), 1)
        if i and p == 0:
            continue
        y = h * Y - i * GAP * h * (1 - (1 - p) ** 3)   # ease out: fast start, soft stop
        layer = copies[i].copy()
        layer.putalpha(layer.getchannel("A").point(lambda a: round(a * fade)))
        img.alpha_composite(layer, (round((w - layer.width) / 2), round(y - layer.height / 2)))
    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)
copies = [copy_of_word(i) for i in range(ECHOES + 1)]
render(src, out)