Update app.py

app.py

@@ -1,12 +1,10 @@
-import os, tempfile, io, math, time, threading, base64, requests, textwrap
+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, ImageDraw, ImageFont
 
-# ══════════════════════════════════════════════════════════════════
-#  TOKENS
-# ══════════════════════════════════════════════════════════════════
+# ── 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()
 
@@ -17,49 +15,37 @@ if HF_TOKEN:
         login(token=HF_TOKEN); hf_client = InferenceClient(token=HF_TOKEN)
         print("✅ HF ready")
     except Exception as e: print(f"⚠️ HF: {e}")
-
 if FAL_KEY: os.environ["FAL_KEY"] = FAL_KEY; print("✅ fal.ai ready")
-print("✅ App ready!")
 
-# ══════════════════════════════════════════════════════════════════
-#  HELPERS
-# ══════════════════════════════════════════════════════════════════
-def pil_to_bytes(img, quality=92):
-    buf = io.BytesIO(); img.save(buf, format="JPEG", quality=quality); return buf.getvalue()
+# ── HELPERS ───────────────────────────────────────────────────────
+def pil_to_bytes(img, q=92):
+    b=io.BytesIO(); img.save(b,format="JPEG",quality=q); return b.getvalue()
 
-def save_video_bytes(data):
-    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-    tmp.write(data); tmp.flush(); return tmp.name
+def save_bytes(data):
+    t=tempfile.NamedTemporaryFile(suffix=".mp4",delete=False)
+    t.write(data); t.flush(); return t.name
 
-def run_with_timeout(fn, timeout, *args, **kwargs):
+def run_timeout(fn, sec, *a, **kw):
     box=[None]; err=[None]
-    def _r():
-        try: box[0]=fn(*args,**kwargs)
+    def r():
+        try: box[0]=fn(*a,**kw)
         except Exception as e: err[0]=str(e)
-    t=threading.Thread(target=_r,daemon=True); t.start(); t.join(timeout=timeout)
-    if t.is_alive(): print(f"  ⏱ timeout {timeout}s"); return None
-    if err[0]: print(f"  ❌ {err[0][:100]}")
+    t=threading.Thread(target=r,daemon=True); t.start(); t.join(timeout=sec)
+    if t.is_alive(): print(f"  ⏱ timeout {sec}s"); return None
+    if err[0]: print(f"  ❌ {err[0][:80]}")
     return box[0]
 
-def ease_in_out(t):
+def ease(t):
     t=max(0.,min(1.,t)); return t*t*(3-2*t)
 
-def ease_in_out_cubic(t):
+def ease_cubic(t):
     t=max(0.,min(1.,t)); return 4*t*t*t if t<.5 else 1-math.pow(-2*t+2,3)/2
 
-def ease_out_expo(t):
+def ease_expo(t):
     return 1-math.pow(2,-10*t) if t<1 else 1.
 
-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
-    else: t-=2.625/2.75; return 7.5625*t*t+0.984375
-
-# ══════════════════════════════════════════════════════════════════
-#  FAL.AI + HF CHAIN
-# ══════════════════════════════════════════════════════════════════
-def try_fal_ltx(pil_image, prompt):
+# ── FAL + HF CHAIN ────────────────────────────────────────────────
+def try_fal(pil_image, prompt):
     if not FAL_KEY: return None
     try:
         import fal_client
@@ -73,566 +59,396 @@ def try_fal_ltx(pil_image, prompt):
         if vurl:
             resp = requests.get(vurl, timeout=60)
             if resp.status_code==200: return resp.content
-    except Exception as e: print(f"  ❌ fal LTX: {e}")
+    except Exception as e: print(f"  ❌ fal: {e}")
     return None
 
-def try_hf_ltx(pil_image, prompt):
+def try_hf(pil_image, prompt):
     if not hf_client: return None
     try:
-        r = hf_client.image_to_video(image=pil_to_bytes(pil_image), model="Lightricks/LTX-2", prompt=prompt)
+        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: {e}")
+    except Exception as e: print(f"  ❌ HF: {e}")
     return None
 
-CHAIN = [
-    ("🤖 fal.ai LTX-Video",  try_fal_ltx,  90),
-    ("🤖 HF LTX-2",          try_hf_ltx,   60),
-    ("🎬 Cinematic Engine",   None,          0),
-]
-
-def get_ai_video(pil_image, prompt, style, cb=None):
-    for name, fn, timeout in CHAIN:
+def get_ai_video(pil, prompt, cb=None):
+    for name, fn, sec in [
+        ("🤖 fal.ai LTX", try_fal, 90),
+        ("🤖 HF LTX-2",   try_hf,  60),
+    ]:
         if cb: cb(f"⏳ {name}...")
-        if fn is None: return None, name
-        result = run_with_timeout(fn, timeout, pil_image, prompt)
-        if result: return save_video_bytes(result), name
-    return None, "🎬 Cinematic Engine"
+        r = run_timeout(fn, sec, pil, prompt)
+        if r: return save_bytes(r), name
+    return None, "local"
 
 
 # ══════════════════════════════════════════════════════════════════
-#  ✨ CINEMATIC ENGINE — 3D Parallax + Bokeh + Captions + Audio
+#  CINEMATIC ENGINE  — image ALWAYS visible
 # ══════════════════════════════════════════════════════════════════
 
