How to add a liquid splash transition with Claude

Join clipA.mp4 and clipB.mp4 with a 1.2 second liquid splash transition that starts 1.2 seconds before clipA.mp4 ends, so the result is A's length plus B's length minus 1.2 seconds (B starts from its first frame when the transition starts). A wave of blue liquid has a front surface and a back surface. The front surface rises from 80 pixels below the bottom edge to 80 pixels above the top edge over the first 0.54 seconds of the transition with smoothstep easing (ease in and out); everything below it is liquid covering clip A, so the frame is fully blue from 0.54 to 0.66 seconds. The back surface makes the same move from 0.66 to 1.2 seconds, and below it clip B shows, so the liquid rolls off the top. Each surface is wavy: its height at column x (frame width W, transition progress p from 0 to 1) is offset by 40 * (0.6 * sin(2*pi*1.3*x/W + 9p) + 0.4 * sin(2*pi*3.1*x/W - 15.3p + 1)) pixels, and the back surface uses 9p + 2 in place of 9p in both terms (so its second sine's phase is -15.3p - 2.4). Color the liquid light blue (120, 205, 255) at the front surface, blending to deep blue (10, 95, 215) 200 pixels below it, and draw thin moving wavy lines of light through it like sunlight through pool water, pulling it at most 30% back toward the light blue. Draw a pale (215, 240, 255) rim 8 pixels deep along the front surface and 6 pixels high just above the back surface. While the front rises, throw 70 light blue (120, 205, 255) droplets, 3 to 9 pixel radius, from random columns at random times in the first 0.36 seconds: each leaps 40 to 160 pixels above the crest on a parabola and falls back into it over 0.22 seconds. Nothing blue is on screen before the transition or after it. Crossfade the audio over the same 1.2 seconds. Match B's size to A and output 30fps. Use Python with numpy and Pillow for the frames and ffmpeg to decode and encode, keep the audio and save it as output.mp4.

#!/usr/bin/env python3
"""Liquid splash transition: a wave of blue liquid surges up from the bottom over clip A, throwing droplets ahead of its crest, fills the frame, then rolls off the top to leave clip B.

Usage: python3 liquid-splash-transition.py clipA.mp4 clipB.mp4 output.mp4  (both clips need an audio track)
Needs ffmpeg, Pillow and numpy (pip install pillow numpy).
"""
import json
import subprocess
import sys

import numpy as np
from PIL import Image, ImageDraw

D = 1.2                     # transition length in seconds
RISE = 0.45                 # share of D the wave's front takes to cross the frame; its back takes the same at the end
WAVE = 40                   # height of the ripples on the liquid's surface in pixels
SURFACE = (120, 205, 255)   # light blue at the surface and in the droplets
DEEP = (10, 95, 215)        # deep blue the liquid turns 200 pixels below its surface
FOAM = (215, 240, 255)      # pale rim along each edge of the liquid
DROPS = 70                  # droplets thrown up ahead of the rising crest
SEED = 3                    # random seed for the droplets
FPS = 30


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):
    """Every frame of a clip, fitted to A's size at 30fps, as a float RGB array."""
    fit = f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},fps={FPS}"
    ff = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-vf", fit, "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
                          stdout=subprocess.PIPE)
    while True:
        chunk = ff.stdout.read(w * h * 3)
        if not chunk:
            break
        yield np.frombuffer(chunk, np.uint8).reshape(h, w, 3).astype(np.float32)


def surface(q, phase):
    """Height of a wavy surface in pixels, per column, as it travels from below the frame (q=0) to above it (q=1)."""
    q = np.clip(q, 0, 1)
    level = (h + 2 * WAVE) - (h + 4 * WAVE) * q * q * (3 - 2 * q)   # eased in and out
    x = np.arange(w) / w
    return level + WAVE * (0.6 * np.sin(2 * np.pi * 1.3 * x + phase) + 0.4 * np.sin(2 * np.pi * 3.1 * x - 1.7 * phase + 1))


def splash(p, front):
    """Mask of droplets that leap ahead of the rising crest and fall back into it."""
    img = Image.new("L", (w, h))
    draw = ImageDraw.Draw(img)
    for x, launch, height, r in drops:
        age = (p - launch) / 0.18                     # each droplet is in the air for 18% of the transition
        if 0 <= age <= 1:
            y = front[int(x)] - height * 4 * age * (1 - age) - r
            draw.ellipse([x - r, y - r, x + r, y + r], fill=255)
    return np.asarray(img, np.float32) / 255


def liquid(a, b, p):
    """Frame at progress p (0-1): liquid covers A above the rising front, and B shows below the rising back."""
    front = surface(p / RISE, 9 * p)
    back = surface((p - (1 - RISE)) / RISE, 9 * p + 2)
    depth = rows - front[None, :]
    wet = np.clip(depth / 1.5, 0, 1)
    dry = np.clip((rows - back[None, :]) / 1.5, 0, 1)
    shade = np.clip(depth / 200, 0, 1)
    swirl = np.sin(cols * 0.02 + 2 * np.sin(rows * 0.015 + 6 * p)) + np.sin(rows * 0.012 + 2 * np.sin(cols * 0.025 - 6 * p))
    caustics = np.clip(1 - 2.5 * np.abs(swirl), 0, 1) ** 2                 # thin wavy lines of light, like sun through water
    shade = np.clip(shade - 0.3 * caustics, 0, 1)[..., None]
    body = np.array(SURFACE, np.float32) * (1 - shade) + np.array(DEEP, np.float32) * shade
    rim = ((depth < 8) | (back[None, :] - rows < 6))[..., None]
    body = np.where(rim, np.array(FOAM, np.float32), body)
    drop = splash(p, front)[..., None]
    out = a * (1 - wet[..., None]) + body * wet[..., None]
    out = out * (1 - drop) + np.array(SURFACE, np.float32) * drop
    return out * (1 - dry[..., None]) + b * dry[..., None]


a_path, b_path, out = sys.argv[1:4]
w, h, a_len = probe(a_path)
rows = np.arange(h, dtype=np.float32)[:, None]
cols = np.arange(w, dtype=np.float32)[None, :]
rng = np.random.default_rng(SEED)
drops = list(zip(rng.uniform(0, w, DROPS), rng.uniform(0, RISE - 0.15, DROPS),
                 rng.uniform(40, 160, DROPS), rng.uniform(3, 9, DROPS)))
start = round((a_len - D) * FPS)    # first frame of the transition
steps = round(D * FPS)
ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
                       "-r", str(FPS), "-i", "-", "-i", a_path, "-i", b_path,
                       "-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)
b_frames = frames(b_path)
for i, a in enumerate(frames(a_path)):
    if i >= start:
        a = liquid(a, next(b_frames), (i - start + 1) / steps)
    ff.stdin.write(np.clip(a, 0, 255).astype(np.uint8).tobytes())
for b in b_frames:
    ff.stdin.write(b.astype(np.uint8).tobytes())
ff.stdin.close()
if ff.wait():
    sys.exit("ffmpeg failed")