How to add a metallic text with Claude

Add metallic gold text to input.mp4: the word "PREMIUM" in a heavy bold font (Arial Black or similar) at a font size of 15% of the frame width, centered horizontally at 16% down the frame. Fill the letters with a vertical gold gradient running from the top of the letters to the bottom: (255, 240, 170) at the top, (240, 195, 75) at 35%, a dark band of (160, 105, 25) at 50%, a bright (250, 215, 110) at 62% and (185, 130, 35) at the bottom, blended smoothly between those stops. Give the letters a 3 px dark bronze (90, 55, 10) outline and a soft black drop shadow (60% opacity, offset 4 px right and 6 px down, 6 px blur). The text fades in from 0.5 to 0.8 seconds, with nothing on screen before 0.5 seconds, and stays to the end. From 1.2 to 2.0 seconds a glint slides once across the letters from left to right, starting 60 px left of the text and ending 60 px right of it: a band tilted 25 degrees from vertical with its top leaning right (like /), pushing the gold toward white by 95% at its center (falling off over about 9 px either side) plus a softer 35% glow falling off over about 35 px, shown only inside the letters' gold face, not on the outline or the video. Use Python with Pillow and numpy to draw the text, gradient and glint (don't use ffmpeg's drawtext filter) and ffmpeg to put it on the video, keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Metallic text: a polished gold headline fades in, then a white glint slides across the letters.

Usage: python3 metallic-text.py input.mp4 output.mp4
Needs ffmpeg, Pillow and numpy (pip install pillow numpy).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw, ImageFilter, ImageFont

TEXT = "PREMIUM"            # the headline
START = 0.5                 # second the text fades in
FADE_IN = 0.3               # seconds the fade in takes
Y = 0.16                    # text center, 0-1 down the frame
SIZE = 0.15                 # font size as a share of the frame width
METAL = [(0.0, (255, 240, 170)),   # gold bands from the top of the letters (0) to the bottom (1):
         (0.35, (240, 195, 75)),   # pale highlight, warm gold, a dark horizon line,
         (0.5, (160, 105, 25)),    # a bright reflection under it, deeper gold at the base
         (0.62, (250, 215, 110)),
         (1.0, (185, 130, 35))]
EDGE = (90, 55, 10)         # dark bronze outline around the letters
EDGE_WIDTH = 3              # outline thickness in pixels
GLINT_START, GLINT_END = 1.2, 2.0  # seconds the glint takes to cross the text, left to right
GLINT_TILT = 25             # glint angle from vertical, top leaning right (like /)
SHADOW = 0.6                # drop shadow opacity behind the letters (0 = none)
FONTS = ["/System/Library/Fonts/Supplemental/Arial Black.ttf",    # macOS
         "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
         "/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 draw_mask(offset=(0, 0), stroke=0):
    img = Image.new("L", (w, h))
    ImageDraw.Draw(img).text((w / 2 + offset[0], h * Y + offset[1]), TEXT, font=font, anchor="mm", fill=255,
                             stroke_width=stroke, stroke_fill=255)
    return img


def metal_fill():
    """The gold bands, stretched from the top of the letters to the bottom, as an RGB array the size of the frame."""
    top, bottom = font.getbbox(TEXT, anchor="mm")[1::2]
    pos = np.clip((np.arange(h) - (h * Y + top)) / (bottom - top), 0, 1)
    stops = np.array([p for p, _ in METAL])
    colors = np.array([c for _, c in METAL], np.float32)
    column = np.stack([np.interp(pos, stops, colors[:, i]) for i in range(3)], axis=1)
    return np.broadcast_to(column[:, None, :], (h, w, 3))


def glint(t):
    """How far each pixel is pushed to white (0-1): a narrow bright core in a softer glow, sliding left to right."""
    left, _, right, _ = font.getbbox(TEXT, anchor="mm")
    p = (t - GLINT_START) / (GLINT_END - GLINT_START)
    center = w / 2 + left - 60 + p * (right - left + 120)       # starts and ends just off the letters
    yy, xx = np.mgrid[0:h, 0:w].astype(np.float32)
    u = xx + (yy - h * Y) * math.tan(math.radians(GLINT_TILT)) - center
    return np.minimum(0.95 * np.exp(-(u / 9) ** 2) + 0.35 * np.exp(-(u / 35) ** 2), 1)


def overlay(t):
    shown = min(max((t - START) / FADE_IN, 0), 1)
    if shown <= 0:
        return blank
    face = fill
    if GLINT_START <= t <= GLINT_END:
        face = fill + (255 - fill) * glint(t)[..., None]     # the glint lights the gold face only, not the outline
    rgb = face * letters[..., None] + np.array(EDGE, np.float32) * (outline - letters)[..., None]
    alpha = outline + shadow * (1 - outline)
    rgb = rgb / np.maximum(alpha, 1e-6)[..., None]          # shadow pixels are black
    img = np.dstack([np.clip(rgb, 0, 255), alpha * 255 * shown])
    return Image.fromarray(img.round().astype(np.uint8))


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))
letters = np.asarray(draw_mask(), np.float32) / 255
outline = np.asarray(draw_mask(stroke=EDGE_WIDTH), np.float32) / 255
shadow = np.asarray(draw_mask((4, 6), EDGE_WIDTH).filter(ImageFilter.GaussianBlur(6)), np.float32) / 255 * SHADOW
fill = metal_fill()
blank = Image.new("RGBA", (w, h))
render(src, out)