-# ── Color Grading ─────────────────────────────────────────────────
-def color_grade(frame, style):
-    f = frame.astype(np.float32)/255.
-    # Gentle S-curve — lift mids slightly, don't crush blacks
-    f = np.clip(f + 0.08*f*(1-f)*(2*f-1)*(-1), 0, 1)
-    if style=="premium":
-        lum=0.299*f[:,:,0]+0.587*f[:,:,1]+0.114*f[:,:,2]
-        sh=np.clip(1.-lum*2.5,0,1)[:,:,None]
-        hi=np.clip((lum-.6)*2.5,0,1)[:,:,None]
-        f[:,:,0]+=(-0.02*sh[:,:,0]+0.03*hi[:,:,0])
-        f[:,:,1]+=(0.01*sh[:,:,0]+0.01*hi[:,:,0])
-        f[:,:,2]+=(0.03*sh[:,:,0]-0.02*hi[:,:,0])
-        f=np.clip(f*1.03, 0, 1)
-    elif style=="energetic":
-        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-.02,0,1)
-        f[:,:,0]=np.clip(f[:,:,0]*1.06,0,1)
-    elif style=="fun":
-        f[:,:,0]=np.clip(f[:,:,0]*1.1,0,1)
-        f[:,:,1]=np.clip(f[:,:,1]*1.06,0,1)
-        f[:,:,2]=np.clip(f[:,:,2]*.95,0,1)
-        f=np.clip(f*1.05+.02,0,1)
-    return np.clip(f*255,0,255).astype(np.uint8)
-
-# ── Vignette ──────────────────────────────────────────────────────
-def vignette(frame, strength=0.40):
-    h,w=frame.shape[:2]; Y,X=np.ogrid[:h,:w]
-    dist=np.sqrt(((X-w/2)/(w/2*.90))**2+((Y-h/2)/(h/2))**2)
-    mask=np.clip(1.-strength*dist**1.8,0,1)
-    return np.clip(frame.astype(np.float32)*mask[:,:,None],0,255).astype(np.uint8)
-
-# ── 3D Perspective Warp ────────────────────────────────────────────
-def warp_3d(frame, angle_deg, axis="y"):
-    """Simulate 3D rotation using perspective transform."""
-    h,w=frame.shape[:2]
-    angle=math.radians(angle_deg)
-    cos_a=math.cos(angle); skew=math.sin(angle)*0.35
-
-    if axis=="y":   # rotate around Y (left-right tilt)
-        src=np.float32([[0,0],[w,0],[w,h],[0,h]])
-        oy=h*0.02*math.sin(angle)
-        shrink=1.-abs(skew)*0.15
-        cx=w*(1.-shrink)/2
-        dst=np.float32([
-            [cx+w*skew*0.3,  oy],
-            [w-cx+w*skew*0.3, oy],
-            [w-cx-w*skew*0.3, h-oy],
-            [cx-w*skew*0.3,   h-oy],
-        ])
-    else:           # rotate around X (up-down tilt)
-        src=np.float32([[0,0],[w,0],[w,h],[0,h]])
-        ox=w*0.02*math.sin(angle)
-        shrink=1.-abs(skew)*0.15
-        cy=h*(1.-shrink)/2
-        dst=np.float32([
-            [ox,  cy+h*skew*0.3],
-            [w-ox, cy-h*skew*0.3],
-            [w-ox, h-cy-h*skew*0.3],
-            [ox,   h-cy+h*skew*0.3],
-        ])
-
-    M=cv2.getPerspectiveTransform(src,dst)
-    return cv2.warpPerspective(frame,M,(w,h),flags=cv2.INTER_LINEAR,
-                                borderMode=cv2.BORDER_REFLECT)
-
-# ── Bokeh Particles ───────────────────────────────────────────────
-class BokehSystem:
-    def __init__(self, W, H, n=28, style="premium"):
-        self.W,self.H=W,H
-        colors={"premium":[(255,220,120),(200,180,255),(255,255,200)],
-                "energetic":[(255,80,80),(80,180,255),(255,200,0)],
-                "fun":[(255,150,200),(150,255,200),(200,150,255)]}
-        c=colors.get(style,colors["premium"])
-        self.particles=[{
-            "x": np.random.uniform(0,W),
-            "y": np.random.uniform(0,H),
-            "r": np.random.uniform(4,18),
-            "alpha": np.random.uniform(0.08,0.35),
-            "vx": np.random.uniform(-0.3,0.3),
-            "vy": np.random.uniform(-0.6,-0.1),
-            "color": c[np.random.randint(len(c))],
-            "phase": np.random.uniform(0,math.pi*2),
-        } for _ in range(n)]
-
-    def draw(self, frame, t):
-        overlay=frame.astype(np.float32)
-        for p in self.particles:
-            px=int(p["x"]+p["vx"]*t*60+math.sin(t*2+p["phase"])*8)%self.W
-            py=int((p["y"]+p["vy"]*t*60)%self.H)
-            pulse=0.7+0.3*math.sin(t*3+p["phase"])
-            r=max(2,int(p["r"]*pulse)); a=p["alpha"]*pulse
-            # Draw soft glowing circle
-            tmp=np.zeros_like(overlay)
-            cv2.circle(tmp,(px,py),r,p["color"],-1)
-            cv2.circle(tmp,(px,py),r//2,
-                       tuple(min(255,int(c*1.3)) for c in p["color"]),-1)
-            overlay=overlay*(1-a)+tmp.astype(np.float32)*a
-        return np.clip(overlay,0,255).astype(np.uint8)
-
-# ── Animated Text Captions ─────────────────────────────────────────
+def prep_image(pil, W, H):
+    """Resize with smart crop — NO quality loss, NO black bars."""
+    img = pil.convert("RGB")
+    sw, sh = img.size
+    # Crop to target ratio
+    tr = W/H
+    if sw/sh > tr:
+        nw = int(sh*tr); img = img.crop(((sw-nw)//2, 0, (sw-nw)//2+nw, sh))
+    else:
+        nh = int(sw/tr); img = img.crop((0, (sh-nh)//2, sw, (sh-nh)//2+nh))
+    img = img.resize((W, H), Image.LANCZOS)
+    # Gentle sharpening only
+    img = img.filter(ImageFilter.UnsharpMask(radius=0.8, percent=110, threshold=3))
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Color(img).enhance(1.08)
+    return np.array(img)
+
+
+def grade(frame, style):
+    """Subtle color grade — won't darken image."""
+    f = frame.astype(np.float32) / 255.0
+    if style == "premium":
+        # Slight warm highlights, cool shadows — VERY subtle
+        f[:,:,0] = np.clip(f[:,:,0] * 1.03 + 0.01, 0, 1)
+        f[:,:,2] = np.clip(f[:,:,2] * 1.02, 0, 1)
+    elif style == "energetic":
+        # Slight saturation boost
+        gray = 0.299*f[:,:,0:1] + 0.587*f[:,:,1:2] + 0.114*f[:,:,2:3]
+        f = np.clip(gray + 1.25*(f-gray), 0, 1)
+        f = np.clip(f * 1.05, 0, 1)
+    elif style == "fun":
+        f[:,:,0] = np.clip(f[:,:,0] * 1.06, 0, 1)
+        f[:,:,1] = np.clip(f[:,:,1] * 1.03, 0, 1)
+    return np.clip(f*255, 0, 255).astype(np.uint8)
+
+
+def soft_vignette(frame):
+    """Very subtle vignette — only darkens extreme edges."""
+    h, w = frame.shape[:2]
+    Y, X = np.ogrid[:h, :w]
+    dist = np.sqrt(((X-w/2)/(w/2))**2 + ((Y-h/2)/(h/2))**2)
+    # Only kicks in after 0.85 from center — very gentle
+    mask = np.clip(1.0 - 0.30 * np.maximum(dist - 0.85, 0)**2, 0, 1)
+    return np.clip(frame.astype(np.float32)*mask[:,:,None], 0, 255).astype(np.uint8)
+
+
+class Bokeh:
+    def __init__(self, W, H, style):
+        self.W, self.H = W, H
+        cols = {"premium":[(255,220,100),(180,160,255)],
+                "energetic":[(80,180,255),(255,80,80)],
+                "fun":[(255,150,200),(150,255,180)]}
+        c = cols.get(style, cols["premium"])
+        self.p = [{
+            "x": np.random.uniform(0,W), "y": np.random.uniform(0,H),
+            "r": np.random.uniform(5,20),
+            "a": np.random.uniform(0.06, 0.20),   # very transparent
+            "vx": np.random.uniform(-0.2,0.2),
+            "vy": np.random.uniform(-0.5,-0.05),
+            "col": c[np.random.randint(len(c))],
+            "ph": np.random.uniform(0, math.pi*2),
+        } for _ in range(18)]
+
+    def draw(self, frame, t_sec):
+        ov = frame.astype(np.float32)
+        for p in self.p:
+            px = int(p["x"] + p["vx"]*t_sec*50 + math.sin(t_sec*1.5+p["ph"])*6) % self.W
+            py = int((p["y"] + p["vy"]*t_sec*50) % self.H)
+            r  = max(3, int(p["r"] * (0.8+0.2*math.sin(t_sec*2+p["ph"]))))
+            a  = p["a"] * (0.7+0.3*math.sin(t_sec*2+p["ph"]))
+            tmp = np.zeros_like(ov)
+            cv2.circle(tmp, (px,py), r, p["col"], -1)
+            # soft glow: blur the circle
+            tmp_blurred = cv2.GaussianBlur(tmp, (r|1, r|1), r/2)
+            ov = ov*(1-a) + tmp_blurred.astype(np.float32)*a
+        return np.clip(ov, 0, 255).astype(np.uint8)
+
+
 def get_font(size):
-    paths=["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-           "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
-           "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf",
-           "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf"]
-    for p in paths:
+    for p in ["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+              "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+              "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf"]:
         if os.path.exists(p):
-            try: return ImageFont.truetype(p,size)
+            try: return ImageFont.truetype(p, size)
             except: pass
     return ImageFont.load_default()
 
-def draw_caption(frame_pil, text, t, W, H, style, phase="in"):
-    """Slide-in animated caption with gradient background."""
-    if not text.strip(): return frame_pil
-    draw=ImageDraw.Draw(frame_pil)
 
-    font_main=get_font(max(28, W//22))
-    font_sub =get_font(max(18, W//32))
+def draw_caption(frame_np, text, anim_t, W, H, style):
+    """Animated caption — slide up from bottom."""
+    if not text.strip(): return frame_np
+    pil = Image.fromarray(frame_np).convert("RGBA")
+    overlay = Image.new("RGBA", pil.size, (0,0,0,0))
+    draw = ImageDraw.Draw(overlay)
 
+    font = get_font(max(30, W//20))
     # Word wrap
-    words=text.split(); lines=[]; line=""
+    words = text.split(); lines = []; line = ""
     for w in words:
-        test=line+" "+w if line else w
-        bbox=font_main.getbbox(test)
-        if bbox[2]>W*0.85 and line:
-            lines.append(line); line=w
-        else: line=test
+        test = (line+" "+w).strip()
+        try: bbox = font.getbbox(test)
+        except: bbox = (0,0,len(test)*18,30)
+        if bbox[2] > W*0.82 and line:
+            lines.append(line); line = w
+        else: line = test
     if line: lines.append(line)
 
-    line_h=font_main.getbbox("Ag")[3]+10
-    total_h=len(lines)*line_h+20
-    base_y=H-total_h-70
-
-    # Eased slide-in
-    if phase=="in":
-        slide=ease_out_bounce(min(t/0.5,1.0))
-        alpha_t=min(t/0.3,1.0)
-    elif phase=="out":
-        slide=ease_in_out(1.-min(t/0.4,1.))
-        alpha_t=1.-min(t/0.4,1.)
-    else:
-        slide=1.; alpha_t=1.
-
-    offset_y=int((1.-slide)*60)
+    lh = max(36, W//18)
+    total_h = len(lines)*lh + 24
+    base_y = H - total_h - 80
 
-    colors={"premium":(255,220,80),"energetic":(80,200,255),"fun":(255,120,200)}
-    txt_color=colors.get(style,(255,255,255))
+    # Slide up animation
+    slide = ease_expo(min(anim_t/0.5, 1.0))
+    offset = int((1-slide)*50)
+    alpha = int(min(anim_t/0.4, 1.0) * 255)
 
-    for li,ln in enumerate(lines):
-        bbox=font_main.getbbox(ln); tw=bbox[2]-bbox[0]
-        tx=(W-tw)//2; ty=base_y+li*line_h+offset_y
+    txt_colors = {"premium":(255,210,60),"energetic":(60,200,255),"fun":(255,100,180)}
+    txt_col = txt_colors.get(style, (255,255,255))
 
-        # Dark pill background
-        pad=12
-        rx1,ry1=tx-pad,ty-6; rx2,ry2=tx+tw+pad,ty+line_h+2
-        # Draw semi-transparent rounded rect via overlay
-        overlay=Image.new("RGBA",frame_pil.size,(0,0,0,0))
-        od=ImageDraw.Draw(overlay)
-        od.rounded_rectangle([rx1,ry1,rx2,ry2],radius=10,
-                              fill=(0,0,0,int(160*alpha_t)))
-        frame_pil=Image.alpha_composite(frame_pil.convert("RGBA"),overlay).convert("RGB")
-        draw=ImageDraw.Draw(frame_pil)
+    for i, ln in enumerate(lines):
+        try: bbox = font.getbbox(ln); tw = bbox[2]-bbox[0]
+        except: tw = len(ln)*18
+        tx = (W-tw)//2; ty = base_y + i*lh + offset
 
+        # Background pill
+        pad = 14
+        draw.rounded_rectangle([tx-pad, ty-6, tx+tw+pad, ty+lh+4],
+                                radius=12, fill=(0,0,0,min(170,alpha)))
         # Shadow
-        draw.text((tx+2,ty+2),ln,font=font_main,fill=(0,0,0,int(200*alpha_t)))
-        # Main text
-        r,g,b=txt_color
-        draw.text((tx,ty),ln,font=font_main,
-                  fill=(r,g,b,int(255*alpha_t)) if alpha_t<1 else txt_color)
-
-    return frame_pil
-
-# ── Light Leak ────────────────────────────────────────────────────
-def light_leak(frame, t, style):
-    if not (0.25<t<0.70): return frame
-    peak=math.sin((t-0.25)/(0.45)*math.pi)
-    h,w=frame.shape[:2]; Y,X=np.ogrid[:h,:w]
-    pos=0.25+((t-0.25)/0.45)*0.65
-    mask=np.exp(-(((X/w+(h-Y)/h)/2.-pos)**2)/(2*.22**2))
-    c={"premium":[255,220,140],"energetic":[120,180,255],"fun":[255,160,220]}
-    col=np.array(c.get(style,[255,220,140]),dtype=np.float32)
-    return np.clip(frame.astype(np.float32)+(mask[:,:,None]*col*peak*0.22),0,255).astype(np.uint8)
-
-# ── Generate TTS Audio ─────────────────────────────────────────────
-def make_audio(text, duration_sec, out_path):
-    """gTTS voiceover if available, else silent track."""
-    try:
-        from gtts import gTTS
-        tts=gTTS(text=text[:200], lang="en", slow=False)
-        tts_path=out_path.replace(".wav","_tts.mp3")
-        tts.save(tts_path)
-        # Pad/trim to duration using ffmpeg
-        os.system(
-            f'ffmpeg -y -i "{tts_path}" '
-            f'-af "apad=pad_dur={duration_sec}" '
-            f'-t {duration_sec} "{out_path}" -loglevel error'
-        )
-        os.remove(tts_path)
-        return os.path.exists(out_path)
-    except Exception as e:
-        print(f"  ⚠️ TTS: {e}")
-        return False
-
-def make_bgm(duration_sec, out_path, style="premium", bpm=95):
-    """Generate simple lo-fi beat with numpy."""
-    sr=44100; n=int(sr*duration_sec)
-    t_arr=np.linspace(0,duration_sec,n,endpoint=False)
-
-    # Base beat params per style
-    params={
-        "premium":   dict(kick_bpm=bpm, bass_freq=55,  melody_freqs=[261,311,370],  gain=0.18),
-        "energetic": dict(kick_bpm=bpm*2, bass_freq=80, melody_freqs=[330,392,494],  gain=0.22),
-        "fun":       dict(kick_bpm=bpm,  bass_freq=65,  melody_freqs=[392,494,587],  gain=0.20),
-    }
-    p=params.get(style,params["premium"])
-
-    # Kick drum (thump)
-    beat_sec=60./p["kick_bpm"]
-    kick=np.zeros(n,dtype=np.float32)
-    for i in range(int(duration_sec/beat_sec)+1):
-        s=int(i*beat_sec*sr)
-        if s>=n: break
-        env=np.exp(-15*np.arange(min(int(sr*.12),n-s))/sr)
-        freq_sweep=p["bass_freq"]*np.exp(-30*np.arange(min(int(sr*.12),n-s))/sr)
-        kick[s:s+len(env)]+=env*np.sin(2*math.pi*freq_sweep*np.arange(len(env))/sr)*0.7
-
-    # Bass line
-    bass=np.sin(2*math.pi*p["bass_freq"]*t_arr)*0.15
-    bass*=0.5+0.5*np.sin(2*math.pi*(p["kick_bpm"]/60/2)*t_arr)
-
-    # Melody arp
-    melody=np.zeros(n,dtype=np.float32)
-    arp_speed=2.0
-    for j,freq in enumerate(p["melody_freqs"]):
-        phase_off=j*0.33
-        env=np.clip(0.5+0.5*np.sin(2*math.pi*arp_speed*t_arr-phase_off*math.pi*2),0,1)
-        melody+=np.sin(2*math.pi*freq*t_arr)*env*0.06
-
-    # Hi-hat (noise burst on 8ths)
-    hat_sec=beat_sec/2
-    hat=np.zeros(n,dtype=np.float32)
-    for i in range(int(duration_sec/hat_sec)+1):
-        s=int(i*hat_sec*sr)
-        if s>=n: break
-        l=min(int(sr*.04),n-s)
-        env=np.exp(-60*np.arange(l)/sr)
-        hat[s:s+l]+=np.random.randn(l)*env*0.08
-
-    # Mix
-    mix=(kick+bass+melody+hat)*p["gain"]
-    # Fade in/out
-    fade=int(sr*.5)
-    mix[:fade]*=np.linspace(0,1,fade)
-    mix[-fade:]*=np.linspace(1,0,fade)
-    mix=np.clip(mix,-1,1)
-
-    # Save as WAV
-    import wave, struct
-    samples=(mix*32767).astype(np.int16)
+        draw.text((tx+2, ty+2), ln, font=font, fill=(0,0,0,min(200,alpha)))
+        # Text
+        r,g,b = txt_col
+        draw.text((tx, ty), ln, font=font, fill=(r,g,b,alpha))
+
+    combined = Image.alpha_composite(pil, overlay)
+    return np.array(combined.convert("RGB"))
+
+
+def make_bgm(duration_sec, out_path, style="premium"):
+    import wave
+    sr = 44100; n = int(sr*duration_sec)
+    t  = np.linspace(0, duration_sec, n, endpoint=False)
+    bpm = {"premium":90, "energetic":128, "fun":105}.get(style, 90)
+    beat = 60./bpm
+
+    # Kick
+    kick = np.zeros(n, np.float32)
+    for i in range(int(duration_sec/beat)+2):
+        s = int(i*beat*sr)
+        if s >= n: break
+        l = min(int(sr*.10), n-s)
+        env = np.exp(-20*np.arange(l)/sr)
+        kick[s:s+l] += env * np.sin(2*math.pi*55*np.exp(-30*np.arange(l)/sr)*np.arange(l)/sr) * 0.6
+
+    # Bassline
+    bass_f = {"premium":55,"energetic":80,"fun":65}.get(style,55)
+    bass = np.sin(2*math.pi*bass_f*t)*0.12*(0.5+0.5*np.sin(2*math.pi*(bpm/60/4)*t))
+
+    # Melody
+    mel_freqs = {"premium":[261,329,392],"energetic":[330,415,494],"fun":[392,494,587]}.get(style,[261,329,392])
+    mel = np.zeros(n, np.float32)
+    for j,f in enumerate(mel_freqs):
+        env = np.clip(0.5+0.5*np.sin(2*math.pi*1.5*t - j*2.1), 0, 1)
+        mel += np.sin(2*math.pi*f*t)*env*0.05
+
+    # Hi-hat
+    hat = np.zeros(n, np.float32)
+    hs  = beat/2
+    for i in range(int(duration_sec/hs)+2):
+        s = int(i*hs*sr)
+        if s >= n: break
+        l = min(int(sr*.03), n-s)
+        hat[s:s+l] += np.random.randn(l)*np.exp(-80*np.arange(l)/sr)*0.07
+
+    mix = np.clip((kick+bass+mel+hat)*0.20, -1, 1)
+    fade = int(sr*.4)
+    mix[:fade] *= np.linspace(0,1,fade)
+    mix[-fade:] *= np.linspace(1,0,fade)
+
     with wave.open(out_path,"w") as wf:
         wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(sr)
-        wf.writeframes(samples.tobytes())
+        wf.writeframes((mix*32767).astype(np.int16).tobytes())
     return True
 
-def merge_audio_video(video_path, audio_path, out_path):
-    """Use ffmpeg to mux audio + video."""
-    ret=os.system(
-        f'ffmpeg -y -i "{video_path}" -i "{audio_path}" '
-        f'-c:v copy -c:a aac -b:a 128k '
-        f'-shortest "{out_path}" -loglevel error'
-    )
-    return os.path.exists(out_path)
-
-
-# ── MAIN CINEMATIC RENDERER ───────────────────────────────────────
-def render_cinematic(
-    pil_image,
-    caption_text = "Premium Quality",
-    style        = "premium",
-    duration_sec = 7,
-    fps          = 30,
-    add_audio    = True,
-    add_caption  = True,
-    add_3d       = True,
-    add_bokeh    = True,
-    add_bars     = True,
-):
-    TW,TH=720,1280; pad=200; BW,BH=TW+pad*2,TH+pad*2
-    total=duration_sec*fps
-
-    # Prepare base image
-    img=pil_image.convert("RGB"); sw,sh=img.size
-    if sw/sh>TW/TH:
-        nw=int(sh*TW/TH); img=img.crop(((sw-nw)//2,0,(sw-nw)//2+nw,sh))
-    else:
-        nh=int(sw*TH/TW); img=img.crop((0,(sh-nh)//2,sw,(sh-nh)//2+nh))
-    img=img.filter(ImageFilter.UnsharpMask(radius=1.2,percent=130,threshold=2))
-    img=ImageEnhance.Contrast(img).enhance(1.08)
-    img=ImageEnhance.Color(img).enhance(1.15)
-    base=np.array(img.resize((BW,BH),Image.LANCZOS))
-
-    # Pre-build vignette — gentle, not crushing blacks
-    Y,X=np.ogrid[:TH,:TW]
-    vmask=np.clip(1.-0.40*(np.sqrt(((X-TW/2)/(TW/2*.90))**2+((Y-TH/2)/(TH/2))**2)**1.8),0,1).astype(np.float32)
-
-    # Bokeh system
-    bokeh=BokehSystem(TW,TH,n=22,style=style) if add_bokeh else None
-
-    # Caption segments  [start_t, end_t, text, phase_in_dur, phase_out_dur]
-    words=caption_text.strip().split()
-    mid=len(words)//2
-    cap_lines=[" ".join(words[:mid]) or caption_text, " ".join(words[mid:]) or ""]
-    cap_segs=[
-        (0.8,  3.2,  cap_lines[0]),
-        (3.5,  6.5,  cap_lines[1] if cap_lines[1] else cap_lines[0]),
-    ]
 
-    # Motion keyframes
-    SEG=[
-        (0.00,0.20, 1.40,1.18, 0,       int(-pad*.06), 0,          int(-pad*.08)),
-        (0.20,0.50, 1.18,1.10, int(-pad*.04),int(pad*.05), int(-pad*.08),int(-pad*.25)),
-        (0.50,0.75, 1.10,1.05, int(pad*.05), int(pad*.14), int(-pad*.25),int(-pad*.14)),
-        (0.75,1.00, 1.05,1.00, int(pad*.14), 0,            int(-pad*.14),0),
+def add_audio_to_video(video_path, style, duration_sec, caption):
+    bgm  = video_path.replace(".mp4","_bgm.wav")
+    final= video_path.replace(".mp4","_final.mp4")
+    make_bgm(duration_sec, bgm, style)
+
+    # Try TTS
+    tts_ok = False
+    tts = video_path.replace(".mp4","_tts.mp3")
+    try:
+        from gtts import gTTS
+        gTTS(text=caption[:180], lang="en", slow=False).save(tts)
+        # Mix tts(loud) + bgm(soft)
+        mixed = video_path.replace(".mp4","_mix.wav")
+        os.system(f'ffmpeg -y -i "{bgm}" -i "{tts}" '
+                  f'-filter_complex "[0]volume=0.22[a];[1]volume=1.0[b];[a][b]amix=inputs=2:duration=first" '
+                  f'-t {duration_sec} "{mixed}" -loglevel error')
+        if os.path.exists(mixed): bgm = mixed; tts_ok = True
+    except: pass
+
+    os.system(f'ffmpeg -y -i "{video_path}" -i "{bgm}" '
+              f'-c:v copy -c:a aac -b:a 128k -shortest "{final}" -loglevel error')
+    return final if os.path.exists(final) else video_path
+
+
+# ── MAIN RENDER ───────────────────────────────────────────────────
+def render(pil, caption="Step into style.", style="premium",
+           duration_sec=7, fps=30, add_audio=True, add_caption=True, add_bokeh=True):
+
+    TW, TH = 720, 1280
+    PAD    = 160                        # extra canvas for zoom
+    BW, BH = TW+PAD*2, TH+PAD*2
+
+    base   = prep_image(pil, BW, BH)   # large canvas — FULL COLOR image
+    total  = duration_sec * fps
+
+    bokeh  = Bokeh(TW, TH, style) if add_bokeh else None
+
+    # Motion: gentle zoom + pan — no 3D, no warp
+    SEGS = [
+        (0.00, 0.22,  1.30, 1.12,  0,           -int(PAD*.07),  0,           -int(PAD*.08)),
+        (0.22, 0.52,  1.12, 1.07, -int(PAD*.04),  int(PAD*.06), -int(PAD*.08),-int(PAD*.22)),
+        (0.52, 0.78,  1.07, 1.03,  int(PAD*.06),  int(PAD*.13), -int(PAD*.22),-int(PAD*.12)),
+        (0.78, 1.00,  1.03, 1.00,  int(PAD*.13),  0,            -int(PAD*.12), 0),
     ]
 
-    # 3D rotation path: gentle Y-rotation sweep + slight X tilt
-    def get_3d_angles(tg):
-        if not add_3d: return 0,0
-        ry = math.sin(tg*math.pi*1.5)*6.0          # ±6° Y rotation
-        rx = math.sin(tg*math.pi+0.5)*2.5           # ±2.5° X tilt
-        return ry, rx
+    tmp    = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    writer = cv2.VideoWriter(tmp.name, cv2.VideoWriter_fourcc(*"mp4v"), fps, (TW,TH))
 
-    tmp_video=tempfile.NamedTemporaryFile(suffix=".mp4",delete=False)
-    writer=cv2.VideoWriter(tmp_video.name,cv2.VideoWriter_fourcc(*"mp4v"),fps,(TW,TH))
+    # Caption segments
+    cap_words = caption.strip().split()
+    mid = max(1, len(cap_words)//2)
+    cap_segs = [
+        (1.0, 3.5,  " ".join(cap_words[:mid])),
+        (3.8, 6.5,  " ".join(cap_words[mid:]) or " ".join(cap_words)),
+    ]
 
     for i in range(total):
-        tg=i/(total-1)
-
-        # Motion
-        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)
+        tg = i / max(total-1, 1)
+
+        # Get motion params
+        zoom = pan_x = pan_y = None
+        for (t0,t1,z0,z1,px0,px1,py0,py1) in SEGS:
+            if t0 <= tg <= t1:
+                te = ease_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
-
-        # Micro shake (first 20%)
-        if tg<0.20:
-            s=(0.20-tg)/0.20*2.0
-            pan_x+=int(s*math.sin(i*1.4)); pan_y+=int(s*math.cos(i*1.0))
-
-        # Crop
-        cw,ch=int(TW/zoom),int(TH/zoom)
-        ox,oy=BW//2+pan_x,BH//2+pan_y
-        x1,y1=max(0,ox-cw//2),max(0,oy-ch//2)
-        x2,y2=min(BW,x1+cw),min(BH,y1+ch)
-        if (x2-x1)<10 or (y2-y1)<10: x1,y1,x2,y2=0,0,TW,TH
+        if zoom is None: zoom,pan_x,pan_y = 1.0,0,0
 
-        frame=cv2.resize(base[y1:y2,x1:x2],(TW,TH),interpolation=cv2.INTER_LINEAR)
+        # Micro camera shake (first 15%)
+        if tg < 0.15:
+            s = (0.15-tg)/0.15 * 1.8
+            pan_x += int(s*math.sin(i*1.5))
+            pan_y += int(s*math.cos(i*1.1))
 
-        # 3D perspective warp — gentle angles only
-        ry,rx=get_3d_angles(tg)
-        if abs(ry)>0.3: frame=warp_3d(frame,ry*0.5,"y")
-        if abs(rx)>0.2: frame=warp_3d(frame,rx*0.5,"x")
+        # Crop from big canvas
+        cw, ch = int(TW/zoom), int(TH/zoom)
+        cx, cy = BW//2+pan_x, BH//2+pan_y
+        x1 = max(0, cx-cw//2); y1 = max(0, cy-ch//2)
+        x2 = min(BW, x1+cw);   y2 = min(BH, y1+ch)
+        if (x2-x1)<20 or (y2-y1)<20: x1,y1,x2,y2=0,0,TW,TH
 
-        # Color grade
-        frame=color_grade(frame,style)
+        frame = cv2.resize(base[y1:y2,x1:x2], (TW,TH), interpolation=cv2.INTER_LINEAR)
 
-        # Light leak
-        frame=light_leak(frame,tg,style)
+        # Subtle color grade (won't darken)
+        frame = grade(frame, style)
 
-        # Vignette
-        frame=np.clip(frame.astype(np.float32)*vmask[:,:,None],0,255).astype(np.uint8)
+        # Soft vignette (barely noticeable)
+        frame = soft_vignette(frame)
 
-        # Film grain
-        frame=np.clip(frame.astype(np.float32)+np.random.normal(0,4.,frame.shape),0,255).astype(np.uint8)
+        # Film grain — very light
+        frame = np.clip(frame.astype(np.float32) +
+                        np.random.normal(0, 3.0, frame.shape), 0, 255).astype(np.uint8)
 
-        # Bokeh particles
-        if bokeh: frame=bokeh.draw(frame, tg*duration_sec)
+        # Bokeh on top
+        if bokeh: frame = bokeh.draw(frame, tg*duration_sec)
 
-        # Cinematic bars
-        if add_bars: frame[:44,:]=0; frame[-44:,:]=0
+        # Cinematic bars — thin
+        frame[:36, :] = 0; frame[-36:, :] = 0
 
-        # Fade — very quick fade in (first 3%), slow fade out
-        if tg<0.03: alpha=ease_out_expo(tg/0.03)
-        elif tg>0.93: alpha=ease_in_out((1.-tg)/0.07)
-        else: alpha=1.
-        if alpha<1.: frame=np.clip(frame.astype(np.float32)*alpha,0,255).astype(np.uint8)
+        # Fade in (first 2%) / out (last 5%)
+        if   tg < 0.02: alpha = ease_expo(tg/0.02)
+        elif tg > 0.95: alpha = ease(1-(tg-0.95)/0.05)
+        else:           alpha = 1.0
+        if alpha < 1.0:
+            frame = np.clip(frame.astype(np.float32)*alpha, 0, 255).astype(np.uint8)
 
-        # Captions (draw on PIL)
+        # Captions
         if add_caption:
-            fp=Image.fromarray(frame)
-            t_sec=tg*duration_sec
+            t_sec = tg*duration_sec
             for (cs,ce,ct) in cap_segs:
-                if cs<=t_sec<=ce:
-                    seg_t=t_sec-cs; seg_len=ce-cs
-                    if seg_t<0.5: phase="in"
-                    elif seg_t>seg_len-0.4: phase="out"
-                    else: phase="mid"
-                    local_t=seg_t if phase=="in" else (seg_t-(seg_len-0.4)) if phase=="out" else 0.5
-                    fp=draw_caption(fp,ct,local_t,TW,TH,style,phase)
-            frame=np.array(fp)
+                if cs <= t_sec <= ce:
+                    frame = draw_caption(frame, ct, t_sec-cs, TW, TH, style)
 
-        writer.write(cv2.cvtColor(frame,cv2.COLOR_RGB2BGR))
+        writer.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
 
     writer.release()
 
-    # ── Audio ────────────────────────────────────────────────────────
-    if not add_audio:
-        return tmp_video.name
+    if add_audio:
+        return add_audio_to_video(tmp.name, style, duration_sec, caption)
+    return tmp.name
 
-    bgm_path  =tmp_video.name.replace(".mp4","_bgm.wav")
-    tts_path  =tmp_video.name.replace(".mp4","_tts.wav")
-    audio_path=tmp_video.name.replace(".mp4","_audio.wav")
-    final_path=tmp_video.name.replace(".mp4","_final.mp4")
 
-    make_bgm(duration_sec, bgm_path, style=style)
-
-    has_tts=make_audio(caption_text, duration_sec, tts_path)
-
-    if has_tts and os.path.exists(tts_path):
-        # Mix BGM (low) + TTS
-        os.system(
-            f'ffmpeg -y -i "{bgm_path}" -i "{tts_path}" '
-            f'-filter_complex "[0]volume=0.25[a];[1]volume=1.0[b];[a][b]amix=inputs=2:duration=first" '
-            f'-t {duration_sec} "{audio_path}" -loglevel error'
-        )
-    else:
-        audio_path=bgm_path
+# ── PIPELINE ──────────────────────────────────────────────────────
+def generate(image, caption, style, add_audio, add_caption, add_bokeh, progress=gr.Progress()):
+    if image is None: return None, "⚠️ Upload an image first!"
+    pil  = image if isinstance(image,Image.Image) else Image.fromarray(image)
+    cap  = caption.strip() or "Premium Quality. Shop Now."
+    prompt = f"cinematic product ad, {cap}, smooth motion, dramatic lighting"
+    lines  = []
 
-    if os.path.exists(audio_path):
-        if merge_audio_video(tmp_video.name, audio_path, final_path):
-            return final_path
-
-    return tmp_video.name
-
-
-# ══════════════════════════════════════════════════════════════════
-#  MAIN PIPELINE
-# ══════════════════════════════════════════════════════════════════
-def generate_ad(image, caption, style, add_audio, add_caption,
-                add_3d, add_bokeh, add_bars, progress=gr.Progress()):
-    if image is None: return None, "⚠️ Upload an image!"
-    pil=image if isinstance(image,Image.Image) else Image.fromarray(image)
-    cap=caption.strip() or "Premium Quality. Shop Now."
-    prompt=f"cinematic product advertisement, {cap}, smooth motion, dramatic lighting"
-    lines=[]
+    def log(msg): lines.append(msg); progress(min(.1+len(lines)*.12,.80),desc=msg)
 
-    def log(msg):
-        lines.append(msg); progress(min(.1+len(lines)*.12,.80),desc=msg)
+    progress(.05, desc="🚀 Starting...")
+    ai_path, model = get_ai_video(pil, prompt, cb=log)
 
-    progress(.05,desc="🚀 Starting...")
-
-    # Try AI models first
-    ai_video, model_used = get_ai_video(pil, prompt, style, cb=log)
-
-    if ai_video and "Ken Burns" not in model_used and "Cinematic" not in model_used:
-        # AI video got — add audio+captions on top via ffmpeg
-        log(f"✅ AI video from {model_used}")
-        progress(.85,desc="🎵 Adding audio + captions...")
-
-        # For AI video: just add audio (captions would need re-encoding)
+    if ai_path:
+        log(f"✅ AI video: {model}")
         if add_audio:
-            bgm=ai_video.replace(".mp4","_bgm.wav")
-            final=ai_video.replace(".mp4","_final.mp4")
-            make_bgm(6,bgm,style=style)
-            if merge_audio_video(ai_video,bgm,final):
-                ai_video=final
-        progress(1.0,desc="✅ Done!"); return ai_video, "\n".join(lines)+f"\n\n✅ {model_used}"
-
-    # Cinematic Engine
-    log("🎬 Cinematic Engine rendering...")
-    progress(.70,desc="🎬 Rendering 3D cinematic video...")
-    out=render_cinematic(
-        pil, caption_text=cap, style=style.lower(),
-        duration_sec=7, fps=30,
-        add_audio=add_audio, add_caption=add_caption,
-        add_3d=add_3d, add_bokeh=add_bokeh, add_bars=add_bars,
-    )
-    progress(1.0,desc="✅ Done!")
-    return out, "\n".join(lines)+"\n\n✅ 🎬 Cinematic Engine (3D + Bokeh + Audio + Captions)"
+            progress(.85, desc="🎵 Adding music...")
+            ai_path = add_audio_to_video(ai_path, style.lower(), 6, cap)
+        progress(1.0, desc="✅ Done!")
+        return ai_path, "\n".join(lines)+f"\n\n✅ {model}"
 
+    log("🎬 Cinematic Engine...")
+    progress(.60, desc="🎬 Rendering...")
+    out = render(pil, caption=cap, style=style.lower(),
+                 add_audio=add_audio, add_caption=add_caption, add_bokeh=add_bokeh)
+    progress(1.0, desc="✅ Done!")
+    return out, "\n".join(lines)+"\n\n✅ 🎬 Cinematic Engine"
 
-# ══════════════════════════════════════════════════════════════════
-#  UI
-# ══════════════════════════════════════════════════════════════════
-css="""
-#title{text-align:center;font-size:2.3rem;font-weight:900;margin-bottom:.2rem}
-#sub  {text-align:center;color:#888;margin-bottom:1.5rem}
-"""
-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 + caption → **cinematic AI video** with 3D, bokeh, music & captions",elem_id="sub")
+
+# ── UI ────────────────────────────────────────────────────────────
+css="#title{text-align:center;font-size:2.3rem;font-weight:900}#sub{text-align:center;color:#888;margin-bottom:1.5rem}"
+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 + caption → cinematic reel with music & captions", elem_id="sub")
 
     with gr.Row():
         with gr.Column(scale=1):
-            img_in=gr.Image(label="📸 Upload Image",type="pil",height=280)
-            cap_in=gr.Textbox(label="✏️ Caption / Tagline",
-                              value="Step into style. Own the moment.",lines=2)
-            sty_dd=gr.Dropdown(["Premium","Energetic","Fun"],value="Premium",label="🎨 Style")
-
-            with gr.Row():
-                audio_cb  =gr.Checkbox(label="🎵 Music + Voice",value=True)
-                caption_cb=gr.Checkbox(label="💬 Captions",     value=True)
+            img_in  = gr.Image(label="📸 Upload Image", type="pil", height=280)
+            cap_in  = gr.Textbox(label="✏️ Caption", value="Step into style. Own the moment.", lines=2)
+            sty_dd  = gr.Dropdown(["Premium","Energetic","Fun"], value="Premium", label="🎨 Style")
             with gr.Row():
-                d3_cb    =gr.Checkbox(label="🌀 3D Effect",      value=True)
-                bokeh_cb =gr.Checkbox(label="✨ Bokeh Particles",value=True)
-                bars_cb  =gr.Checkbox(label="🎬 Cinema Bars",    value=True)
-
-            gen_btn=gr.Button("🚀 Generate Cinematic Reel",variant="primary",size="lg")
-
-            gr.Markdown(
-                "**🔗 Pipeline:**\n"
-                "1. 🤖 fal.ai LTX-Video (if FAL_KEY set)\n"
-                "2. 🤖 HF LTX-2 (if HF_TOKEN set)\n"
-                "3. 🎬 **Cinematic Engine** — 3D warp + bokeh\n"
-                "   + animated captions + lo-fi BGM + TTS voice"
-            )
+                audio_cb  = gr.Checkbox(label="🎵 Music + Voice", value=True)
+                caption_cb= gr.Checkbox(label="💬 Captions",      value=True)
+                bokeh_cb  = gr.Checkbox(label="✨ Bokeh",          value=True)
+            gen_btn = gr.Button("🚀 Generate Reel", variant="primary", size="lg")
+            gr.Markdown("**Chain:** fal.ai LTX → HF LTX-2 → 🎬 Cinematic Engine")
 
         with gr.Column(scale=1):
-            vid_out=gr.Video(label="🎥 Cinematic Reel",height=520)
-            log_out=gr.Textbox(label="📊 Log",lines=5,interactive=False)
+            vid_out = gr.Video(label="🎥 Cinematic Reel", height=500)
+            log_out = gr.Textbox(label="📊 Log", lines=5, interactive=False)
 
-    gen_btn.click(
-        fn=generate_ad,
-        inputs=[img_in,cap_in,sty_dd,audio_cb,caption_cb,d3_cb,bokeh_cb,bars_cb],
-        outputs=[vid_out,log_out],
-    )
-    gr.Markdown("---\n**Cinematic Engine:** 3D Perspective Warp · Bokeh Particles · Split-tone Grade · Light Leak · Film Grain · Animated Captions · Lo-fi BGM · TTS Voiceover · 30fps 720×1280")
+    gen_btn.click(fn=generate,
+                  inputs=[img_in,cap_in,sty_dd,audio_cb,caption_cb,bokeh_cb],
+                  outputs=[vid_out,log_out])
 
-if __name__=="__main__":
+if __name__ == "__main__":
     demo.launch()