Update app.py

app.py

@@ -1,495 +1,408 @@
-import os
-import tempfile
-import io
-import math
-import time
-import random
+import os, tempfile, io, math, time, threading, base64, requests
 import numpy as np
 import cv2
 import gradio as gr
 from PIL import Image, ImageFilter, ImageEnhance
 
-# ── HF SETUP ─────────────────────────────────────────────────────────────────
-hf_token = (
-    os.environ.get("HF_TOKEN", "")
-    or os.environ.get("HF_KEY", "")
-).strip()
+# ══════════════════════════════════════════════════════
+#  TOKENS
+# ══════════════════════════════════════════════════════
+FAL_KEY = (os.environ.get("FAL_KEY", "") or os.environ.get("FAL_API_KEY", "")).strip()
+HF_TOKEN = (os.environ.get("HF_TOKEN", "") or os.environ.get("HF_KEY", "")).strip()
 
 hf_client = None
-if hf_token:
+if HF_TOKEN:
     try:
         from huggingface_hub import login, InferenceClient
-        login(token=hf_token)
-        hf_client = InferenceClient(token=hf_token)
-        print("✅ HF login OK")
+        login(token=HF_TOKEN)
+        hf_client = InferenceClient(token=HF_TOKEN)
+        print("✅ HF ready")
     except Exception as e:
-        print(f"⚠️ HF login skipped: {e}")
+        print(f"⚠️ HF: {e}")
+
+if FAL_KEY:
+    os.environ["FAL_KEY"] = FAL_KEY
+    print("✅ fal.ai ready")
 else:
-    print("⚠️ No HF token — Ken Burns fallback will be used")
+    print("⚠️ No FAL_KEY — will skip fal.ai models")
 
 print("✅ App ready!")
 
 
-# ── HF MODEL FALLBACK CHAIN ───────────────────────────────────────────────────
-HF_MODELS = [
-    {"id": "Lightricks/LTX-2",                                    "name": "LTX-2 (Lightricks) ⚡"},
-    {"id": "Wan-AI/Wan2.2-I2V-A14B",                              "name": "Wan 2.2 I2V-A14B"},
-    {"id": "stabilityai/stable-video-diffusion-img2vid-xt",        "name": "Stable Video Diffusion XT"},
-    {"id": "KlingTeam/LivePortrait",                               "name": "KlingTeam LivePortrait"},
-    {"id": "Lightricks/LTX-Video",                                 "name": "LTX-Video"},
-    {"id": "__ken_burns__",                                        "name": "Ken Burns (local fallback)"},
-]
+# ══════════════════════════════════════════════════════
+#  HELPERS
+# ══════════════════════════════════════════════════════
+def pil_to_b64(img: Image.Image, quality=92) -> str:
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=quality)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode()
 
+def pil_to_bytes(img: Image.Image, quality=92) -> bytes:
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=quality)
+    return buf.getvalue()
 
-def try_hf_model(model_id, pil_image, prompt):
-    if hf_client is None:
+def download_video(url: str) -> bytes | None:
+    try:
+        r = requests.get(url, timeout=60)
+        if r.status_code == 200:
+            return r.content
+    except Exception as e:
+        print(f"  ⚠️ download failed: {e}")
+    return None
+
+def save_video_bytes(data: bytes) -> str:
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    tmp.write(data); tmp.flush()
+    return tmp.name
+
+def run_with_timeout(fn, timeout, *args, **kwargs):
+    """Run fn in thread, return result or None on timeout."""
+    box = [None]; err = [None]
+    def _run():
+        try: box[0] = fn(*args, **kwargs)
+        except Exception as e: err[0] = str(e)
+    t = threading.Thread(target=_run, daemon=True)
+    t.start(); t.join(timeout=timeout)
+    if t.is_alive():
+        print(f"  ⏱ Timeout after {timeout}s")
+        return None
+    if err[0]: print(f"  ❌ Error: {err[0][:120]}")
+    return box[0]
+
+
+# ══════════════════════════════════════════════════════
+#  FAL.AI MODELS  (real AI generation — best quality)
+# ══════════════════════════════════════════════════════
+
+def try_fal_ltx(pil_image: Image.Image, prompt: str) -> bytes | None:
+    """fal-ai/ltx-video/image-to-video — fastest, ~15-25s"""
+    if not FAL_KEY:
         return None
     try:
