How to add a poll sticker with Claude

Add a poll sticker to input.mp4: a white card 80% of the frame width, centered across with its top edge 8% down, rounded corners (radius 6% of the card width) and a soft drop shadow. Inside, with padding of 7% of the card width: the question "Would you try it?" in bold black (20, 20, 24) at 8% of the card width, centered at the top; then two options, "Yes, obsessed" and "Not yet", each a bold black label (5.5% of the card width) on the left above a full-width rounded bar 6.5% of the card width tall in light gray (232, 232, 238). The card pops in at 0.4 seconds over 0.35 seconds with a slight overshoot, growing from its center, with empty bars and no percentages. From 1.0 to 2.2 seconds, easing out, the bars fill from the left in pink (240, 50, 130) to 78% and 22% of their width while a percentage at the right end of each label line counts up from 0 to 78% and 22%; then everything holds to the end. Use Python with Pillow to draw it and ffmpeg to put it on the video (don't rely on ffmpeg's drawtext filter), keep the audio, and save it as output.mp4.

#!/usr/bin/env python3
"""Poll sticker: a white two-option poll card pops in near the top, then its pink vote bars fill to the final split.

Usage: python3 poll-sticker.py input.mp4 output.mp4
Needs ffmpeg and Pillow (pip install pillow).
"""
import json
import math
import subprocess
import sys
from pathlib import Path

from PIL import Image, ImageDraw, ImageFilter, ImageFont

QUESTION = "Would you try it?"                   # the poll question
OPTIONS = [("Yes, obsessed", 78), ("Not yet", 22)]  # each option and its final vote share in percent
START = 0.4              # second the card pops in
POP = 0.35               # seconds the pop takes
FILL_START = 1.0         # second the vote bars start filling
FILL = 1.2               # seconds the bars take to fill
WIDTH = 0.80             # card width as a share of the frame width
TOP = 0.08               # card top edge, as a share of the frame height (centered across)
COLOR = (240, 50, 130)   # vote bar fill
TRACK = (232, 232, 238)  # empty bar
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 layout():
    """Sizes and positions inside the card, in card pixels."""
    cw = round(w * WIDTH)
    pad, gap = round(cw * 0.07), round(cw * 0.05)
    q_font = ImageFont.truetype(FONT_FILE, round(cw * 0.08))
    o_font = ImageFont.truetype(FONT_FILE, round(cw * 0.055))
    bar_h = round(cw * 0.065)
    rows, y = [], pad + q_font.size + gap
    for _ in OPTIONS:
        rows.append((y, y + o_font.size + round(gap * 0.5)))  # (label line top, bar top)
        y += o_font.size + round(gap * 0.5) + bar_h + gap
    return cw, y - gap + pad, pad, bar_h, q_font, o_font, rows


def card(progress):
    """The poll card with its bars filled to `progress` (0-1) of the final vote shares; no shares shown at 0."""
    cw, ch, pad, bar_h, q_font, o_font, rows = geometry
    shadow = round(cw * 0.04)
    img = Image.new("RGBA", (cw + 2 * shadow, ch + 2 * shadow))
    shape = Image.new("L", img.size)
    ImageDraw.Draw(shape).rounded_rectangle([shadow, shadow, shadow + cw, shadow + ch], radius=round(cw * 0.06), fill=255)
    img.paste((0, 0, 0, 90), (0, round(shadow * 0.4)), shape.filter(ImageFilter.GaussianBlur(shadow / 2)))
    img.paste((255, 255, 255, 255), (0, 0), shape)

    draw = ImageDraw.Draw(img)
    draw.text((shadow + cw / 2, shadow + pad), QUESTION, font=q_font, anchor="mt", fill=(20, 20, 24))
    x0, x1 = shadow + pad, shadow + cw - pad
    for (label, share), (label_y, bar_y) in zip(OPTIONS, rows):
        draw.text((x0, shadow + label_y), label, font=o_font, fill=(20, 20, 24))
        top = shadow + bar_y
        draw.rounded_rectangle([x0, top, x1, top + bar_h], radius=bar_h // 2, fill=TRACK)
        if progress > 0:
            shown = share * progress
            draw.text((x1, shadow + label_y), f"{round(shown)}%", font=o_font, anchor="ra", fill=(20, 20, 24))
            right = x0 + (x1 - x0) * shown / 100
            if right - x0 >= bar_h:
                draw.rounded_rectangle([x0, top, right, top + bar_h], radius=bar_h // 2, fill=COLOR)
    return img


def overlay(t):
    img = Image.new("RGBA", (w, h))
    scale = ease_out_back((t - START) / POP) if t >= START else 0
    if scale > 0.02:
        full = card(ease_out_cubic((t - FILL_START) / FILL))
        c = full.resize((max(1, round(full.width * scale)), max(1, round(full.height * scale))), Image.LANCZOS)
        # grow out of the card's center so the pop stays in place
        img.alpha_composite(c, (round(w / 2 - c.width / 2), round(h * TOP + full.height / 2 - c.height / 2)))
    return img


def ease_out_back(p):
    """0 -> 1 with a small overshoot past 1 before settling, which reads as a 'pop'."""
    p = min(max(p, 0), 1)
    return 1 + 2.70158 * (p - 1) ** 3 + 1.70158 * (p - 1) ** 2


def ease_out_cubic(p):
    """0 -> 1, fast at first and slowing into the end, like votes settling."""
    p = min(max(p, 0), 1)
    return 1 - (1 - p) ** 3


def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height,r_frame_rate:format=duration", "-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), float(info["format"]["duration"])


def render(src, out):
    """Draw overlay(t) on every frame of src and save to out, keeping the audio."""
    ff = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-i", src,
                           "-f", "rawvideo", "-pix_fmt", "rgba", "-s", f"{w}x{h}", "-r", rate, "-i", "-",
                           "-filter_complex", "[0:v][1:v]overlay=shortest=1,format=yuv420p[v]",
                           "-map", "[v]", "-map", "0:a?", "-c:v", "libx264", "-crf", "18", "-c:a", "copy", out],
                          stdin=subprocess.PIPE)
    for i in range(math.ceil(duration * fps)):
        ff.stdin.write(overlay(i / fps).tobytes())
    ff.stdin.close()
    if ff.wait():
        sys.exit("ffmpeg failed")


src, out = sys.argv[1:3]
w, h, rate, fps, duration = probe(src)
geometry = layout()
render(src, out)