How to add a trailer title with Claude

Add a movie-trailer title to input.mp4 (540x960). First dim the footage: lay a black layer over the whole frame whose opacity rises from 0 to 70% between 0.3 and 1.3 seconds (smoothstep easing), then stays at 70% to the end. Then write "RADIANCE" in white (255, 255, 255) Georgia Bold, font size 49 pixels, centered horizontally with its vertical middle 451 pixels down (47% of the height). Draw it letter by letter with a gap between letters of 0.35 times the font size at 0 seconds, widening linearly to 0.45 times the font size at 6 seconds. It fades in from invisible at 1.2 seconds to full opacity at 3.2 seconds (smoothstep easing). Under it, "COMING THIS WINTER" in the same white Georgia Bold at font size 19 pixels with 11-pixel gaps between letters, centered horizontally with its vertical middle 505 pixels down, fades in from 3.2 to 4.2 seconds. Both stay to the end. Before 0.3 seconds the frame is untouched. 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
"""Trailer title: the footage dims, then a widely spaced serif title slowly fades in and drifts wider, like a movie trailer.

Usage: python3 trailer-title.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

TITLE = "RADIANCE"           # the big title
TAGLINE = "COMING THIS WINTER"  # the small line under it
DIM_START, DIM_END = 0.3, 1.3   # seconds the footage takes to dim
DIM = 0.7                    # how much of the light the dimming takes away (0-1)
TITLE_IN = 1.2               # second the title starts fading in
TITLE_FADE = 2.0             # seconds the title's fade takes
TAGLINE_IN = 3.2             # second the tagline starts fading in
TAGLINE_FADE = 1.0           # seconds the tagline's fade takes
TITLE_SIZE = 0.09            # title font size as a share of the frame width
TAGLINE_SIZE = 0.035         # tagline font size as a share of the frame width
SPACING = 0.35, 0.45         # gap between title letters, in font sizes, at the start and end of the clip
Y = 0.47                     # title center (0-1 down the frame)
COLOR = (255, 255, 255)      # text color
FONTS = ["/System/Library/Fonts/Supplemental/Georgia Bold.ttf",    # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf",  # Linux
         "C:/Windows/Fonts/georgiab.ttf"]                         # Windows
FONT_FILE = next((f for f in FONTS if Path(f).exists()), None) or sys.exit("No bold serif font found: add one to FONTS")


def ramp(t, start, length):
    """0 before start, 1 after start + length, eased in between."""
    p = min(max((t - start) / length, 0), 1)
    return p * p * (3 - 2 * p)


def spaced(draw, text, font, cy, gap, alpha):
    """Draw text centered on the frame with `gap` pixels between letters."""
    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, cy), ch, font=font, anchor="lm", fill=COLOR + (alpha,))
        x += cw + gap


def overlay(t):
    img = Image.new("RGBA", (w, h), (0, 0, 0, round(255 * DIM * ramp(t, DIM_START, DIM_END - DIM_START))))
    draw = ImageDraw.Draw(img)
    title_alpha = round(255 * ramp(t, TITLE_IN, TITLE_FADE))
    if title_alpha:
        gap = title_font.size * (SPACING[0] + (SPACING[1] - SPACING[0]) * t / duration)
        spaced(draw, TITLE, title_font, h * Y, gap, title_alpha)
    tagline_alpha = round(255 * ramp(t, TAGLINE_IN, TAGLINE_FADE))
    if tagline_alpha:
        spaced(draw, TAGLINE, tagline_font, h * Y + title_font.size * 1.1, tagline_font.size * 0.6, tagline_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)
title_font = ImageFont.truetype(FONT_FILE, round(w * TITLE_SIZE))
tagline_font = ImageFont.truetype(FONT_FILE, round(w * TAGLINE_SIZE))
render(src, out)