How to add a screen melt transition with Claude

Join clipA.mp4 and clipB.mp4 with a 1 second screen melt transition (the melt from classic DOOM). It starts 1 second before A ends, so the result is A's length plus B's length minus 1 second. Cut clip A into vertical strips 8 pixels wide. Give each strip a start delay between 0 and 0.3 of the transition, taken from a random walk across the strips so neighbors start close together; once a strip starts it slides straight down, its offset growing with the square of time until it has moved the full frame height by the end of the transition. A keeps playing inside the strips, and clip B, starting from its first frame, plays behind them in the gap that opens above each strip. Darken B to 50% brightness right above each strip's top edge, fading back to full over 40 pixels, so the drips cast a shadow. Crossfade the audio over the same 1 second. Match B's size to A and output 30fps. Use Python with numpy for the strips and ffmpeg to decode and encode, and save it as output.mp4.

#!/usr/bin/env python3
"""Screen melt transition: over 1s clip A breaks into thin vertical strips that slide down the frame at staggered, speeding-up rates, like melting wax, uncovering clip B behind them.

Usage: python3 screen-melt-transition.py clipA.mp4 clipB.mp4 output.mp4  (both clips need an audio track)
Needs ffmpeg and numpy (pip install numpy).
"""
import json
import subprocess
import sys
from itertools import islice

import numpy as np

D = 1.0           # transition length in seconds
FPS = 30          # output frame rate
STRIP = 8         # strip width in pixels
MAX_DELAY = 0.3   # latest a strip starts falling, as a share of the transition
SHADOW = 40       # height in pixels of the shadow each strip casts on clip B above it
SEED = 7          # change for a different drip pattern


def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height:format=duration", "-of", "json", path]))
    return info["streams"][0]["width"], info["streams"][0]["height"], float(info["format"]["duration"])


def frames(path):
    """Decode a clip as w x h RGB frames at FPS, cropping it to fill the frame if its shape differs."""
    ff = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-vf",
                           f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},fps={FPS}",
                           "-f", "rawvideo", "-pix_fmt", "rgb24", "-"], stdout=subprocess.PIPE)
    while True:
        data = ff.stdout.read(w * h * 3)
        if len(data) < w * h * 3:
            return
        yield np.frombuffer(data, np.uint8).reshape(h, w, 3)


def start_delays():
    """When each strip starts falling: a random walk across the strips, so neighbors start close together
    and the top edge of A forms ragged drips rather than noise."""
    steps = np.random.default_rng(SEED).uniform(-1, 1, -(-w // STRIP)).cumsum()
    steps = (steps - steps.min()) / max(np.ptp(steps), 1e-6)
    return np.repeat(steps * MAX_DELAY, STRIP)[:w]


def melt(a, b, p):
    """One transition frame at progress p (0-1): each strip of A shifted down by its own amount, B behind."""
    fall = np.clip((p - delays) / (1 - MAX_DELAY), 0, 1) ** 2   # 0-1 per column, speeding up as it falls
    drop = np.round(fall * h).astype(int)
    rows = np.arange(h)[:, None] - drop[None, :]                  # which row of A lands on each output row
    cols = np.broadcast_to(np.arange(w), (h, w))
    shade = 1 - 0.5 * np.clip(1 + rows / SHADOW, 0, 1)            # B darkens just above the top edge of each falling strip
    under = (b * shade[..., None]).astype(np.uint8)
    return np.where((rows >= 0)[..., None], a[np.clip(rows, 0, h - 1), cols], under)


A, B, out = sys.argv[1:4]
w, h, length = probe(A)
delays = start_delays()
cut_in = round((length - D) * FPS)   # first frame of the transition
n = round(D * FPS)                   # frames in the transition

enc = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
                        "-r", str(FPS), "-i", "-", "-i", A, "-i", B,
                        "-filter_complex", f"[1:a][2:a]acrossfade=d={D}[au]", "-map", "0:v", "-map", "[au]",
                        "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "aac", out],
                       stdin=subprocess.PIPE)
clip_a, clip_b = frames(A), frames(B)
for a in islice(clip_a, cut_in):
    enc.stdin.write(a.tobytes())
for i, (a, b) in enumerate(zip(islice(clip_a, n), islice(clip_b, n))):
    enc.stdin.write(melt(a, b, (i + 1) / n).tobytes())
for b in clip_b:
    enc.stdin.write(b.tobytes())
enc.stdin.close()
if enc.wait():
    sys.exit("ffmpeg failed")