Add invitation renderer (Indian style, 1080x1920 MP4)

render_invitation.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+"""
+Renders an Indian-style animated retirement invitation: 1080x1920, 30fps, H.264 MP4.
+Maroon/gold palette, rotating mandala, marigold toran, flickering diyas, ornate frame.
+"""
+import os, math, subprocess, urllib.request, random
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, features
+
+W, H, FPS = 1080, 1920, 30
+OUT = "/tmp/mamta_retirement_invitation.mp4"
+POSTER = "/tmp/poster.jpg"
+FDIR = "/tmp/fonts"
+os.makedirs(FDIR, exist_ok=True)
+
+BG_TOP, BG_BOT = (78, 15, 36), (44, 7, 20)
+GOLD, GOLD_D, GOLD_L = (232, 193, 115), (201, 150, 47), (245, 222, 166)
+CREAM, MARIGOLD, ORANGE = (253, 243, 224), (240, 160, 42), (226, 112, 28)
+SOFT = (244, 229, 203)
+
+# ----------------------------------------------------------------- event text
+EV = dict(
+    name="Mamta",
+    hindi="\u0936\u0941\u092d \u0938\u0947\u0935\u093e\u0928\u093f\u0935\u0943\u0924\u094d\u0924\u093f",  # शुभ सेवानिवृत्ति
+    kicker1_en="WITH GREAT JOY",
+    script1="You\u2019re Invited",
+    sub1="a celebration of a beautiful journey",
+    kicker2="IN HONOUR OF",
+    body2="on the joyous occasion of her retirement",
+    small2="30 SEPTEMBER 2026",
+    card_title="Celebratory Lunch",
+    when_label="WHEN",
+    when_1="Wednesday, 30 September 2026",
+    when_2="Lunch at 1:30 pm",
+    where_label="WHERE",
+    where_1="New Rose Common",
+    sub3="Your presence will make it complete",
+    quote=["May the years ahead be as golden", "as the ones you so generously gave."],
+    script5="Come share a memory",
+    body5="a laugh, a toast, and something sweet with",
+    rsvp_label="RSVP",
+    rsvp_value="Kindly reply to the family",
+    kicker6="WE CAN\u2019T WAIT TO",
+    script6="Celebrate With You",
+    sig="With love, the family",
+)
+
+# ----------------------------------------------------------------- fonts
+FONT_URLS = {
+    "script": ["https://raw.githubusercontent.com/google/fonts/main/ofl/greatvibes/GreatVibes-Regular.ttf"],
+    "serif": ["https://raw.githubusercontent.com/google/fonts/main/ofl/playfairdisplay/PlayfairDisplay%5Bwght%5D.ttf",
+              "https://raw.githubusercontent.com/google/fonts/main/ofl/playfairdisplay/static/PlayfairDisplay-Regular.ttf"],
+    "body": ["https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/CormorantGaramond%5Bwght%5D.ttf",
+             "https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/static/CormorantGaramond-Regular.ttf"],
+    "bodyi": ["https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/CormorantGaramond-Italic%5Bwght%5D.ttf",
+              "https://raw.githubusercontent.com/google/fonts/main/ofl/cormorantgaramond/static/CormorantGaramond-Italic.ttf"],
+    "hindi": ["https://raw.githubusercontent.com/google/fonts/main/ofl/notoserifdevanagari/NotoSerifDevanagari%5Bwght%5D.ttf",
+              "https://raw.githubusercontent.com/google/fonts/main/ofl/notoserifdevanagari/static/NotoSerifDevanagari-Regular.ttf"],
+}
+FPATH = {}
+for key, urls in FONT_URLS.items():
+    for i, u in enumerate(urls):
+        dest = os.path.join(FDIR, "%s_%d.ttf" % (key, i))
+        try:
+            req = urllib.request.Request(u, headers={"User-Agent": "Mozilla/5.0"})
+            with urllib.request.urlopen(req, timeout=60) as r, open(dest, "wb") as fh:
+                fh.write(r.read())
+            FPATH[key] = dest
+            print("FONT OK  %-7s %8d  %s" % (key, os.path.getsize(dest), u.split("/")[-1]))
+            break
+        except Exception as e:
+            print("FONT FAIL %-7s %s" % (key, repr(e)[:90]))
+HAS_RAQM = bool(features.check("raqm"))
+print("RAQM (complex text shaping):", HAS_RAQM)
+
+_fc = {}
+def F(kind, size):
+    key = (kind, size)
+    if key in _fc:
+        return _fc[key]
+    path = FPATH.get(kind) or FPATH.get("serif") or FPATH.get("body")
+    f = ImageFont.truetype(path, size)
+    _fc[key] = f
+    return f
+
+# ----------------------------------------------------------------- text helper
+def text_layer(lines, kind, size, color, tracking=0, line_h=None):
+    """Render ink-cropped RGBA layer of centred text."""
+    f = F(kind, size)
+    tmp = Image.new("RGBA", (8, 8)); td = ImageDraw.Draw(tmp)
+    lh = line_h or int(size * 1.30)
+    widths = []
+    for ln in lines:
+        if tracking:
+            widths.append(sum(td.textlength(c, font=f) for c in ln) + tracking * max(0, len(ln) - 1))
+        else:
+            widths.append(td.textlength(ln, font=f))
+    pad = int(size * 0.9) + 14
+    lw = int(max(widths)) + 2 * pad
+    lht = int(lh * len(lines)) + 2 * pad
+    lay = Image.new("RGBA", (lw, lht), (0, 0, 0, 0))
+    d = ImageDraw.Draw(lay)
+    for i, ln in enumerate(lines):
+        base = pad + lh * i + lh * 0.80
+        if tracking:
+            x = (lw - widths[i]) / 2.0
+            for ch in ln:
+                d.text((x, base), ch, font=f, fill=color + (255,), anchor="ls")
+                x += td.textlength(ch, font=f) + tracking
+        else:
+            d.text((lw / 2.0, pad + lh * i + lh / 2.0), ln, font=f, fill=color + (255,), anchor="mm")
+    bb = lay.getbbox()
+    return lay.crop(bb) if bb else lay
+
+def alpha_scale(sprite, a):
+    if a >= 0.999:
+        return sprite
+    arr = np.array(sprite, dtype=np.uint16)
+    arr[..., 3] = (arr[..., 3] * a).astype(np.uint16)
+    return Image.fromarray(arr.astype(np.uint8), "RGBA")
+
+def alpha_variants(sprite, n=12):
+    base = np.array(sprite, dtype=np.uint16)
+    out = []
+    for i in range(n):
+        arr = base.copy()
+        arr[..., 3] = (arr[..., 3] * (i / float(n - 1))).astype(np.uint16)
+        out.append(Image.fromarray(arr.astype(np.uint8), "RGBA"))
+    return out
+
+def paste(dst, lay, cx, cy, alpha, dx=0.0, dy=0.0, anchor="c"):
+    if alpha <= 0.004:
+        return
+    im = alpha_scale(lay, alpha) if alpha < 0.999 else lay
+    if anchor == "c":
+        x = int(cx - lay.size[0] / 2 + dx); y = int(cy - lay.size[1] / 2 + dy)
+    else:  # top-left
+        x = int(cx + dx); y = int(cy + dy)
+    if x + im.size[0] < 0 or y + im.size[1] < 0 or x > W or y > H:
+        return
+    dst.alpha_composite(im, (x, y))
+
+def rule_strip(w, alpha, thickness=2):
+    ramp = np.linspace(0.0, 1.0, max(2, w))
+    a = (np.sin(np.pi * ramp) ** 1.4 * 255 * alpha).astype(np.uint8)
+    st = np.zeros((thickness, max(2, w), 4), dtype=np.uint8)
+    st[..., 0], st[..., 1], st[..., 2] = GOLD[0], GOLD[1], GOLD[2]
+    st[..., 3] = a
+    return Image.fromarray(st, "RGBA")
+
+# ----------------------------------------------------------------- furniture
+def build_bg():
+    y = np.linspace(0, 1, H)[:, None]
+    bg = np.array(BG_TOP)[None, None, :] * (1 - y[..., None]) + np.array(BG_BOT)[None, None, :] * y[..., None]
+    bg = np.repeat(bg, W, axis=1).astype(np.float32)
+    yy, xx = np.mgrid[0:H, 0:W].astype(np.float32)
+    d = np.sqrt(((xx - W * 0.5) / (W * 0.80)) ** 2 + ((yy - H * 0.40) / (H * 0.52)) ** 2)
+    glow = np.clip(1 - d, 0, 1) ** 2.3
+    bg += glow[..., None] * np.array([118, 58, 18], dtype=np.float32)[None, None, :]
+    return Image.fromarray(np.clip(bg, 0, 255).astype(np.uint8), "RGB")
+
+def build_frame():
+    S = 2
+    im = Image.new("RGBA", (W * S, H * S), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
+    for m, col, a, wd in ((38, GOLD, 215, 2.2), (54, GOLD_L, 105, 1.0)):
+        d.rectangle([m * S, m * S, (W - m) * S, (H - m) * S], outline=col + (a,), width=int(wd * S))
+    for cx, cy, sx, sy in ((72, 72, 1, 1), (W - 72, 72, -1, 1), (72, H - 72, 1, -1), (W - 72, H - 72, -1, -1)):
+        L = 44
+        d.line([cx * S, cy * S, (cx + L * sx) * S, cy * S], fill=GOLD_L + (170,), width=int(1.5 * S))
+        d.line([cx * S, cy * S, cx * S, (cy + L * sy) * S], fill=GOLD_L + (170,), width=int(1.5 * S))
+        for k in (1, 2, 3):
+            px, py = cx + 11 * k * sx, cy + 11 * k * sy
+            d.ellipse([(px - 3) * S, (py - 3) * S, (px + 3) * S, (py + 3) * S], fill=MARIGOLD + (150,))
+    return im.resize((W, H), Image.LANCZOS)
+
+def build_toran(height=210):
+    im = Image.new("RGBA", (W, height), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
+    d.rectangle([0, 0, W, 14], fill=(28, 5, 14, 255))
+    for i in range(0, W, 22):
+        d.ellipse([i + 3, 10, i + 19, 26], fill=GOLD_D + (230,))
+    for k in range(4):
+        x0, x1 = W * k / 4.0, W * (k + 1) / 4.0
+        for i in range(48):
+            t = i / 47.0
+            x = x0 + (x1 - x0) * t
+            yy = 52 + math.sin(math.pi * t) * 74
+            r = 12.5
+            col = MARIGOLD if i % 2 == 0 else ORANGE
+            d.ellipse([x - r, yy - r, x + r, yy + r], fill=col + (238,))
+            d.ellipse([x - r * 0.34, yy - r * 0.55, x + r * 0.18, yy - r * 0.12], fill=(255, 236, 196, 130))
+        jx = x1 if k < 3 else None
+        if jx:
+            d.polygon([(jx, 108), (jx - 13, 92), (jx, 74), (jx + 13, 92)], fill=(58, 122, 74, 210))
+    for x in (W * 0.25, W * 0.5, W * 0.75):
+        d.line([x, 118, x, 176], fill=GOLD_L + (170,), width=2)
+        d.ellipse([x - 11, 172, x + 11, 194], fill=ORANGE + (238,))
+        d.ellipse([x - 4, 177, x + 2, 183], fill=(255, 236, 196, 150))
+    return im
+
+def build_mandala(size=1040):
+    S = 2; s = size * S
+    im = Image.new("RGBA", (s, s), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
+    c = s / 2.0
+    for rf, wd, a in ((0.480, 2.4, 90), (0.452, 1.1, 55), (0.300, 1.1, 45), (0.196, 2.0, 70), (0.120, 1.1, 45)):
+        r = s * rf / 2.0
+        d.ellipse([c - r, c - r, c + r, c + r], outline=GOLD_L + (a,), width=int(wd * S))
+    for i in range(24):
+        ang = 360.0 * i / 24
+        pw, ph = int(s * 0.115), int(s * 0.038)
+        p = Image.new("RGBA", (pw, ph), (0, 0, 0, 0))
+        ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (85,), width=int(1.5 * S))
+        p = p.rotate(-ang, expand=True, resample=Image.BICUBIC)
+        r = s * 0.368 / 2.0
+        x = c + r * math.cos(math.radians(ang)) - p.size[0] / 2.0
+        y = c + r * math.sin(math.radians(ang)) - p.size[1] / 2.0
+        im.alpha_composite(p, (int(x), int(y)))
+    for i in range(48):
+        ang = 360.0 * i / 48
+        r = s * 0.248 / 2.0
+        x, y = c + r * math.cos(math.radians(ang)), c + r * math.sin(math.radians(ang))
+        d.ellipse([x - 3.2 * S, y - 3.2 * S, x + 3.2 * S, y + 3.2 * S], fill=MARIGOLD + (105,))
+    return im.resize((size, size), Image.LANCZOS)
+
+def build_diya(size=200):
+    S = 2; s = size * S
+    im = Image.new("RGBA", (s, s), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
+    d.chord([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=0, end=180, fill=GOLD_D + (255,))
+    d.chord([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=0, end=180, outline=GOLD_L + (255,), width=int(3 * S))
+    d.arc([s * 0.10, s * 0.50, s * 0.90, s * 0.98], start=180, end=360, fill=GOLD_L + (220,), width=int(3 * S))
+    fx, fy = s * 0.5, s * 0.50
+    d.polygon([(fx, fy - s * 0.30), (fx - s * 0.070, fy), (fx + s * 0.070, fy)], fill=(255, 206, 108, 255))
+    d.ellipse([fx - s * 0.070, fy - s * 0.085, fx + s * 0.070, fy + s * 0.085], fill=(255, 206, 108, 255))
+    d.polygon([(fx, fy - s * 0.175), (fx - s * 0.033, fy - s * 0.005), (fx + s * 0.033, fy - s * 0.005)], fill=(255, 250, 226, 255))
+    return im.resize((size, size), Image.LANCZOS)
+
+def build_glow(size=420, radius=170.0):
+    yy, xx = np.mgrid[0:size, 0:size]
+    c = (size - 1) / 2.0
+    d = np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / radius
+    g = np.clip(1 - d, 0, 1) ** 2.4
+    arr = np.zeros((size, size, 4), dtype=np.uint8)
+    arr[..., 0], arr[..., 1], arr[..., 2] = 255, 176, 70
+    arr[..., 3] = (g * 195).astype(np.uint8)
+    return Image.fromarray(arr, "RGBA")
+
+def build_mote(size=26):
+    yy, xx = np.mgrid[0:size, 0:size]
+    c = (size - 1) / 2.0
+    r = np.sqrt((xx - c) ** 2 + (yy - c) ** 2) / c
+    g = np.clip(1 - r, 0, 1) ** 2.0
+    arr = np.zeros((size, size, 4), dtype=np.uint8)
+    arr[..., 0], arr[..., 1], arr[..., 2] = 244, 214, 150
+    arr[..., 3] = (g * 210).astype(np.uint8)
+    return Image.fromarray(arr, "RGBA")
+
+def build_lotus(size=124):
+    im = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    for i in range(6):
+        pw, ph = int(size * 0.86), int(size * 0.26)
+        p = Image.new("RGBA", (pw, ph), (0, 0, 0, 0))
+        ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (215,), width=3)
+        p = p.rotate(-(i * 30), expand=True, resample=Image.BICUBIC)
+        im.alpha_composite(p, (size // 2 - p.size[0] // 2, size // 2 - p.size[1] // 2))
+    d = ImageDraw.Draw(im)
+    d.ellipse([size / 2 - 8, size / 2 - 8, size / 2 + 8, size / 2 + 8], fill=MARIGOLD + (235,))
+    return im
+
+def build_monogram(D=600):
+    im = Image.new("RGBA", (D, D), (0, 0, 0, 0)); d = ImageDraw.Draw(im)
+    c = D / 2.0
+    d.ellipse([5, 5, D - 5, D - 5], outline=GOLD + (215,), width=3)
+    d.ellipse([21, 21, D - 21, D - 21], outline=GOLD_L + (120,), width=2)
+    d.ellipse([34, 34, D - 34, D - 34], outline=GOLD_L + (70,), width=1)
+    for i in range(14):
+        ang = 360.0 * i / 14
+        pw, ph = int(D * 0.19), int(D * 0.075)
+        p = Image.new("RGBA", (pw, ph), (0, 0, 0, 0))
+        ImageDraw.Draw(p).ellipse([0, 0, pw - 1, ph - 1], outline=GOLD_L + (120,), width=2)
+        p = p.rotate(-ang, expand=True, resample=Image.BICUBIC)
+        r = D * 0.415
+        x = c + r * math.cos(math.radians(ang)) - p.size[0] / 2.0
+        y = c + r * math.sin(math.radians(ang)) - p.size[1] / 2.0
+        im.alpha_composite(p, (int(x), int(y)))
+    lay = text_layer([EV["name"][0].upper()], "script", int(D * 0.60), CREAM)
+    im.alpha_composite(lay, (int(c - lay.size[0] / 2), int(c - lay.size[1] / 2)))
+    return im
+
+def make_card(width, title, sections, title_size=66, label_size=26, value_size=46, alpha=205):
+    Hc = 1400
+    card = Image.new("RGBA", (width, Hc), (0, 0, 0, 0))
+    S = 2
+    tmp = Image.new("RGBA", (width * S, Hc * S), (0, 0, 0, 0))
+    ImageDraw.Draw(tmp).rounded_rectangle([0, 0, width * S - 1, Hc * S - 1], radius=int(16 * S),
+                                          fill=(60, 11, 28, alpha), outline=GOLD + (235,), width=int(2.2 * S))
+    card.alpha_composite(tmp.resize((width, Hc), Image.LANCZOS), (0, 0))
+    y = 74
+    if title:
+        tl = text_layer([title], "script", title_size, GOLD)
+        card.alpha_composite(tl, (int(width / 2 - tl.size[0] / 2), int(y)))
+        y += tl.size[1] + 30
+        rw = int(width * 0.44)
+        card.alpha_composite(rule_strip(rw, 0.9, 2), (int(width / 2 - rw / 2), int(y)))
+        y += 46
+    for si, sec in enumerate(sections):
+        if si:
+            rw = int(width * 0.34)
+            card.alpha_composite(rule_strip(rw, 0.55, 1), (int(width / 2 - rw / 2), int(y)))
+            y += 38
+        ll = text_layer([sec["label"]], "serif", label_size, GOLD, tracking=11)
+        card.alpha_composite(ll, (int(width / 2 - ll.size[0] / 2), int(y)))
+        y += ll.size[1] + 22
+        for v in sec["values"]:
+            vl = text_layer([v], "body", value_size, CREAM)
+            card.alpha_composite(vl, (int(width / 2 - vl.size[0] / 2), int(y)))
+            y += vl.size[1] + 12
+        y += 18
+    used = y + 40
+    tl2 = build_lotus(64)
+    card.alpha_composite(tl2, (int(width / 2 - 32), int(used - 20)))
+    return card.crop((0, 0, width, min(Hc, used + 54)))
+
+# ----------------------------------------------------------------- build assets
+print("building assets ...")
+BG = build_bg().convert("RGBA")
+FRAME = build_frame()
+TORAN = build_toran()
+MANDALA = alpha_scale(build_mandala(1040), 0.19)
+DIYA = build_diya(200)
+LOTUS = build_lotus(120)
+LOTUS_S = build_lotus(64)
+GLOWS = alpha_variants(build_glow(430, 175.0), 12)
+MOTE_V = alpha_variants(build_mote(26), 12)
+MOTE_S = alpha_variants(build_mote(15), 12)
+
+random.seed(11)
+MOTES = [dict(x=random.uniform(70, W - 70), y=random.uniform(0, H), sp=random.uniform(58, 132),
+              sw=random.uniform(0.25, 0.7), ph=random.uniform(0, 6.28), big=random.random() < 0.45)
+         for _ in range(16)]
+
+kicker1 = text_layer([EV["hindi"]], "hindi", 44, GOLD) if HAS_RAQM else \
+          text_layer([EV["kicker1_en"]], "serif", 34, GOLD, tracking=13)
+if HAS_RAQM:
+    k1_extra = text_layer([EV["kicker1_en"]], "serif", 26, GOLD, tracking=11)
+else:
+    k1_extra = None
+
+L_script1 = text_layer([EV["script1"]], "script", 158, GOLD)
+L_sub1 = text_layer([EV["sub1"]], "bodyi", 46, SOFT)
+L_kick2 = text_layer([EV["kicker2"]], "serif", 32, GOLD, tracking=15)
+L_name = text_layer([EV["name"]], "script", 248, CREAM)
+L_name_glow = alpha_scale(text_layer([EV["name"]], "script", 248, GOLD).filter(ImageFilter.GaussianBlur(16)), 0.55)
+L_body2 = text_layer([EV["body2"]], "bodyi", 47, SOFT)
+L_small2 = text_layer([EV["small2"]], "serif", 28, GOLD, tracking=10)
+CARD_D = make_card(832, EV["card_title"], [
+    dict(label=EV["when_label"], values=[EV["when_1"], EV["when_2"]]),
+    dict(label=EV["where_label"], values=[EV["where_1"]]),
+])
+L_sub3 = text_layer([EV["sub3"]], "bodyi", 42, SOFT)
+MONO = build_monogram(600)
+L_quote = text_layer(EV["quote"], "bodyi", 47, SOFT, line_h=76)
+L_kick3 = text_layer(["THE CELEBRATION"], "serif", 32, GOLD, tracking=15)
+L_script5 = text_layer([EV["script5"]], "script", 104, GOLD)
+L_body5 = text_layer([EV["body5"]], "bodyi", 43, SOFT)
+L_name5 = text_layer([EV["name"]], "script", 152, CREAM)
+CARD_R = make_card(700, None, [dict(label=EV["rsvp_label"], values=[EV["rsvp_value"]])],
+                   label_size=28, value_size=44)
+L_kick6 = text_layer([EV["kicker6"]], "serif", 32, GOLD, tracking=15)
+L_script6 = text_layer([EV["script6"]], "script", 136, GOLD)
+L_sig = text_layer([EV["sig"]], "script", 80, CREAM)
+
+# ----------------------------------------------------------------- timeline
+DUR = [4.0, 5.0, 6.5, 5.5, 5.5, 5.5]
+OV, HOLD = 0.55, 2.0
+start = []
+acc = 0.0
+for d in DUR:
+    start.append(acc); acc += d - OV
+LAST_END = start[-1] + DUR[-1]
+TOTAL = LAST_END + HOLD
+FADES = 0.75
+NF = int(round(TOTAL * FPS))
+print("timeline:", [round(s, 2) for s in start], "last end", round(LAST_END, 2), "total", round(TOTAL, 2), "frames", NF)
+
+def scene_alpha(i, t):
+    s, e = start[i], (TOTAL if i == len(DUR) - 1 else start[i] + DUR[i])
+    if t < s or t > e:
+        return 0.0
+    if i + 1 < len(DUR) and t >= start[i + 1]:
+        return max(0.0, 1.0 - (t - start[i + 1]) / OV)
+    return 1.0
+
+def ease(t, delay, dur=0.95):
+    x = (t - delay) / dur
+    if x <= 0:
+        return 0.0
+    if x >= 1:
+        return 1.0
+    return 1.0 - (1.0 - x) ** 3
+
+# item = (layer, xf, yf, delay, dy, dur, anchor)
+ITEMS = [
+    [(kicker1, 0.5, 0.278, 0.10, 40, 0.9, "c"),
+     (k1_extra, 0.5, 0.325, 0.28, 34, 0.9, "c"),
+     (L_script1, 0.5, 0.408, 0.48, 62, 1.05, "c"),
+     (LOTUS, 0.5, 0.497, 0.88, 18, 0.8, "c"),
+     (L_sub1, 0.5, 0.556, 1.05, 40, 0.9, "c")],
+
+    [(L_kick2, 0.5, 0.297, 0.10, 38, 0.9, "c"),
+     (L_name_glow, 0.5, 0.415, 0.42, 58, 1.1, "c"),
+     (L_name, 0.5, 0.415, 0.42, 58, 1.1, "c"),
+     (LOTUS, 0.5, 0.525, 0.88, 18, 0.8, "c"),
+     (L_body2, 0.5, 0.588, 1.00, 40, 0.9, "c"),
+     (L_small2, 0.5, 0.650, 1.20, 30, 0.9, "c")],
+
+    [(L_kick3, 0.5, 0.252, 0.10, 38, 0.9, "c"),
+     (CARD_D, 0.5, 0.488, 0.40, 56, 1.05, "c"),
+     (L_sub3, 0.5, 0.732, 1.05, 40, 0.9, "c")],
+
+    [(MONO, 0.5, 0.400, 0.20, 50, 1.05, "c"),
+     (LOTUS_S, 0.5, 0.548, 0.90, 18, 0.8, "c"),
+     (L_quote, 0.5, 0.648, 1.05, 44, 1.0, "c")],
+
+    [(L_script5, 0.5, 0.286, 0.15, 50, 1.0, "c"),
+     (L_body5, 0.5, 0.362, 0.52, 40, 0.9, "c"),
+     (L_name5, 0.5, 0.441, 0.80, 56, 1.05, "c"),
+     (CARD_R, 0.5, 0.615, 1.10, 50, 1.0, "c")],
+
+    [(L_kick6, 0.5, 0.336, 0.15, 36, 0.9, "c"),
+     (L_script6, 0.5, 0.428, 0.45, 58, 1.05, "c"),
+     (LOTUS, 0.5, 0.515, 0.88, 18, 0.8, "c"),
+     (L_sig, 0.5, 0.578, 1.08, 44, 0.95, "c")],
+]
+
+def rgba_layer_to_box(lay):
+    return lay
+
+def render(t, poster=False):
+    img = BG.copy()
+    mand = MANDALA.rotate((t * 7.5) % 360.0, resample=Image.BICUBIC)
+    img.alpha_composite(mand, (int(W / 2 - mand.size[0] / 2), int(H * 0.455 - mand.size[1] / 2)))
+    img.alpha_composite(TORAN, (0, 0))
+    img.alpha_composite(FRAME, (0, 0))
+    for ph_i, cx in enumerate((148, W - 148)):
+        fl = 0.68 + 0.24 * math.sin(t * 7.2 + ph_i * 1.9) + 0.10 * math.sin(t * 16.7 + ph_i * 2.4)
+        fl = max(0.30, min(1.0, fl))
+        g = GLOWS[int(fl * 11)]
+        cy = H - 168
+        img.alpha_composite(g, (int(cx - g.size[0] / 2), int(cy - g.size[1] / 2 - 46)))
+        img.alpha_composite(DIYA, (int(cx - DIYA.size[0] / 2), int(cy - DIYA.size[1] / 2 - 46)))
+    for m in MOTES:
+        yy = (m["y"] - m["sp"] * t) % (H + 240) - 120
+        xx = m["x"] + 26 * math.sin(t * m["sw"] + m["ph"])
+        al = 0.22 + 0.62 * max(0.0, math.sin(t * 0.85 + m["ph"]))
+        idx = max(0, min(11, int(al * 11)))
+        sp = MOTE_V[idx] if m["big"] else MOTE_S[idx]
+        px, py = int(xx - sp.size[0] / 2), int(yy - sp.size[1] / 2)
+        if -sp.size[0] < px < W and -sp.size[1] < py < H:
+            img.alpha_composite(sp, (max(0, px), max(0, py)) if (px >= 0 and py >= 0) else (px, py))
+    for i in range(len(DUR)):
+        sa = scene_alpha(i, t)
+        if sa <= 0.004:
+            continue
+        tl = t - start[i]
+        for (lay, xf, yf, delay, dy, dur, an) in ITEMS[i]:
+            a = ease(tl, delay, dur) * sa
+            if an == "c":
+                paste(img, lay, W * xf, H * yf, a, dy=(1 - ease(tl, delay, dur)) * dy)
+            else:
+                paste(img, lay, W * xf, H * yf, a, dy=(1 - ease(tl, delay, dur)) * dy, anchor="tl")
+    if poster:
+        return img.convert("RGB")
+    if t < FADES:
+        k = t / FADES
+    elif t > TOTAL - FADES:
+        k = max(0.0, (TOTAL - t) / FADES)
+    else:
+        k = 1.0
+    rgb = img.convert("RGB")
+    if k < 1.0:
+        arr = np.asarray(rgb, dtype=np.float32) * k
+        return Image.fromarray(arr.astype(np.uint8), "RGB")
+    return rgb
+
+# ----------------------------------------------------------------- encode
+from imageio_ffmpeg import get_ffmpeg_exe
+FFMPEG = get_ffmpeg_exe()
+print("ffmpeg:", FFMPEG)
+cmd = [FFMPEG, "-y", "-loglevel", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
+       "-s", "%dx%d" % (W, H), "-r", str(FPS), "-i", "-",
+       "-c:v", "libx264", "-preset", "medium", "-crf", "20", "-pix_fmt", "yuv420p",
+       "-movflags", "+faststart", "-an", OUT]
+proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
+
+poster_t = start[1] + 2.6
+for n in range(NF):
+    t = n / float(FPS)
+    fr = render(t, poster=(abs(t - poster_t) < 0.5 / FPS))
+    if abs(t - poster_t) < 0.5 / FPS:
+        fr.save(POSTER, quality=92)
+    proc.stdin.write(np.asarray(fr, dtype=np.uint8).tobytes())
+    if n % 120 == 0:
+        print("frame %4d / %d  (t=%.1fs)" % (n, NF, t), flush=True)
+proc.stdin.close()
+proc.wait()
+print("encoded:", OUT, os.path.getsize(OUT), "bytes")
+
+# ----------------------------------------------------------------- upload
+from huggingface_hub import HfApi
+REPO = os.environ.get("REPO_ID", "coderdecoder01/retirement-invitation-mamta")
+tok = os.environ.get("HF_TOKEN")
+api = HfApi(token=tok)
+api.create_repo(repo_id=REPO, repo_type="dataset", private=False, exist_ok=True)
+api.upload_file(path_or_fileobj=OUT, path_in_repo="mamta-retirement-invitation.mp4",
+                repo_id=REPO, repo_type="dataset")
+api.upload_file(path_or_fileobj=POSTER, path_in_repo="poster.jpg", repo_id=REPO, repo_type="dataset")
+print("UPLOADED https://huggingface.co/datasets/%s/resolve/main/mamta-retirement-invitation.mp4" % REPO)
+print("POSTER   https://huggingface.co/datasets/%s/resolve/main/poster.jpg" % REPO)