How to add a testimonial montage with Claude

Make a testimonial montage from clip1.mp4, clip2.mp4 and clip3.mp4: play clip1 from 0 to 2s, then clip2 from its own 2s to 4s, then clip3 from its own 4s to 6s, each with its own audio, as hard cuts. Fit every clip to clip1's size (540x960) by scaling it to fill and cropping the center, at 30fps, so the output is 6 seconds. Each clip gets its own name tag: "Maya R.", "Jordan K." and "Priya S." in that order. A tag is a white pill (fully rounded ends) with a soft black drop shadow, its top-left corner 6% across and 78% down the frame, padding 3.2% of the frame width. Inside, on the left, a dark purple (60, 40, 110) circle as tall as the two text lines with the name's first letter in white bold; to its right the name in bold near-black (25, 25, 30) text 6.2% of the frame width tall, and under it five gold (255, 185, 0) five-pointed stars, each 4% of the frame width across, followed by "Verified buyer" in grey (130, 130, 140) bold text 3.8% of the frame width tall. Nothing shows for the first 0.15 seconds of each clip; then that clip's tag fades in while rising 4% of the frame height into place over 0.3 seconds with a cubic ease-out, and stays until the next cut, where it disappears with the clip. Use Python with Pillow to draw the tags and ffmpeg to cut the clips and put the tags on (don't rely on ffmpeg's drawtext filter), keep each clip's audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Testimonial montage: three customer clips cut back to back, each with its own name tag rising in at the cut.

Usage: python3 testimonial-montage.py clip1.mp4 clip2.mp4 clip3.mp4 output.mp4
Needs ffmpeg and Pillow (pip install pillow). Every clip needs an audio track; each plays with its own sound.
"""
import json
import math
import subprocess
import sys
from pathlib import Path

from PIL import Image, ImageDraw, ImageFilter, ImageFont

PEOPLE = ["Maya R.", "Jordan K.", "Priya S."]  # one name per clip, in order
BYLINE = "Verified buyer"  # grey line under each name, after the stars
SHOT = 2.0               # seconds of each clip; clip n plays its own n*SHOT to (n+1)*SHOT
DELAY = 0.15             # seconds after each cut before the tag starts to rise in
RISE = 0.3               # seconds the tag takes to fade and rise into place
X, Y = 0.06, 0.78        # tag's top-left corner (0-1 across and down the frame)
GOLD = (255, 185, 0)     # star color
AVATAR = (60, 40, 110)   # circle behind each person's initial
FONTS = ["/System/Library/Fonts/Supplemental/Arial Bold.ttf",     # macOS
         "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",  # Linux
         "C:/Windows/Fonts/arialbd.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 star(draw, cx, cy, r, fill):
    points = [(cx + (r if i % 2 == 0 else r * 0.45) * math.sin(i * math.pi / 5),
               cy - (r if i % 2 == 0 else r * 0.45) * math.cos(i * math.pi / 5)) for i in range(10)]
    draw.polygon(points, fill=fill)


def tag(name):
    """A white name tag: a circle with the initial, the name, five stars and the byline, with a soft shadow."""
    name_font = ImageFont.truetype(FONT_FILE, round(w * 0.062))
    small = ImageFont.truetype(FONT_FILE, round(w * 0.038))
    pad, r = round(w * 0.032), round(w * 0.02)
    d = name_font.size + small.size + pad // 2  # avatar diameter spans both lines
    text_x = pad + d + pad
    second = 5 * r * 2.4 + pad // 2 + small.getlength(BYLINE)
    tw, th = round(text_x + max(name_font.getlength(name), second) + pad * 1.4), d + 2 * pad

    shadow = round(w * 0.025)
    img = Image.new("RGBA", (tw + 2 * shadow, th + 2 * shadow))
    shade = Image.new("RGBA", img.size)
    ImageDraw.Draw(shade).rounded_rectangle([shadow, shadow + 5, shadow + tw, shadow + th + 5], th // 2, fill=(0, 0, 0, 100))
    img.alpha_composite(shade.filter(ImageFilter.GaussianBlur(shadow / 2)))
    draw = ImageDraw.Draw(img)
    draw.rounded_rectangle([shadow, shadow, shadow + tw, shadow + th], th // 2, fill="white")

    x0, y0 = shadow + pad, shadow + pad
    draw.ellipse([x0, y0, x0 + d, y0 + d], fill=AVATAR)
    draw.text((x0 + d / 2, y0 + d / 2), name[0], font=name_font, anchor="mm", fill="white")
    x = shadow + text_x
    draw.text((x, y0), name, font=name_font, fill=(25, 25, 30))
    y = y0 + name_font.size + pad // 2 + small.size / 2
    for i in range(5):
        star(draw, x + r + i * r * 2.4, y, r, GOLD)
    draw.text((x + 5 * r * 2.4 + pad // 2, y), BYLINE, font=small, anchor="lm", fill=(130, 130, 140))
    return img


def overlay(t):
    img = Image.new("RGBA", (w, h))
    n = min(int(t // SHOT), len(tags) - 1)
    p = (t - n * SHOT - DELAY) / RISE
    if p > 0:
        p = 1 - (1 - min(p, 1)) ** 3  # fast at first, gentle as it lands
        layer = tags[n].copy()
        layer.putalpha(layer.getchannel("A").point(lambda a: round(a * p)))
        img.alpha_composite(layer, (round(w * X), round(h * Y + h * 0.04 * (1 - p))))
    return img


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


def render(clips, out):
    """Cut SHOT seconds from each clip (fitted to the first clip's frame), join them with their sound, draw the tags."""
    cuts = "".join(f"[{i}:v]trim={i * SHOT}:{(i + 1) * SHOT},setpts=PTS-STARTPTS,fps=30,"
                   f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},setsar=1[v{i}];"
                   f"[{i}:a]atrim={i * SHOT}:{(i + 1) * SHOT},asetpts=PTS-STARTPTS[a{i}];" for i in range(len(clips)))
    joined = "".join(f"[v{i}][a{i}]" for i in range(len(clips)))
    inputs = [arg for clip in clips for arg in ("-i", clip)]
    ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", *inputs,
                           "-f", "rawvideo", "-pix_fmt", "rgba", "-s", f"{w}x{h}", "-r", "30", "-i", "-",
                           "-filter_complex", f"{cuts}{joined}concat=n={len(clips)}:v=1:a=1[cut][a];"
                           f"[cut][{len(clips)}:v]overlay=shortest=1,format=yuv420p[v]",
                           "-map", "[v]", "-map", "[a]", "-c:v", "libx264", "-crf", "18", "-c:a", "aac", out],
                          stdin=subprocess.PIPE)
    for i in range(math.ceil(SHOT * len(clips) * 30)):
        ff.stdin.write(overlay(i / 30).tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


*clips, out = sys.argv[1:]
w, h = probe(clips[0])
tags = [tag(name) for name in PEOPLE[:len(clips)]]
render(clips, out)