Update app.py

app.py

@@ -3,10 +3,11 @@ import tempfile
 import io
 import math
 import time
+import random
 import numpy as np
 import cv2
 import gradio as gr
-from PIL import Image
+from PIL import Image, ImageFilter, ImageEnhance
 
 # ── HF SETUP ─────────────────────────────────────────────────────────────────
 hf_token = (
@@ -24,7 +25,7 @@ if hf_token:
     except Exception as e:
         print(f"⚠️ HF login skipped: {e}")
 else:
-    print("⚠️ No HF token — will use Ken Burns fallback only")
+    print("⚠️ No HF token — Ken Burns fallback will be used")
 
 print("✅ App ready!")
 
@@ -45,7 +46,7 @@ def try_hf_model(model_id, pil_image, prompt):
         return None
     try:
         buf = io.BytesIO()
-        pil_image.save(buf, format="JPEG")
+        pil_image.save(buf, format="JPEG", quality=95)
         image_bytes = buf.getvalue()
         print(f"   🤖 Trying {model_id} ...")
         result = hf_client.image_to_video(
@@ -72,7 +73,7 @@ def generate_video_with_fallback(pil_image, prompt, style, progress_callback=Non
             progress_callback(f"⏳ Trying: {model_name}")
 
         if model_id == "__ken_burns__":
-            print("   🎬 Using Ken Burns (local fallback)")
+            print("   🎬 Using Ken Burns (cinematic local)")
             path = generate_video_ken_burns(pil_image, style=style.lower())
             return path, f"🎨 {model_name}"
 
@@ -90,135 +91,310 @@ def generate_video_with_fallback(pil_image, prompt, style, progress_callback=Non
     return path, "🎨 Ken Burns (local)"
 
 
-# ── KEN BURNS VIDEO ───────────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════════
+#  CINEMATIC KEN BURNS — UPGRADED
+# ═══════════════════════════════════════════════════════════════════
+
+# ── Easing ───────────────────────────────────────────────────────────────────
 def ease_in_out(t):
+    t = max(0.0, min(1.0, t))
     return t * t * (3 - 2 * t)
 
-def ease_out_bounce(t):
-    if t < 1/2.75:
-        return 7.5625 * t * t
-    elif t < 2/2.75:
-        t -= 1.5/2.75
-        return 7.5625 * t * t + 0.75
-    elif t < 2.5/2.75:
-        t -= 2.25/2.75
-        return 7.5625 * t * t + 0.9375
+def ease_out_expo(t):
+    return 1 - math.pow(2, -10 * t) if t < 1 else 1.0
+
+def ease_in_out_cubic(t):
+    t = max(0.0, min(1.0, t))
+    if t < 0.5:
+        return 4 * t * t * t
+    return 1 - math.pow(-2 * t + 2, 3) / 2
+
+def cubic_bezier(t, p0, p1, p2, p3):
+    """Generic cubic bezier interpolation."""
+    u = 1 - t
+    return u**3*p0 + 3*u**2*t*p1 + 3*u*t**2*p2 + t**3*p3
+
+
+# ── Image Pre-processing ──────────────────────────────────────────────────────
+def preprocess_image(pil_image, target_w, target_h):
+    """Resize + smart sharpen + slight contrast boost."""
+    img = pil_image.convert("RGB")
+
+    # Smart crop to fill target aspect ratio without distortion
+    src_w, src_h = img.size
+    src_ratio = src_w / src_h
+    tgt_ratio = target_w / target_h
+    if src_ratio > tgt_ratio:
+        new_h = src_h
+        new_w = int(src_h * tgt_ratio)
+        left  = (src_w - new_w) // 2
+        img   = img.crop((left, 0, left + new_w, new_h))
     else:
-        t -= 2.625/2.75
-        return 7.5625 * t * t + 0.984375
+        new_w = src_w
+        new_h = int(src_w / tgt_ratio)
+        top   = (src_h - new_h) // 2
+        img   = img.crop((0, top, new_w, top + new_h))
 
-def apply_vignette(frame, strength=0.6):
-    h, w = frame.shape[:2]
-    Y, X = np.ogrid[:h, :w]
-    cx, cy = w / 2, h / 2
-    dist = np.sqrt(((X - cx) / cx) ** 2 + ((Y - cy) / cy) ** 2)
-    mask = np.clip(1.0 - strength * (dist ** 1.5), 0, 1)
-    return (frame * mask[:, :, np.newaxis]).astype(np.uint8)
+    # Resize with high quality
+    img = img.resize((target_w, target_h), Image.LANCZOS)
+
+    # Unsharp mask — brings out crisp details
+    img = img.filter(ImageFilter.UnsharpMask(radius=1.2, percent=130, threshold=2))
 
+    # Subtle contrast + saturation lift
+    img = ImageEnhance.Contrast(img).enhance(1.08)
+    img = ImageEnhance.Color(img).enhance(1.12)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+
+    return np.array(img)
+
+
+# ── Color Grading ─────────────────────────────────────���───────────────────────
 def apply_color_grade(frame, style="premium"):
-    f = frame.astype(np.float32)
+    """
+    Premium LUT-style grading:
+    - S-curve for contrast
+    - Per-channel color shifts
+    - Highlight/shadow split toning
+    """
+    f = frame.astype(np.float32) / 255.0
+
+    # S-curve (raises mids, deepens blacks, lifts highlights)
+    def scurve(x, strength=0.18):
+        return x + strength * x * (1 - x) * (2 * x - 1) * (-1)
+
+    f = scurve(f, strength=0.20)
+
     if style == "premium":
-        f[:,:,0] = np.clip(f[:,:,0] * 1.05, 0, 255)
-        f[:,:,2] = np.clip(f[:,:,2] * 1.08, 0, 255)
-        f = np.clip(f * 1.05, 0, 255)
+        # Teal-orange — Hollywood standard
+        # Shadows → teal, highlights → warm orange
+        lum = 0.299*f[:,:,0] + 0.587*f[:,:,1] + 0.114*f[:,:,2]
+        shadow_mask    = np.clip(1.0 - lum * 2.5,       0, 1)[:,:,np.newaxis]
+        highlight_mask = np.clip((lum - 0.6) * 2.5,     0, 1)[:,:,np.newaxis]
+        # Shadows: +teal (G+B, -R)
+        f[:,:,0] -= 0.04 * shadow_mask[:,:,0]
+        f[:,:,1] += 0.03 * shadow_mask[:,:,0]
+        f[:,:,2] += 0.05 * shadow_mask[:,:,0]
+        # Highlights: +warm (R+G, -B)
+        f[:,:,0] += 0.05 * highlight_mask[:,:,0]
+        f[:,:,1] += 0.02 * highlight_mask[:,:,0]
+        f[:,:,2] -= 0.04 * highlight_mask[:,:,0]
+        # Global slight brightness
+        f *= 1.04
+
     elif style == "energetic":
-        gray = np.mean(f, axis=2, keepdims=True)
-        f = np.clip(gray + 1.4 * (f - gray), 0, 255)
-        f = np.clip(f * 1.1, 0, 255)
+        # High saturation, punchy contrast, slight crush blacks
+        gray = 0.299*f[:,:,0:1] + 0.587*f[:,:,1:2] + 0.114*f[:,:,2:3]
+        f = np.clip(gray + 1.5 * (f - gray), 0, 1)   # +50% saturation
+        f = np.clip(f * 1.12 - 0.02, 0, 1)            # crush blacks slightly
+        f[:,:,0] = np.clip(f[:,:,0] * 1.06, 0, 1)     # red channel boost
+
     elif style == "fun":
-        f[:,:,0] = np.clip(f[:,:,0] * 1.1, 0, 255)
-        f[:,:,1] = np.clip(f[:,:,1] * 1.05, 0, 255)
-    return f.astype(np.uint8)
+        # Warm, bright, pastel-ish
+        f[:,:,0] = np.clip(f[:,:,0] * 1.10, 0, 1)     # warm reds
+        f[:,:,1] = np.clip(f[:,:,1] * 1.06, 0, 1)     # green lift
+        f[:,:,2] = np.clip(f[:,:,2] * 0.95, 0, 1)     # desaturate blue
+        f = np.clip(f * 1.05 + 0.02, 0, 1)            # lift blacks (matte look)
 
-def generate_video_ken_burns(pil_image, duration_sec=5, fps=24, style="premium"):
-    total_frames = duration_sec * fps
-    img = pil_image.convert("RGB")
-    target_w, target_h = 720, 1280
-    img = img.resize((target_w, target_h), Image.LANCZOS)
+    return np.clip(f * 255, 0, 255).astype(np.uint8)
 
-    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-    out = cv2.VideoWriter(tmp.name, fourcc, fps, (target_w, target_h))
 
-    pad = 160
-    big_h, big_w = target_h + pad * 2, target_w + pad * 2
-    big_img = np.array(img.resize((big_w, big_h), Image.LANCZOS))
+# ── Vignette ──────────────────────────────────────────────────────────────────
+def apply_vignette(frame, strength=0.65, softness=2.0):
+    """Oval cinematic vignette — darker, softer edges."""
+    h, w = frame.shape[:2]
+    Y, X  = np.ogrid[:h, :w]
+    cx, cy = w / 2, h / 2
+    # Oval (wider horizontally for portrait/reel format)
+    dist = np.sqrt(((X - cx) / (cx * 0.85))**2 + ((Y - cy) / cy)**2)
+    mask = np.clip(1.0 - strength * (dist ** softness), 0, 1)
+    return (frame * mask[:, :, np.newaxis]).astype(np.uint8)
+
+
+# ── Film Grain ────────────────────────────────────────────────────────────────
+def apply_film_grain(frame, intensity=6.0):
+    """Subtle luminance noise — makes it feel organic, not AI-flat."""
+    grain = np.random.normal(0, intensity, frame.shape).astype(np.float32)
+    result = frame.astype(np.float32) + grain
+    return np.clip(result, 0, 255).astype(np.uint8)
+
+
+# ── Light Leak ────────────────────────────────────────────────────────────────
+def apply_light_leak(frame, progress, style="premium"):
+    """
+    Sweeping diagonal light leak — appears at 30-60% of video.
+    Gives that 'lens flare' feel without actual 3D rendering.
+    """
+    if not (0.28 < progress < 0.65):
+        return frame
+
+    h, w = frame.shape[:2]
+    t = (progress - 0.28) / 0.37   # 0→1 within leak window
+    peak = math.sin(t * math.pi)    # rises and falls
 
-    s1_end = int(fps * 1.5)
-    s2_end = int(fps * 3.0)
-    s3_end = int(fps * 4.2)
-    s4_end = total_frames
+    # Diagonal gradient from top-right
+    Y, X = np.ogrid[:h, :w]
+    diag = (X / w + (h - Y) / h) / 2.0
+    leak_pos   = 0.3 + t * 0.6     # sweep across
+    leak_width = 0.25
+    leak_mask  = np.exp(-((diag - leak_pos)**2) / (2 * leak_width**2))
+
+    if style == "premium":
+        color = np.array([255, 220, 160], dtype=np.float32)   # warm gold
+    elif style == "energetic":
+        color = np.array([160, 200, 255], dtype=np.float32)   # electric blue
+    else:
+        color = np.array([255, 180, 200], dtype=np.float32)   # pink fun
+
+    strength  = peak * 0.22
+    leak_layer = (leak_mask[:,:,np.newaxis] * color * strength).astype(np.float32)
+    result     = np.clip(frame.astype(np.float32) + leak_layer, 0, 255)
+    return result.astype(np.uint8)
+
+
+# ── Cinematic Bars ─────────────────────────────────────────────────────────────
+def apply_letterbox(frame, bar_h=40):
+    """Black cinematic bars at top and bottom."""
+    frame[:bar_h,  :] = 0
+    frame[-bar_h:, :] = 0
+    return frame
+
+
+# ── Main Video Generator ──────────────────────────────────────────────────────
+def generate_video_ken_burns(
+    pil_image,
+    duration_sec = 6,
+    fps          = 30,        # 30fps — smoother than 24
+    style        = "premium",
+    add_grain    = True,
+    add_leak     = True,
+    add_bars     = True,
+):
+    """
+    Cinematic Ken Burns with:
+    ✅ 1080×1920  (full HD portrait / Reels format)
+    ✅ 30 fps
+    ✅ Smart aspect-ratio crop + LANCZOS resize
+    ✅ Unsharp mask sharpening
+    ✅ S-curve + split-toning color grade
+    ✅ Oval soft vignette
+    ✅ Subtle film grain
+    ✅ Diagonal light leak sweep
+    ✅ Cinematic letterbox bars
+    ✅ Smooth bezier motion paths
+    ✅ Fade in / fade out
+    """
+    TARGET_W, TARGET_H = 1080, 1920
+    RENDER_W, RENDER_H = 1080, 1920  # full res render
+
+    total_frames = duration_sec * fps   # 180 frames @ 30fps
+
+    # ── Prepare canvas ──────────────────────────────────────────────────────
+    pad    = 220                        # generous padding for all movements
+    big_w  = RENDER_W + pad * 2
+    big_h  = RENDER_H + pad * 2
+
+    base   = preprocess_image(pil_image, big_w, big_h)  # large canvas
+
+    # ── Output file ─────────────────────────────────────────────────────────
+    tmp    = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(tmp.name, fourcc, fps, (TARGET_W, TARGET_H))
+
+    # ── Motion keyframes (zoom, pan_x, pan_y) ───────────────────────────────
+    # Each segment: (start_zoom, end_zoom, start_px, end_px, start_py, end_py)
+    SEG = [
+        # t=0.00-0.25 : burst zoom in
+        (0.00, 0.25, 1.40, 1.15,  0,        int(-pad*0.10),  0,        int(-pad*0.12)),
+        # t=0.25-0.55 : slow upward drift
+        (0.25, 0.55, 1.15, 1.08,  int(-pad*0.05), int(pad*0.08),  int(-pad*0.12), int(-pad*0.30)),
+        # t=0.55-0.78 : subtle right pan + tiny zoom out
+        (0.55, 0.78, 1.08, 1.05,  int(pad*0.08),  int(pad*0.18),  int(-pad*0.30), int(-pad*0.18)),
+        # t=0.78-1.00 : pull back + settle
+        (0.78, 1.00, 1.05, 1.00,  int(pad*0.18),  0,              int(-pad*0.18), 0),
+    ]
 
     for i in range(total_frames):
-        if i < s1_end:
-            t  = i / s1_end
-            te = ease_out_bounce(min(t * 1.1, 1.0))
-            zoom  = 1.35 - 0.25 * te
-            pan_x = int(pad * 0.1 * t)
-            pan_y = int(-pad * 0.15 * t)
-        elif i < s2_end:
-            t  = (i - s1_end) / (s2_end - s1_end)
-            te = ease_in_out(t)
-            zoom    = 1.10 - 0.05 * te
-            shake_x = int(3 * math.sin(i * 0.8))
-            shake_y = int(2 * math.cos(i * 1.1))
-            pan_x   = int(pad * 0.1 + shake_x)
-            pan_y   = int(-pad * 0.15 - pad * 0.20 * te + shake_y)
-        elif i < s3_end:
-            t  = (i - s2_end) / (s3_end - s2_end)
-            te = ease_in_out(t)
-            zoom  = 1.05 - 0.04 * te
-            pan_x = int(pad * 0.1 * (1 - te))
-            pan_y = int(-pad * 0.35 * (1 - te))
-        else:
-            t  = (i - s3_end) / (s4_end - s3_end)
-            te = ease_in_out(t)
-            zoom  = 1.01 + 0.03 * te
-            pan_x = 0
-            pan_y = 0
-
-        crop_w = int(target_w / zoom)
-        crop_h = int(target_h / zoom)
-        cx = big_w // 2 + pan_x
-        cy = big_h // 2 + pan_y
+        t_global = i / (total_frames - 1)    # 0.0 → 1.0
+
+        # Find active segment
+        zoom = pan_x = pan_y = None
+        for (t0, t1, z0, z1, px0, px1, py0, py1) in SEG:
+            if t0 <= t_global <= t1 or (zoom is None and t_global < t0):
+                if t0 <= t_global <= t1:
+                    seg_t = (t_global - t0) / (t1 - t0)
+                    te    = ease_in_out_cubic(seg_t)
+                    zoom  = z0 + (z1 - z0) * te
+                    pan_x = int(px0 + (px1 - px0) * te)
+                    pan_y = int(py0 + (py1 - py0) * te)
+                    break
+
+        if zoom is None:
+            zoom, pan_x, pan_y = 1.00, 0, 0
+
+        # ── Micro camera shake (only in first 30% of video) ─────────────────
+        if t_global < 0.30:
+            shake_strength = (0.30 - t_global) / 0.30 * 2.5
+            pan_x += int(shake_strength * math.sin(i * 1.3))
+            pan_y += int(shake_strength * math.cos(i * 0.9))
+
+        # ── Crop from canvas ─────────────────────────────────────────────────
+        crop_w = int(RENDER_W / zoom)
+        crop_h = int(RENDER_H / zoom)
+        cx     = big_w // 2 + pan_x
+        cy     = big_h // 2 + pan_y
+
         x1 = max(0, cx - crop_w // 2)
         y1 = max(0, cy - crop_h // 2)
         x2 = min(big_w, x1 + crop_w)
         y2 = min(big_h, y1 + crop_h)
 
-        if x2 - x1 < 10 or y2 - y1 < 10:
-            x1, y1, x2, y2 = 0, 0, target_w, target_h
+        # Guard
+        if (x2 - x1) < 10 or (y2 - y1) < 10:
+            x1, y1, x2, y2 = 0, 0, RENDER_W, RENDER_H
+
+        cropped = base[y1:y2, x1:x2]
+        # High quality resize — LANCZOS4 is the best OpenCV offers
+        frame   = cv2.resize(cropped, (RENDER_W, RENDER_H), interpolation=cv2.INTER_LANCZOS4)
+
+        # ── Post-processing pipeline ─────────────────────────────────────────
+        frame = apply_color_grade(frame, style)
+
+        if add_leak:
+            frame = apply_light_leak(frame, t_global, style)
+
+        frame = apply_vignette(frame, strength=0.60, softness=2.2)
+
+        if add_grain:
+            grain_strength = 5.5 if style != "premium" else 4.0
+            frame = apply_film_grain(frame, intensity=grain_strength)
 
-        cropped = big_img[y1:y2, x1:x2]
-        frame   = cv2.resize(cropped, (target_w, target_h), interpolation=cv2.INTER_LINEAR)
-        frame   = apply_color_grade(frame, style)
-        frame   = apply_vignette(frame, strength=0.55)
+        if add_bars:
+            frame = apply_letterbox(frame, bar_h=48)
 
-        fade_in_end  = int(fps * 0.4)
-        fade_out_sta = int(fps * 4.4)
-        if i < fade_in_end:
-            alpha = ease_in_out(i / fade_in_end)
-        elif i >= fade_out_sta:
-            alpha = ease_in_out(1.0 - (i - fade_out_sta) / (total_frames - fade_out_sta))
+        # ── Fade in / out ────────────────────────────────────────────────────
+        FADE_IN  = 0.06   # first 6%
+        FADE_OUT = 0.90   # last 10%
+        if t_global < FADE_IN:
+            alpha = ease_out_expo(t_global / FADE_IN)
+        elif t_global > FADE_OUT:
+            alpha = ease_in_out(1.0 - (t_global - FADE_OUT) / (1.0 - FADE_OUT))
         else:
             alpha = 1.0
 
-        flash_frames = {s1_end, s1_end+1, s2_end, s2_end+1}
-        if i in flash_frames:
-            fs    = 0.35 if i in {s1_end, s2_end} else 0.15
-            white = np.ones_like(frame) * 255
-            frame = cv2.addWeighted(frame, 1 - fs, white.astype(np.uint8), fs, 0)
+        if alpha < 1.0:
+            frame = np.clip(frame.astype(np.float32) * alpha, 0, 255).astype(np.uint8)
 
-        frame     = np.clip(frame.astype(np.float32) * alpha, 0, 255).astype(np.uint8)
+        # ── Write ────────────────────────────────────────────────────────────
         frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
-        out.write(frame_bgr)
+        writer.write(frame_bgr)
 
-    out.release()
+    writer.release()
     return tmp.name
 
 
 # ── MAIN ──────────────────────────────────────────────────────────────────────
-def generate_ad(image, prompt_text, style, progress=gr.Progress()):
+def generate_ad(image, prompt_text, style, add_grain, add_leak, add_bars, progress=gr.Progress()):
     if image is None:
         return None, "⚠️ Please upload an image first!"
 
@@ -229,7 +405,7 @@ def generate_ad(image, prompt_text, style, progress=gr.Progress()):
 
     def log(msg):
         status_lines.append(msg)
-        progress(0.2 + len(status_lines) * 0.12, desc=msg)
+        progress(0.2 + len(status_lines) * 0.10, desc=msg)
 
     progress(0.1, desc="🎬 Starting video generation...")
 
@@ -240,6 +416,17 @@ def generate_ad(image, prompt_text, style, progress=gr.Progress()):
         progress_callback=log,
     )
 
+    # If ken burns was used, regenerate with user options
+    if "Ken Burns" in model_used:
+        progress(0.7, desc="🎨 Rendering cinematic video...")
+        video_path = generate_video_ken_burns(
+            pil_image,
+            style    = style.lower(),
+            add_grain= add_grain,
+            add_leak = add_leak,
+            add_bars = add_bars,
+        )
+
     progress(1.0, desc="✅ Done!")
     log_text = "\n".join(status_lines) + f"\n\n✅ Used: {model_used}"
     return video_path, log_text
@@ -247,27 +434,34 @@ def generate_ad(image, prompt_text, style, progress=gr.Progress()):
 
 # ── UI ────────────────────────────────────────────────────────────────────────
 css = """
-#title { text-align:center; font-size:2.2rem; font-weight:800; margin-bottom:.2rem; }
-#sub   { text-align:center; color:#888; margin-bottom:1.5rem; }
+#title { text-align:center; font-size:2.4rem; font-weight:900; margin-bottom:.2rem; }
+#sub   { text-align:center; color:#888; margin-bottom:1.5rem; font-size:1.05rem; }
 """
 
 with gr.Blocks(css=css, theme=gr.themes.Soft(primary_hue="violet")) as demo:
 
     gr.Markdown("# 🎬 AI Reel Generator", elem_id="title")
-    gr.Markdown("Image upload karo → cinematic video ready!", elem_id="sub")
+    gr.Markdown("Image upload karo → **cinematic 1080p video** ready in seconds!", elem_id="sub")
 
     with gr.Row():
+        # ── LEFT ─────────────────────────────────────────────────────────────
         with gr.Column(scale=1):
             image_input  = gr.Image(label="📸 Upload Image", type="pil", height=320)
             prompt_input = gr.Textbox(
-                label="✏️ Prompt (optional)",
+                label="✏️ Prompt (optional — for AI models)",
                 placeholder="e.g. cinematic slow zoom, product floating in air ...",
-                lines=3,
+                lines=2,
             )
             style_dd = gr.Dropdown(
-                choices=["Fun", "Premium", "Energetic"],
-                value="Premium", label="🎨 Style",
+                choices=["Premium", "Energetic", "Fun"],
+                value="Premium", label="🎨 Color Grade Style",
             )
+
+            with gr.Row():
+                grain_cb = gr.Checkbox(label="🎞 Film Grain",    value=True)
+                leak_cb  = gr.Checkbox(label="✨ Light Leak",    value=True)
+                bars_cb  = gr.Checkbox(label="🎬 Cinematic Bars", value=True)
+
             gen_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
 
             gr.Markdown(
@@ -277,18 +471,26 @@ with gr.Blocks(css=css, theme=gr.themes.Soft(primary_hue="violet")) as demo:
                 "3. Stable Video Diffusion XT\n"
                 "4. KlingTeam/LivePortrait\n"
                 "5. Lightricks/LTX-Video\n"
-                "6. Ken Burns (always works ✅)"
+                "6. 🎨 Ken Burns **1080p** (always works ✅)"
             )
 
+        # ── RIGHT ────────────────────────────────────────────────────────────
         with gr.Column(scale=1):
-            video_out  = gr.Video(label="🎥 Generated Video", height=450)
+            video_out  = gr.Video(label="🎥 Generated Video (1080×1920)", height=500)
             status_out = gr.Textbox(label="📊 Model Log", lines=8, interactive=False)
 
     gen_btn.click(
         fn=generate_ad,
-        inputs=[image_input, prompt_input, style_dd],
+        inputs=[image_input, prompt_input, style_dd, grain_cb, leak_cb, bars_cb],
         outputs=[video_out, status_out],
     )
 
+    gr.Markdown(
+        "---\n"
+        "**Ken Burns pipeline:** Smart crop → LANCZOS resize → Unsharp Mask → "
+        "S-curve + Split-toning Grade → Light Leak → Oval Vignette → "
+        "Film Grain → Cinematic Bars → Bezier motion → 30fps @ 1080×1920"
+    )
+
 if __name__ == "__main__":
     demo.launch()