How to add a TV turn off with Claude

Add an old CRT TV turn-off to input.mp4 at 4 seconds. From 4.0 to 4.25 seconds, squeeze the picture vertically toward the center line (height eases from 100% down to a 6-pixel line, scaling with progress squared) while blending it toward pure white (255, 255, 255), with black above and below. From 4.25 to 4.55 seconds, show a pure white horizontal line 6 pixels thick centered vertically, shrinking from the full frame width to a 14-pixel dot in the center, with a soft white glow around it (Gaussian blur radius 10). From 4.55 to 5.0 seconds, the dot shrinks to half its size and fades out. After 5.0 seconds, the screen stays black to the end. Leave everything before 4 seconds untouched. Use Python with Pillow and numpy to draw the frames (don't use ffmpeg's drawtext filter), keep the audio but fade it out from 4.0 to 4.55 seconds, keep the size and frame rate, and save it as output.mp4.

#!/usr/bin/env python3
"""TV turn off: the picture squashes into a glowing white line, shrinks to a dot, and the screen goes black.

Usage: python3 tv-turn-off.py input.mp4 output.mp4
Needs ffmpeg, Pillow and numpy (pip install pillow numpy).
"""
import json
import subprocess
import sys

import numpy as np
from PIL import Image, ImageDraw, ImageFilter

START = 4.0       # second the picture starts to collapse
SQUASH = 0.25     # seconds for the picture to squash into a line
SHRINK = 0.30     # seconds for the line to shrink into a dot
FADE = 0.45       # seconds for the dot to fade out
LINE = 6          # thickness of the white line in pixels
DOT = 14          # diameter of the dot in pixels
GLOW = 10         # blur radius of the glow around the line and dot


def ease_in(p):
    return min(max(p, 0), 1) ** 2


def squashed(img, p):
    """The picture squeezed to (1 - p) of its height and washed toward white, centered on black."""
    rows = max(LINE, round(h * (1 - ease_in(p))))
    washed = Image.blend(img, Image.new("RGB", (w, h), "white"), ease_in(p) ** 0.5)
    screen = Image.new("RGB", (w, h))
    screen.paste(washed.resize((w, rows), Image.BILINEAR), (0, (h - rows) // 2))
    return screen


def glowing(draw_shape, strength=1.0):
    """A white shape on black with a soft glow around it, dimmed by strength."""
    shape = Image.new("L", (w, h))
    draw_shape(ImageDraw.Draw(shape))
    glow = np.asarray(shape.filter(ImageFilter.GaussianBlur(GLOW)), np.float32) * 1.6
    light = np.maximum(np.asarray(shape, np.float32), glow) * strength
    return Image.fromarray(np.repeat(np.clip(light, 0, 255).astype(np.uint8)[:, :, None], 3, axis=2))


def line(p):
    half = max(DOT / 2, w / 2 * (1 - ease_in(p)))
    return glowing(lambda d: d.rectangle([w / 2 - half, (h - LINE) / 2, w / 2 + half, (h + LINE) / 2], fill=255))


def dot(p):
    r = DOT / 2 * (1 - 0.5 * p)
    return glowing(lambda d: d.ellipse([w / 2 - r, h / 2 - r, w / 2 + r, h / 2 + r], fill=255), 1 - p)


def screen(img, t):
    if t < START:
        return img
    t -= START
    if t < SQUASH:
        return squashed(img, t / SQUASH)
    t -= SQUASH
    if t < SHRINK:
        return line(t / SHRINK)
    t -= SHRINK
    if t < FADE:
        return dot(t / FADE)
    return Image.new("RGB", (w, h))


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?",
                           "-af", f"afade=t=out:st={START}:d={SQUASH + SHRINK}",
                           "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest", out],
                          stdin=subprocess.PIPE)
i = 0
while raw := reader.stdout.read(w * h * 3):
    writer.stdin.write(screen(Image.frombytes("RGB", (w, h), raw), i / fps).tobytes())
    i += 1
writer.stdin.close()
if reader.wait() or writer.wait():
    sys.exit("ffmpeg failed")