-        buf = io.BytesIO()
-        pil_image.save(buf, format="JPEG", quality=95)
-        image_bytes = buf.getvalue()
-        print(f"   🤖 Trying {model_id} ...")
-        result = hf_client.image_to_video(
-            image=image_bytes,
-            model=model_id,
-            prompt=prompt,
+        import fal_client
+
+        img_url = fal_client.upload_image(pil_image)   # upload to fal CDN
+
+        result = fal_client.run(
+            "fal-ai/ltx-video/image-to-video",
+            arguments={
+                "image_url":    img_url,
+                "prompt":       prompt,
+                "num_frames":   121,     # ~5s @ 24fps
+                "fps":          24,
+                "guidance_scale": 3.5,
+                "num_inference_steps": 30,
+            },
         )
-        if isinstance(result, bytes):
-            return result
-        elif hasattr(result, "read"):
-            return result.read()
+        video_url = result.get("video", {}).get("url") or result.get("video_url")
+        if video_url:
+            return download_video(video_url)
+    except Exception as e:
+        print(f"  ❌ fal LTX: {e}")
+    return None
+
+
+def try_fal_wan(pil_image: Image.Image, prompt: str) -> bytes | None:
+    """fal-ai/wan-i2v — Wan2.1 image-to-video"""
+    if not FAL_KEY:
         return None
+    try:
+        import fal_client
+
+        img_url = fal_client.upload_image(pil_image)
+
+        result = fal_client.run(
+            "fal-ai/wan-i2v",
+            arguments={
+                "image_url": img_url,
+                "prompt":    prompt,
+                "num_frames": 81,
+                "fps": 16,
+            },
+        )
+        video_url = (
+            result.get("video", {}).get("url")
+            or result.get("video_url")
+        )
+        if video_url:
+            return download_video(video_url)
     except Exception as e:
-        print(f"   ❌ {model_id} failed: {e}")
+        print(f"  ❌ fal Wan: {e}")
+    return None
+
+
+def try_fal_kling(pil_image: Image.Image, prompt: str) -> bytes | None:
+    """fal-ai/kling-video/v1.6/standard/image-to-video"""
+    if not FAL_KEY:
         return None
+    try:
+        import fal_client
+
+        img_b64 = pil_to_b64(pil_image)
+
+        result = fal_client.run(
+            "fal-ai/kling-video/v1.6/standard/image-to-video",
+            arguments={
+                "image_url": img_b64,
+                "prompt":    prompt,
+                "duration":  "5",
+                "aspect_ratio": "9:16",
+            },
+        )
+        video_url = (
+            result.get("video", {}).get("url")
+            or result.get("video_url")
+        )
+        if video_url:
+            return download_video(video_url)
+    except Exception as e:
+        print(f"  ❌ fal Kling: {e}")
+    return None
 
 
-def generate_video_with_fallback(pil_image, prompt, style, progress_callback=None):
-    for model_info in HF_MODELS:
-        model_id   = model_info["id"]
-        model_name = model_info["name"]
+# ══════════════════════════════════════════════════════
+#  HF FALLBACK
+# ══════════════════════════════════════════════════════
+def try_hf_ltx(pil_image: Image.Image, prompt: str) -> bytes | None:
+    if hf_client is None:
+        return None
+    try:
+        r = hf_client.image_to_video(
+            image=pil_to_bytes(pil_image),
+            model="Lightricks/LTX-2",
+            prompt=prompt,
+        )
+        return r.read() if hasattr(r, "read") else r
+    except Exception as e:
+        print(f"  ❌ HF LTX-2: {e}")
+    return None
+
+
+# ══════════════════════════════════════════════════════
+#  FULL FALLBACK CHAIN
+# ══════════════════════════════════════════════════════
+CHAIN = [
+    # (name, fn, timeout_sec)
+    ("🤖 fal.ai — LTX-Video",     try_fal_ltx,   90),
+    ("🤖 fal.ai — Wan2.1 I2V",    try_fal_wan,   120),
+    ("🤖 fal.ai — Kling v1.6",    try_fal_kling, 120),
+    ("🤖 HF — LTX-2",             try_hf_ltx,    60),
+    ("🎨 Ken Burns (local)",       None,          0),   # always works
+]
 
-        if progress_callback:
-            progress_callback(f"⏳ Trying: {model_name}")
+def generate_video_with_fallback(pil_image, prompt, style, cb=None):
+    for name, fn, timeout in CHAIN:
+        if cb: cb(f"⏳ Trying: {name}")
 
-        if model_id == "__ken_burns__":
-            print("   🎬 Using Ken Burns (cinematic local)")
+        if fn is None:                     # Ken Burns fallback
             path = generate_video_ken_burns(pil_image, style=style.lower())
-            return path, f"🎨 {model_name}"
+            return path, f"🎨 Ken Burns (local)"
 
-        video_bytes = try_hf_model(model_id, pil_image, prompt)
-        if video_bytes:
-            tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-            tmp.write(video_bytes)
-            tmp.flush()
-            print(f"   ✅ SUCCESS with {model_name}")
-            return tmp.name, f"🤖 {model_name}"
-
-        time.sleep(1)
+        result = run_with_timeout(fn, timeout, pil_image, prompt)
+        if result:
+            return save_video_bytes(result), name
 
     path = generate_video_ken_burns(pil_image, style=style.lower())
     return path, "🎨 Ken Burns (local)"
 
 
-# ═══════════════════════════════════════════════════════════════════
-#  CINEMATIC KEN BURNS — UPGRADED
-# ═══════════════════════════════════════════════════════════════════
-
-# ── Easing ───────────────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════
+#  CINEMATIC KEN BURNS  (local fallback — always works)
+# ══════════════════════════════════════════════════════
 def ease_in_out(t):
     t = max(0.0, min(1.0, t))
-    return t * t * (3 - 2 * t)
-
-def ease_out_expo(t):
-    return 1 - math.pow(2, -10 * t) if t < 1 else 1.0
+    return t*t*(3-2*t)
 
 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
+    return 4*t*t*t if t<0.5 else 1-math.pow(-2*t+2,3)/2
 
+def ease_out_expo(t):
+    return 1-math.pow(2,-10*t) if t<1 else 1.0
 
-# ── Image Pre-processing ──────────────────────────────────────────────────────
-def preprocess_image(pil_image, target_w, target_h):
-    """Resize + smart sharpen + slight contrast boost."""
+def preprocess_image(pil_image, W, H):
     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))
