How to add a curtain reveal with Claude

Open input.mp4 with a stage curtain reveal. Two red velvet curtains, each half the frame wide, cover the whole frame at first: draw them with numpy as vertical folds, 5 folds per curtain, red (170, 20, 35) on each fold's crest shading down to about 35% of that in the troughs and a little darker toward the top, with a gold (212, 170, 70) braid 1.2% of the frame width wide down each curtain's inner edge where they meet at the center. At 0.4 seconds they part from the center: over 1.5 seconds, with smoothstep easing, each curtain narrows from half the frame width to nothing, anchored at its outer edge (left curtain on the left, right curtain on the right), squeezing its folds tighter as it goes rather than sliding them off. The hem trails the top by 0.25 seconds (row y starts moving 0.25*y/height seconds later), so the curtains swing slightly and are fully gone by 2.15 seconds. Each curtain casts a soft black shadow on the video, 5% of the frame width wide and 60% dark at the curtain's edge. After that the clip plays untouched. Draw the curtains with Python (numpy or Pillow, not ffmpeg's drawtext) and overlay them with ffmpeg, keep the audio, and save it as output.mp4 at the input's size, 6 seconds, 30fps.

#!/usr/bin/env python3
"""Curtain reveal: red velvet stage curtains part from the center and bunch up as they sweep off both sides.

Usage: python3 curtain-reveal.py input.mp4 output.mp4
Needs ffmpeg and numpy (pip install numpy).
"""
import json
import math
import subprocess
import sys

import numpy as np

START = 0.4              # second the curtains start to part
OPEN = 1.5               # seconds they take to clear the frame
LAG = 0.25               # seconds the hem trails the top, so the curtains swing a little
FOLDS = 5                # folds across each curtain
COLOR = (170, 20, 35)    # velvet red on a fold's crest
TRIM = (212, 170, 70)    # gold braid down each curtain's inner edge
TRIM_W = 0.012           # braid width as a share of the frame width
SHADOW_W = 0.05          # width of the shadow each curtain casts on the video, as a share of the frame width


def velvet():
    """One curtain (half the frame wide): vertical folds, darker at the top and in each fold's trough."""
    half = w // 2
    x = np.arange(half) / half
    folds = 0.5 + 0.5 * np.cos(2 * math.pi * FOLDS * x + 0.6 * np.sin(2 * math.pi * 3 * x))
    shade = 0.35 + 0.65 * folds ** 0.7
    y = np.arange(h) / h
    shade = shade[None, :] * (0.78 + 0.22 * np.sin(math.pi * np.clip(y, 0, 0.9) / 0.9))[:, None]
    tex = shade[:, :, None] * np.array(COLOR, np.float32)
    tex[:, round(half - TRIM_W * w):] = TRIM                      # braid on the inner edge
    return tex.astype(np.float32)


def smoothstep(p):
    p = np.clip(p, 0, 1)
    return p * p * (3 - 2 * p)


def overlay(t):
    """The curtains at time t as an RGBA frame: the left one drawn from tex, the right one mirrored."""
    half = tex.shape[1]
    y = np.arange(h) / h
    width = half * (1 - smoothstep((t - START - LAG * y) / OPEN))   # each row's curtain width; the hem lags
    x = np.arange(w // 2)[None, :] + 0.5
    cover = np.clip(width[:, None] - x + 0.5, 0, 1)                 # 1 inside the curtain, soft at its edge
    cols = np.minimum((x / np.maximum(width[:, None], 1e-3) * half).astype(int), half - 1)
    rgb = np.take_along_axis(tex, np.broadcast_to(cols[:, :, None], cols.shape + (3,)), axis=1)
    gap = np.clip((x - width[:, None]) / (SHADOW_W * w), 0, 1)
    shadow = 0.6 * (1 - gap) ** 2 * (width[:, None] > 0.5)
    alpha = cover + shadow * (1 - cover)
    left = np.dstack([rgb * (cover > 0)[:, :, None], alpha * 255])
    img = np.zeros((h, w, 4), np.float32)
    img[:, :w // 2] = left
    img[:, w - w // 2:] = left[:, ::-1]
    return img.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)
tex = velvet()
render(src, out)