How to add a spin blur with Claude

In input.mp4, add a spin blur (rotational blur) from 1.0 to 4.4 seconds; before 1.0s and after 4.4s the video must be untouched. On each frame, average 32 copies of the frame rotated around the frame center (270, 480) at evenly spaced angles from -A/2 to +A/2 degrees, filling the corners by reflecting the edges, so every point smears along a circular arc. A is 24 degrees at full strength: ease it up from 0 to 24 between 1.0s and 1.4s (smoothstep), hold 24 until 4.0s and ease back to 0 by 4.4s. Use Python with OpenCV (cv2.getRotationMatrix2D and cv2.warpAffine) and numpy, piping frames through ffmpeg. Keep the size (540x960), 30fps, 6 seconds and the audio. No text is needed; if you add any, draw it with Pillow, not ffmpeg's drawtext. Encode H.264 yuv420p and save it as output.mp4.

#!/usr/bin/env python3
"""Spin blur: from 1s to 4s the picture smears in circles around its center, as if the camera were spinning.

Usage: python3 spin-blur.py input.mp4 output.mp4
Needs ffmpeg, OpenCV and numpy (pip install opencv-python-headless numpy).
"""
import json
import subprocess
import sys

import cv2
import numpy as np

START = 1.0      # second the spin blur starts building (before it the video is untouched)
END = 4.0        # second it starts easing back off
RAMP = 0.4       # seconds to build up and ease off
ANGLE = 24       # degrees of arc each point smears across at full strength
CENTER = (0.5, 0.5)  # point the picture spins around (0-1 across and down the frame)
STEPS = 32       # rotated copies averaged per frame (more makes smoother arcs)


def strength(t):
    """0 before START, easing up to 1 over RAMP, held until END, easing back to 0."""
    p = min(max((t - START) / RAMP, 0), 1, max((END + RAMP - t) / RAMP, 0))
    return p * p * (3 - 2 * p)


def spin_blur(img, angle):
    """Average copies of the frame rotated across -angle/2..+angle/2 around CENTER."""
    center = (CENTER[0] * w, CENTER[1] * h)
    acc = np.zeros(img.shape, np.float32)
    for a in np.linspace(-angle / 2, angle / 2, STEPS):
        m = cv2.getRotationMatrix2D(center, float(a), 1.0)
        acc += cv2.warpAffine(img, m, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT)
    return (acc / STEPS).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", "-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)


src, out = sys.argv[1:3]
w, h, rate, fps = probe(src)
reader = subprocess.Popen(["ffmpeg", "-v", "error", "-i", src, "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
                          stdout=subprocess.PIPE)
writer = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
                           "-r", rate, "-i", "-", "-i", src, "-map", "0:v", "-map", "1:a?", "-c:v", "libx264",
                           "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "copy", "-shortest", out],
                          stdin=subprocess.PIPE)
i = 0
while True:
    buf = reader.stdout.read(w * h * 3)
    if len(buf) < w * h * 3:
        break
    img = np.frombuffer(buf, np.uint8).reshape(h, w, 3)
    s = strength(i / fps)
    if s > 0:
        img = spin_blur(img, ANGLE * s)
    writer.stdin.write(img.tobytes())
    i += 1
writer.stdin.close()
if reader.wait() or writer.wait():
    sys.exit("ffmpeg failed")