+    sw, sh = img.size
+    if sw/sh > W/H:
+        nw = int(sh*W/H); img = img.crop(((sw-nw)//2,0,(sw-nw)//2+nw,sh))
     else:
-        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))
-
-    # 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
+        nh = int(sw*H/W); img = img.crop((0,(sh-nh)//2,sw,(sh-nh)//2+nh))
+    img = img.resize((W,H), Image.LANCZOS)
+    img = img.filter(ImageFilter.UnsharpMask(radius=1.0, percent=120, threshold=2))
     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"):
-    """
-    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)
-
+def apply_color_grade(f32, style):
+    f = f32 / 255.0
+    f = f + 0.20*f*(1-f)*(2*f-1)*(-1)          # S-curve
     if style == "premium":
-        # 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
+        lum = 0.299*f[:,:,0]+0.587*f[:,:,1]+0.114*f[:,:,2]
+        sh  = np.clip(1.0-lum*2.5,0,1)[:,:,np.newaxis]
+        hi  = np.clip((lum-0.6)*2.5,0,1)[:,:,np.newaxis]
+        f[:,:,0] += -0.04*sh[:,:,0] + 0.05*hi[:,:,0]
+        f[:,:,1] +=  0.03*sh[:,:,0] + 0.02*hi[:,:,0]
+        f[:,:,2] +=  0.05*sh[:,:,0] - 0.04*hi[:,:,0]
         f *= 1.04
-
     elif style == "energetic":
-        # 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
-
+        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); f = np.clip(f*1.12-0.02,0,1)
+        f[:,:,0] = np.clip(f[:,:,0]*1.06,0,1)
     elif style == "fun":
-        # 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)
-
-    return np.clip(f * 255, 0, 255).astype(np.uint8)
-
-
-# ── 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
-
-    # 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),
+        f[:,:,0]=np.clip(f[:,:,0]*1.10,0,1)
+        f[:,:,1]=np.clip(f[:,:,1]*1.06,0,1)
+        f[:,:,2]=np.clip(f[:,:,2]*0.95,0,1)
+        f=np.clip(f*1.05+0.02,0,1)
+    return np.clip(f*255,0,255).astype(np.uint8)
+
+def apply_light_leak(frame, tg, style):
+    if not (0.28<tg<0.65): return frame
+    t=((tg-0.28)/0.37); peak=math.sin(t*math.pi)
+    h,w=frame.shape[:2]; Y,X=np.ogrid[:h,:w]
+    diag=(X/w+(h-Y)/h)/2.0; lpos=0.3+t*0.6
+    mask=np.exp(-((diag-lpos)**2)/(2*0.25**2))
+    c={"premium":[255,220,160],"energetic":[160,200,255],"fun":[255,180,200]}
+    col=np.array(c.get(style,[255,220,160]),dtype=np.float32)
+    leak=(mask[:,:,np.newaxis]*col*peak*0.20).astype(np.float32)
+    return np.clip(frame.astype(np.float32)+leak,0,255).astype(np.uint8)
+
+def generate_video_ken_burns(pil_image, duration_sec=6, fps=30, style="premium",
+                              add_grain=True, add_leak=True, add_bars=True):
+    TW,TH=720,1280; pad=180; BW,BH=TW+pad*2,TH+pad*2
+    base=preprocess_image(pil_image,BW,BH)
+    total=duration_sec*fps
+    tmp=tempfile.NamedTemporaryFile(suffix=".mp4",delete=False)
+    writer=cv2.VideoWriter(tmp.name,cv2.VideoWriter_fourcc(*"mp4v"),fps,(TW,TH))
+
+    SEG=[
+        (0.00,0.25, 1.38,1.14,  0,         int(-pad*.08), 0,          int(-pad*.10)),
+        (0.25,0.55, 1.14,1.07,  int(-pad*.05),int(pad*.07),int(-pad*.10),int(-pad*.28)),
+        (0.55,0.78, 1.07,1.04,  int(pad*.07),int(pad*.16),int(-pad*.28),int(-pad*.16)),
+        (0.78,1.00, 1.04,1.00,  int(pad*.16),0,           int(-pad*.16),0),
     ]
 
-    for i in range(total_frames):
-        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)
-
-        # 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)
-
+    Y,X=np.ogrid[:TH,:TW]; cx,cy=TW/2,TH/2
+    vmask=np.clip(1.0-0.60*(np.sqrt(((X-cx)/(cx*0.85))**2+((Y-cy)/cy)**2)**2.0),0,1).astype(np.float32)
+
+    for i in range(total):
+        tg=i/(total-1)
+        zoom=pan_x=pan_y=None
+        for t0,t1,z0,z1,px0,px1,py0,py1 in SEG:
+            if t0<=tg<=t1:
+                te=ease_in_out_cubic((tg-t0)/(t1-t0))
+                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.0,0,0
+        if tg<0.30:
+            s=(0.30-tg)/0.30*2.2
+            pan_x+=int(s*math.sin(i*1.3)); pan_y+=int(s*math.cos(i*0.9))
+
+        cw=int(TW/zoom); ch=int(TH/zoom)
+        ox=BW//2+pan_x; oy=BH//2+pan_y
+        x1=max(0,ox-cw//2); y1=max(0,oy-ch//2)
+        x2=min(BW,x1+cw);   y2=min(BH,y1+ch)
+        if (x2-x1)<10 or (y2-y1)<10: x1,y1,x2,y2=0,0,TW,TH
+
+        frame=cv2.resize(base[y1:y2,x1:x2],(TW,TH),interpolation=cv2.INTER_LINEAR)
+        frame=apply_color_grade(frame.astype(np.float32),style)
+        if add_leak: frame=apply_light_leak(frame,tg,style)
+        frame=np.clip(frame.astype(np.float32)*vmask[:,:,np.newaxis],0,255).astype(np.uint8)
         if add_grain:
-            grain_strength = 5.5 if style != "premium" else 4.0
-            frame = apply_film_grain(frame, intensity=grain_strength)
-
-        if add_bars:
-            frame = apply_letterbox(frame, bar_h=48)
-
-        # ── 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
+            frame=np.clip(frame.astype(np.float32)+np.random.normal(0,4.5,frame.shape),0,255).astype(np.uint8)
+        if add_bars: frame[:42,:]=0; frame[-42:,:]=0
 
-        if alpha < 1.0:
-            frame = np.clip(frame.astype(np.float32) * alpha, 0, 255).astype(np.uint8)
-
-        # ── Write ────────────────────────────────────────────────────────────
-        frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
-        writer.write(frame_bgr)
+        if tg<0.06: alpha=ease_out_expo(tg/0.06)
+        elif tg>0.90: alpha=ease_in_out(1.0-(tg-0.90)/0.10)
+        else: alpha=1.0
+        if alpha<1.0: frame=np.clip(frame.astype(np.float32)*alpha,0,255).astype(np.uint8)
 
+        writer.write(cv2.cvtColor(frame,cv2.COLOR_RGB2BGR))
     writer.release()
     return tmp.name
 
 
-# ── MAIN ──────────────────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════
+#  MAIN PIPELINE
+# ══════════════════════════════════════════════════════
 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!"
 
-    pil_image = image if isinstance(image, Image.Image) else Image.fromarray(image)
-    prompt    = prompt_text.strip() if prompt_text.strip() else "cinematic product advertisement, smooth motion"
-
-    status_lines = []
+    pil    = image if isinstance(image, Image.Image) else Image.fromarray(image)
+    prompt = prompt_text.strip() or "cinematic product advertisement, smooth dynamic motion, dramatic lighting"
+    lines  = []
 
     def log(msg):
-        status_lines.append(msg)
-        progress(0.2 + len(status_lines) * 0.10, desc=msg)
+        lines.append(msg)
+        progress(min(0.1+len(lines)*0.12,0.85), desc=msg)
 
-    progress(0.1, desc="🎬 Starting video generation...")
-
-    video_path, model_used = generate_video_with_fallback(
-        pil_image,
-        prompt=prompt,
-        style=style,
-        progress_callback=log,
-    )
+    progress(0.05, desc="🚀 Starting AI video generation...")
+    video_path, model_used = generate_video_with_fallback(pil, prompt, style, cb=log)
 
-    # If ken burns was used, regenerate with user options
     if "Ken Burns" in model_used:
-        progress(0.7, desc="🎨 Rendering cinematic video...")
+        progress(0.80, desc="🎨 Rendering cinematic fallback...")
         video_path = generate_video_ken_burns(
-            pil_image,
-            style    = style.lower(),
-            add_grain= add_grain,
-            add_leak = add_leak,
-            add_bars = add_bars,
+            pil, 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
+    return video_path, "\n".join(lines) + f"\n\n✅ Model used: {model_used}"
 
 
-# ── UI ────────────────────────────────────────────────────────────────────────
+# ══════════════════════════════════════════════════════
+#  UI
+# ══════════════════════════════════════════════════════
 css = """
-#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; }
+#title{text-align:center;font-size:2.3rem;font-weight:900;margin-bottom:.2rem}
+#sub  {text-align:center;color:#888;margin-bottom:1.5rem}
+.chain{font-size:.85rem;line-height:1.9}
 """
 
 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 1080p video** ready in seconds!", elem_id="sub")
+    gr.Markdown("Image + prompt → **real AI video** (fal.ai → HF → Ken Burns fallback)", 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 — for AI models)",
-                placeholder="e.g. cinematic slow zoom, product floating in air ...",
-                lines=2,
-            )
-            style_dd = gr.Dropdown(
-                choices=["Premium", "Energetic", "Fun"],
-                value="Premium", label="🎨 Color Grade Style",
+            img_in  = gr.Image(label="📸 Upload Image", type="pil", height=300)
+            prm_in  = gr.Textbox(
+                label="✏️ Prompt",
+                value="cinematic product shot, smooth motion, dramatic lighting, professional ad",
+                lines=3,
             )
-
+            sty_dd  = gr.Dropdown(["Premium","Energetic","Fun"], value="Premium", label="🎨 Style")
             with gr.Row():
-                grain_cb = gr.Checkbox(label="🎞 Film Grain",    value=True)
-                leak_cb  = gr.Checkbox(label="✨ Light Leak",    value=True)
+                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")
+            gen_btn = gr.Button("🚀 Generate AI Video", variant="primary", size="lg")
 
             gr.Markdown(
-                "**🔗 Fallback Chain:**\n"
-                "1. Lightricks/LTX-2 ⚡\n"
-                "2. Wan 2.2 I2V-A14B\n"
-                "3. Stable Video Diffusion XT\n"
-                "4. KlingTeam/LivePortrait\n"
-                "5. Lightricks/LTX-Video\n"
-                "6. 🎨 Ken Burns **1080p** (always works ✅)"
+                "**🔗 AI Chain (best → fallback):**\n\n"
+                "1. 🤖 **fal.ai LTX-Video** — fastest real AI (~20s)\n"
+                "2. 🤖 **fal.ai Wan 2.1** — high quality (~40s)\n"
+                "3. 🤖 **fal.ai Kling v1.6** — cinematic (~60s)\n"
+                "4. 🤖 **HF LTX-2** — free fallback\n"
+                "5. 🎨 **Ken Burns** — always works ✅\n\n"
+                "💡 Add `FAL_KEY` secret for real AI generation!",
+                elem_classes="chain",
             )
 
-        # ── RIGHT ────────────────────────────────────────────────────────────
         with gr.Column(scale=1):
-            video_out  = gr.Video(label="🎥 Generated Video (1080×1920)", height=500)
-            status_out = gr.Textbox(label="📊 Model Log", lines=8, interactive=False)
+            vid_out = gr.Video(label="🎥 AI Generated Video", height=500)
+            log_out = gr.Textbox(label="📊 Generation Log", lines=7, interactive=False)
 
     gen_btn.click(
         fn=generate_ad,
-        inputs=[image_input, prompt_input, style_dd, grain_cb, leak_cb, bars_cb],
-        outputs=[video_out, status_out],
+        inputs=[img_in, prm_in, sty_dd, grain_cb, leak_cb, bars_cb],
+        outputs=[vid_out, log_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"
+        "**Get fal.ai key free:** [fal.ai/dashboard](https://fal.ai/dashboard) → API Keys → add as `FAL_KEY` secret in HF Space"
     )
 
 if __name__ == "__main__":