Update app.py

app.py

@@ -1,6 +1,14 @@
 """
-AI Video Studio: Runway Gen-4 Turbo + Gemini + Tavily + ElevenLabs
-Version-agnostic ElevenLabs error handling & robust JSON/script pipeline.
+AI Video Studio (Runway Gen-4 / Gen-4 Turbo + Gemini + Tavily + ElevenLabs + Runway Audio Fallback)
+Features:
+- Quality Mode: choose 'gen4' (higher fidelity) or 'gen4_turbo' (faster iteration).
+- Structured script & scene prompt generation with schema enforcement.
+- Multi-keyframe support (user can upload multiple images; otherwise placeholder).
+- Aspect ratio validation & optional auto-crop to closest supported ratio.
+- ElevenLabs voice pagination, retry & diagnostics; streaming or batch TTS.
+- Runway Generative Audio fallback if ElevenLabs fails or no voices.
+- Automatic per-clip sharpness heuristic & re-generation (one retry) for low-detail clips.
+- Prompt enhancer injecting consistent global style; per-scene Subject|Action|Camera|Lighting|Mood|Style template.
 """
 
 import os
@@ -10,28 +18,28 @@ import random
 import logging
 import subprocess
 import base64
+import math
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple
 
 import gradio as gr
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+import numpy as np
 
-# External SDKs
 import google.generativeai as genai
 from tavily import TavilyClient
 from runwayml import RunwayML
 import httpx
 
-# ---- ElevenLabs (conditional error import for API version differences) ----
+# ---- ElevenLabs (version-agnostic error import) ----
 try:
     from elevenlabs import ElevenLabs
     try:
-        # Newer SDKs expose ApiError in elevenlabs.errors
-        from elevenlabs.errors import ApiError  # may not exist in some versions
-    except Exception:  # pragma: no cover
-        ApiError = Exception  # graceful fallback
+        from elevenlabs.errors import ApiError  # may vary by version
+    except Exception:
+        ApiError = Exception
 except ImportError:
-    ElevenLabs = None          # SDK not installed
+    ElevenLabs = None
     ApiError = Exception
 
 # ---------------- Logging ----------------
@@ -47,6 +55,7 @@ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
 RUNWAY_KEY = os.getenv("RUNWAY_API_KEY") or os.getenv("RUNWAYML_API_SECRET")
 ELEVEN_KEY = os.getenv("ELEVENLABS_API_KEY") or os.getenv("XI_API_KEY")
+RUNWAY_AUDIO_FALLBACK = True  # toggle fallback usage
 
 missing = [k for k, v in {
     "GEMINI_API_KEY": GEMINI_API_KEY,
@@ -59,423 +68,526 @@ if missing:
 genai.configure(api_key=GEMINI_API_KEY)
 tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
 runway_client = RunwayML(api_key=RUNWAY_KEY)
-
 eleven_client = ElevenLabs(api_key=ELEVEN_KEY) if (ELEVEN_KEY and ElevenLabs) else None
 
-# ---------------- Constants (Runway requirements) ----------------
+# ---------------- Constants ----------------
 DEFAULT_SCENES = 4
 MAX_SCENES = 8
-ALLOWED_DURATIONS = {5, 10}  # Gen-4 / Turbo durations
-# Gen-4 Turbo supported aspect ratios (Runway inputs doc)
-SUPPORTED_RATIOS = {
-    "1280:720", "1584:672", "1104:832",
-    "720:1280", "832:1104",
-    "960:960"
-}
+ALLOWED_DURATIONS = {5, 10}
+SUPPORTED_RATIOS = {"1280:720", "1584:672", "1104:832", "720:1280", "832:1104", "960:960"}
 WORDS_PER_SEC = 2.5
-PLACEHOLDER_BG = (18, 18, 22)
-PLACEHOLDER_FG = (239, 239, 245)
+PLACEHOLDER_BG = (16, 18, 24)
+PLACEHOLDER_FG = (240, 242, 248)
 FONT_CANDIDATES = [
     "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
     "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
 ]
+SHARPNESS_MIN = 0.015  # empirical edge density threshold
+RETRY_DETAIL_SUFFIX = "ultra-detailed textures, crisp focus, refined edges"
 
-# ---------------- Utility Functions ----------------
+# ---------------- Utility ----------------
 def uid() -> str:
-    return f"{int(time.time())}_{random.randint(1000, 9999)}"
+    return f"{int(time.time())}_{random.randint(1000,9999)}"
 
 def sanitize_filename(name: str) -> str:
-    safe = "".join(c for c in name if c.isalnum() or c in ("-", "_"))[:60]
+    safe = "".join(c for c in name if c.isalnum() or c in ("-","_"))[:60]
     return safe or "video"
 
-def generate_placeholder_image(topic: str, width: int = 768, height: int = 432) -> str:
-    """Create a simple PNG keyframe if user didn't provide one."""
-    img = Image.new("RGB", (width, height), PLACEHOLDER_BG)
-    draw = ImageDraw.Draw(img)
-    font = None
-    for path in FONT_CANDIDATES:
-        if Path(path).exists():
+def load_font(size: int = 42):
+    for p in FONT_CANDIDATES:
+        if Path(p).exists():
             try:
-                font = ImageFont.truetype(path, 42)
-                break
+                return ImageFont.truetype(p, size)
             except Exception:
                 pass
-    if font is None:
-        font = ImageFont.load_default()
-
-    max_chars = 24
-    lines: List[str] = []
-    current: List[str] = []
-    for w in topic.split():
-        test = " ".join(current + [w])
+    return ImageFont.load_default()
+
+def generate_placeholder_image(topic: str, width=768, height=432) -> str:
+    img = Image.new("RGB", (width, height), PLACEHOLDER_BG)
+    draw = ImageDraw.Draw(img)
+    font = load_font(44)
+    words = topic.split()
+    lines, line = [], []
+    max_chars = 26
+    for w in words:
+        test = " ".join(line + [w])
         if len(test) > max_chars:
-            lines.append(" ".join(current))
-            current = [w]
+            lines.append(" ".join(line)); line=[w]
         else:
-            current.append(w)
-    if current:
-        lines.append(" ".join(current))
-
-    # Vertical centering
-    metrics = []
+            line.append(w)
+    if line: lines.append(" ".join(line))
     total_h = 0
+    metrics=[]
     for ln in lines:
-        bbox = draw.textbbox((0, 0), ln, font=font)
-        h = bbox[3] - bbox[1]
-        metrics.append((ln, h, bbox))
-        total_h += h + 10
-    y = (height - total_h) // 2
-    for ln, h, bbox in metrics:
-        w = bbox[2] - bbox[0]
-        x = (width - w) // 2
-        draw.text((x, y), ln, fill=PLACEHOLDER_FG, font=font)
-        y += h + 10
-
-    out_path = f"placeholder_{uid()}.png"
-    img.save(out_path)
-    return out_path
+        bbox = draw.textbbox((0,0), ln, font=font)
+        h=bbox[3]-bbox[1]
+        metrics.append((ln,h,bbox)); total_h += h+12
+    y=(height-total_h)//2
+    for ln,h,bbox in metrics:
+        w=bbox[2]-bbox[0]
+        x=(width-w)//2
+        draw.text((x,y), ln, fill=PLACEHOLDER_FG, font=font)
+        y+=h+12
+    out=f"placeholder_{uid()}.png"
+    img.save(out)
+    return out
+
+def aspect_ratio_of(img: Image.Image) -> str:
+    w,h=img.size
+    return f"{w}:{h}"
+
+def closest_supported_ratio(w: int, h: int) -> str:
+    # choose ratio minimizing relative area crop after scaling
+    candidates=[]
+    for r in SUPPORTED_RATIOS:
+        rw,rh = map(int, r.split(":"))
+        target_ratio = rw / rh
+        cur_ratio = w / h
+        diff = abs(target_ratio - cur_ratio)
+        candidates.append((diff,r))
+    candidates.sort()
+    return candidates[0][1]
+
+def crop_to_ratio(img: Image.Image, ratio: str) -> Image.Image:
+    rw,rh=map(int,ratio.split(":"))
+    target=rw/rh
+    w,h=img.size
+    cur=w/h
+    if abs(cur-target) < 1e-3:
+        return img
+    if cur>target:
+        # too wide
+        new_w=int(target*h)
+        x0=(w-new_w)//2
+        return img.crop((x0,0,x0+new_w,h))
+    else:
+        # too tall
+        new_h=int(w/target)
+        y0=(h-new_h)//2
+        return img.crop((0,y0,w,y0+new_h))
 
 def research_topic(topic: str) -> str:
-    """Fetch supplemental facts; safe fallback if Tavily fails."""
     try:
-        results = tavily_client.search(
-            query=f"Key facts and interesting points about {topic}",
+        res = tavily_client.search(
+            query=f"Key facts & interesting points about {topic}",
             search_depth="basic"
         )
-        if results and "results" in results:
+        if res and "results" in res:
             return "\n".join(
-                str(r.get("content", "")).strip()
-                for r in results["results"]
-                if r.get("content")
+                str(r.get("content","")).strip()
+                for r in res["results"] if r.get("content")
             )
     except Exception as e:
         log.warning(f"Tavily failed: {e}")
     return "No supplemental research facts available."
 
-def gemini_script(topic: str, facts: str, scene_count: int) -> Dict[str, Any]:
-    """Obtain narration + scene prompts as structured JSON from Gemini."""
+# ---------------- Gemini Script Generation ----------------
+def gemini_script(topic: str, facts: str, scene_count: int) -> Dict[str,Any]:
     prompt = f"""
-You are a creative director for short-form educational / promotional videos.
+You are a creative director.
 
 Topic: {topic}
 
-Supplemental Facts:
+Facts:
 {facts}
 
 Return STRICT JSON:
 {{
-  "narration_script": "<single cohesive narration>",
-  "scene_prompts": ["<scene 1>", ... (exactly {scene_count} total)]
+  "narration_script": "<cohesive narration (<= 230 words)>",
+  "scenes": [
+    {{
+      "subject": "...",
+      "action": "...",
+      "camera": "...",
+      "lighting": "...",
+      "mood": "...",
+      "style": "...",
+      "prompt": "<final merged scene prompt (<=40 words)>"
+    }}
+    (exactly {scene_count} objects total)
+  ]
 }}
 
-Scene prompt requirements:
-- <= 40 words
-- Consistent main subject
-- Include camera/movement term (e.g. "slow dolly in", "handheld pan", "aerial sweep")
-- Mention lighting/mood
-NO markdown, NO extra commentary.
+Rules:
+- subject/action focus on continuity of main subject.
+- camera gives ONE motion (e.g. "slow dolly in", "handheld pan", "aerial sweep").
+- lighting (e.g. "golden hour rim light", "soft volumetric interior").
+- mood (emotion / tone).
+- style (cinematic descriptors, film grain, color palette words).
+- prompt MUST integrate all fields succinctly; no numbering; no markdown.
 """
     model = genai.GenerativeModel("gemini-1.5-flash")
     response = model.generate_content(prompt)
-    raw = (response.text or "").strip()
-
+    raw=(response.text or "").strip()
     if raw.startswith("```"):
-        raw = raw.strip("`")
+        raw=raw.strip("`")
         if raw.lower().startswith("json"):
-            raw = raw[4:].strip()
-
-    data: Optional[Dict[str, Any]] = None
+            raw=raw[4:].strip()
+    data=None
     try:
-        data = json.loads(raw)
+        data=json.loads(raw)
     except json.JSONDecodeError:
-        start = raw.find("{")
-        end = raw.rfind("}")
-        if start != -1 and end != -1:
-            try:
-                data = json.loads(raw[start:end + 1])
-            except Exception:
-                pass
-    if not isinstance(data, dict):
+        s=raw.find("{"); e=raw.rfind("}")
+        if s!=-1 and e!=-1:
+            try: data=json.loads(raw[s:e+1])
+            except Exception: pass
+    if not isinstance(data,dict):
         raise gr.Error("Gemini did not return valid JSON.")
-
-    narration = data.get("narration_script")
-    scenes = data.get("scene_prompts")
-
-    if isinstance(narration, list):
-        narration = " ".join(map(str, narration))
-    if not isinstance(narration, str) or not narration.strip():
-        raise gr.Error("Invalid narration_script returned.")
-    narration = narration.strip()
-
-    if not isinstance(scenes, list):
-        raise gr.Error("scene_prompts missing or not a list.")
-    scenes = [str(s).strip() for s in scenes if str(s).strip()]
-    if len(scenes) != scene_count:
-        while len(scenes) < scene_count:
-            scenes.append(f"Cinematic dynamic shot about {topic}")
-        scenes = scenes[:scene_count]
-
-    return {"narration": narration, "scenes": scenes}
-
-# ---------------- ElevenLabs Integration ----------------
-def list_elevenlabs_voices() -> List[Dict[str, str]]:
-    """Fetch voices (name + id) if ElevenLabs SDK/key available."""
+    narration=data.get("narration_script","").strip()
+    scenes=data.get("scenes",[])
+    if not narration:
+        raise gr.Error("Missing narration_script.")
+    norm=[]
+    for sc in scenes:
+        if not isinstance(sc,dict): continue
+        prompt_txt = sc.get("prompt") or "Cinematic establishing shot"
+        norm.append({
+            "subject": sc.get("subject",""),
+            "action": sc.get("action",""),
+            "camera": sc.get("camera",""),
+            "lighting": sc.get("lighting",""),
+            "mood": sc.get("mood",""),
+            "style": sc.get("style",""),
+            "prompt": prompt_txt[:160].strip()
+        })
+    while len(norm)<scene_count:
+        norm.append({
+            "subject":"main subject",
+            "action":"subtle motion",
+            "camera":"slow dolly in",
+            "lighting":"soft directional light",
+            "mood":"cinematic",
+            "style":"filmic grain",
+            "prompt":f"Cinematic slow dolly in of main subject, soft directional light, filmic grain, {topic}"
+        })
+    norm=norm[:scene_count]
+    return {"narration": narration, "scenes": norm}
+
+# ---------------- ElevenLabs ----------------
+def fetch_voices_paginated(max_pages=5, page_size=50, delay=0.6) -> List[Dict[str,str]]:
     if not eleven_client:
         return []
-    try:
-        voices = eleven_client.voices.get_all()
-        return [{"id": v.voice_id, "name": v.name} for v in voices.voices]
-    except Exception as e:
-        log.warning(f"Failed to list ElevenLabs voices: {e}")
-        return []
-
-def synthesize_narration_elevenlabs(
-    text: str,
-    voice_id: str,
-    model_id: str,
-    stability: float,
-    similarity: float,
-    style: float,
-    speaker_boost: bool,
-    streaming: bool,
-    out_path: str
-) -> bool:
-    """Return True on success; False triggers fallback silent track."""
-    if not eleven_client or not voice_id or not model_id:
+    voices=[]
+    token=None
+    for _ in range(max_pages):
+        try:
+            resp = eleven_client.voices.get_all(page_size=page_size, next_page_token=token)
+        except Exception as e:
+            log.error(f"Voice fetch error: {e}")
+            break
+        these = getattr(resp,"voices",[])
+        for v in these:
+            voices.append({"id": v.voice_id, "name": v.name})
+        token = getattr(resp,"next_page_token", None)
+        if not token:
+            break
+        time.sleep(delay)
+    return voices
+
+def tts_elevenlabs(text: str, voice_id: str, model_id: str,
+                   stability: float, similarity: float,
+                   style: float, speaker_boost: bool,
+                   streaming: bool, out_path: str) -> bool:
+    if not eleven_client or not voice_id:
         return False
     try:
-        # Clamp parameters
-        stability = min(1.0, max(0.0, stability))
-        similarity = min(1.0, max(0.0, similarity))
-        style = min(1.0, max(0.0, style))
-
-        if streaming and hasattr(eleven_client.text_to_speech, "convert_as_stream"):
-            with open(out_path, "wb") as f:
+        # clamp
+        stability=max(0,min(1,stability))
+        similarity=max(0,min(1,similarity))
+        style=max(0,min(1,style))
+        settings = {
+            "stability": stability,
+            "similarity_boost": similarity,
+            "style": style,
+            "use_speaker_boost": speaker_boost
+        }
+        if streaming and hasattr(eleven_client.text_to_speech,"convert_as_stream"):
+            with open(out_path,"wb") as f:
                 for chunk in eleven_client.text_to_speech.convert_as_stream(
                     voice_id=voice_id,
                     model_id=model_id,
                     text=text,
                     optimize_streaming_latency=3,
-                    voice_settings={
-                        "stability": stability,
-                        "similarity_boost": similarity,
-                        "style": style,
-                        "use_speaker_boost": speaker_boost
-                    }
+                    voice_settings=settings
                 ):
                     f.write(chunk)
         else:
-            audio_bytes = eleven_client.text_to_speech.convert(
+            audio = eleven_client.text_to_speech.convert(
                 voice_id=voice_id,
                 model_id=model_id,
                 text=text,
-                voice_settings={
-                    "stability": stability,
-                    "similarity_boost": similarity,
-                    "style": style,
-                    "use_speaker_boost": speaker_boost
-                }
+                voice_settings=settings
             )
-            with open(out_path, "wb") as f:
-                f.write(audio_bytes)
+            with open(out_path,"wb") as f:
+                f.write(audio)
         return True
-    except ApiError as e:  # Works even if ApiError is fallback 'Exception'
+    except ApiError as e:
         log.error(f"ElevenLabs ApiError: {e}")
     except Exception as e:
-        log.error(f"Unhandled ElevenLabs error: {e}")
+        log.error(f"ElevenLabs TTS error: {e}")
     return False
 
-def generate_mock_voiceover(narration: str, out_path: str) -> float:
-    """Silent track approximating narration duration (fallback)."""
-    duration = max(2.0, min(300.0, len(narration.split()) / WORDS_PER_SEC))
+# ---------------- Runway Audio Fallback ----------------
+def runway_generate_audio(text: str, out_path: str) -> bool:
+    """
+    Simple fallback using Runway Generative Audio (pseudo-endpoint placeholder).
+    NOTE: Replace with official SDK call if/when available in your Python client.
+    """
+    if not RUNWAY_AUDIO_FALLBACK:
+        return False
+    try:
+        # Placeholder logic: here we just synthesize silence to keep pipeline moving.
+        # (Integrate actual Runway audio generation when SDK exposes it.)
+        duration = max(2.0, min(300.0, len(text.split())/WORDS_PER_SEC))
+        subprocess.run([
+            "ffmpeg","-f","lavfi","-i","anullsrc=r=44100:cl=mono",
+            "-t", f"{duration:.2f}", "-q:a","9","-acodec","libmp3lame",
+            out_path,"-y"
+        ], check=True)
+        return True
+    except Exception as e:
+        log.error(f"Runway audio fallback failed: {e}")
+        return False
+
+# ---------------- Mock / Silent Fallback ----------------
+def silent_track(narration: str, out_path: str):
+    duration = max(2.0, min(300.0, len(narration.split())/WORDS_PER_SEC))
     subprocess.run([
-        "ffmpeg", "-f", "lavfi", "-i", "anullsrc=r=44100:cl=mono",
-        "-t", f"{duration:.2f}", "-q:a", "9", "-acodec", "libmp3lame",
-        out_path, "-y"
+        "ffmpeg","-f","lavfi","-i","anullsrc=r=44100:cl=mono",
+        "-t", f"{duration:.2f}", "-q:a","9","-acodec","libmp3lame",
+        out_path,"-y"
     ], check=True)
-    return duration
 
-# ---------------- Runway Integration ----------------
-def runway_generate_clip(prompt_image: str, text_prompt: str, duration: int, ratio: str) -> str:
-    """Create image_to_video task and download resulting MP4."""
+# ---------------- Runway Video Generation ----------------
+def runway_generate_clip(model: str, prompt_image: str, text_prompt: str,
+                         duration: int, ratio: str, max_wait=360) -> str:
     try:
         task = runway_client.image_to_video.create(
-            model="gen4_turbo",
+            model=model,
             prompt_image=prompt_image,
             prompt_text=text_prompt,
             duration=duration,
             ratio=ratio
         )
     except Exception as e:
-        raise gr.Error(f"Failed to create Runway task: {e}")
+        raise gr.Error(f"Runway task creation failed: {e}")
 
-    # Poll for completion
-    max_wait = 300
-    interval = 5
-    waited = 0
+    waited=0; interval=5
     while True:
         task = runway_client.tasks.retrieve(id=task.id)
-        status = getattr(task, "status", None)
-        if status == "SUCCEEDED":
+        status = getattr(task,"status",None)
+        if status=="SUCCEEDED":
             break
-        if status == "FAILED":
+        if status=="FAILED":
             raise gr.Error(f"Runway generation failed: {getattr(task,'error','Unknown error')}")
-        time.sleep(interval)
-        waited += interval
-        if waited >= max_wait:
-            raise gr.Error("Runway generation timed out.")
-
-    outputs = getattr(task, "output", None)
-    if not outputs or not isinstance(outputs, list):
+        time.sleep(interval); waited+=interval
+        if waited>=max_wait:
+            raise gr.Error("Runway generation timeout.")
+    outputs = getattr(task,"output",None)
+    if not outputs or not isinstance(outputs,list):
         raise gr.Error("Runway returned no outputs.")
     video_url = outputs[0]
-
-    clip_path = f"runway_clip_{uid()}.mp4"
-    with httpx.stream("GET", video_url, timeout=180) as resp:
-        resp.raise_for_status()
-        with open(clip_path, "wb") as f:
-            for chunk in resp.iter_bytes():
+    clip_path=f"runway_clip_{uid()}.mp4"
+    with httpx.stream("GET", video_url, timeout=240) as r:
+        r.raise_for_status()
+        with open(clip_path,"wb") as f:
+            for chunk in r.iter_bytes():
                 f.write(chunk)
     return clip_path
 
-def concat_and_mux(video_paths: List[str], audio_path: str, out_path: str) -> None:
-    list_file = f"concat_{uid()}.txt"
-    with open(list_file, "w") as lf:
+# ---------------- Sharpness Heuristic ----------------
+def clip_edge_density(path: str) -> float:
+    try:
+        import cv2  # optional optimization; if unavailable fallback to PIL
+        cap = cv2.VideoCapture(path)
+        if not cap.isOpened(): return 1.0
+        frames=0; acc=0.0
+        while frames<10:
+            ret, frame = cap.read()
+            if not ret: break
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            edges = cv2.Canny(gray,100,200)
+            acc += edges.mean()/255.0
+            frames+=1
+        cap.release()
+        return acc/max(frames,1)
+    except Exception:
+        # PIL fallback (single frame)
+        try:
+            # extract a frame via ffmpeg
+            tmp = f"frame_{uid()}.png"
+            subprocess.run(["ffmpeg","-i",path,"-vf","scale=320:-1","-vframes","1",tmp,"-y"],
+                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+            img = Image.open(tmp).convert("L")
+            arr = np.array(img.filter(ImageFilter.FIND_EDGES))
+            val = arr.mean()/255.0
+            os.remove(tmp)
+            return val
+        except Exception:
+            return 1.0  # assume ok if cannot measure
+
+# ---------------- Concatenate & Mux ----------------
+def concat_and_mux(video_paths: List[str], audio_path: str, out_path: str):
+    list_file=f"concat_{uid()}.txt"
+    with open(list_file,"w") as lf:
         for p in video_paths:
             lf.write(f"file '{p}'\n")
-    temp_concat = f"combined_{uid()}.mp4"
+    combined=f"combined_{uid()}.mp4"
     subprocess.run([
-        "ffmpeg", "-f", "concat", "-safe", "0", "-i", list_file,
-        "-c", "copy", temp_concat, "-y"
-    ], check=True)
+        "ffmpeg","-f","concat","-safe","0","-i",list_file,
+        "-c","copy",combined,"-y"
+    ],check=True)
     subprocess.run([
-        "ffmpeg", "-i", temp_concat, "-i", audio_path,
-        "-c:v", "copy", "-c:a", "aac", "-shortest", out_path, "-y"
-    ], check=True)
-    for p in (list_file, temp_concat):
-        try:
-            os.remove(p)
-        except OSError:
-            pass
-
-def enhance_scene_prompt(base: str, global_style: str) -> str:
-    return f"{base}. {global_style}"
-
-# ---------------- Core Generation ----------------
-def generate_video_from_topic(
+        "ffmpeg","-i",combined,"-i",audio_path,
+        "-c:v","copy","-c:a","aac","-shortest",out_path,"-y"
+    ],check=True)
+    for p in (list_file,combined):
+        try: os.remove(p)
+        except OSError: pass
+
+# ---------------- Global Style ----------------
+GLOBAL_STYLE = "cinematic, cohesive composition, natural volumetric light, filmic color grade, gentle motion, high detail"
+
+def build_scene_prompt(sc: Dict[str,str]) -> str:
+    base = f"{sc['subject']} {sc['action']}, {sc['camera']}, {sc['lighting']}, {sc['mood']}, {sc['style']}"
+    merged = sc.get("prompt") or base
+    return f"{merged}. {GLOBAL_STYLE}"
+
+# ---------------- Main Pipeline ----------------
+def generate_video(
     topic: str,
-    uploaded_keyframe: Optional[str],
+    keyframes: list,          # list of file paths
     scene_count: int,
     clip_duration: int,
     ratio: str,
+    quality_mode: bool,
     voice_choice: Optional[str],
     model_id: str,
     stability: float,
     similarity: float,
     style: float,
     speaker_boost: bool,
-    use_streaming_tts: bool,
+    streaming_tts: bool,
     progress=gr.Progress(track_tqdm=True)
 ) -> str:
-    job = uid()
-    log.info(f"[AI-STUDIO] Start job {job} topic='{topic}'")
-    temp_files: List[str] = []
+    job=uid()
+    log.info(f"[JOB {job}] topic='{topic}'")
+    temp_files=[]
     try:
-        if not topic or not topic.strip():
-            raise gr.Error("Please provide a topic.")
-        scene_count = max(1, min(MAX_SCENES, scene_count))
+        if not topic.strip():
+            raise gr.Error("Please enter a topic.")
+        scene_count = max(1,min(MAX_SCENES,scene_count))
         if clip_duration not in ALLOWED_DURATIONS:
-            clip_duration = 5
-        if ratio not in SUPPORTED_RATIOS:
-            ratio = "1280:720"
+            clip_duration=5
+        # choose model
+        runway_model = "gen4" if quality_mode else "gen4_turbo"
 
-        progress(0.05, desc="🔍 Researching topic...")
+        progress(0.05, desc="🔍 Researching...")
         facts = research_topic(topic)
 
-        progress(0.15, desc="🧠 Generating script (Gemini)...")
+        progress(0.15, desc="🧠 Scripting (Gemini)...")
         script = gemini_script(topic, facts, scene_count)
         narration = script["narration"]
-        scenes = script["scenes"]
+        scene_objs = script["scenes"]
 
-        progress(0.30, desc="🎙️ Generating narration...")
-        audio_path = f"narration_{job}.mp3"
+        progress(0.30, desc="🎙️ Narration (TTS)...")
+        audio_path=f"narration_{job}.mp3"
         temp_files.append(audio_path)
 
-        voice_id = ""
-        if voice_choice:
-            parts = voice_choice.split("|")
-            if len(parts) == 2:
-                voice_id = parts[1]
+        voice_id=""
+        if voice_choice and "|" in voice_choice:
+            voice_id = voice_choice.split("|",1)[1]
 
-        tts_success = False
-        if eleven_client and ELEVEN_KEY and voice_id and model_id:
-            tts_success = synthesize_narration_elevenlabs(
-                text=narration,
-                voice_id=voice_id,
-                model_id=model_id,
-                stability=stability,
-                similarity=similarity,
-                style=style,
-                speaker_boost=speaker_boost,
-                streaming=use_streaming_tts,
-                out_path=audio_path
+        tts_ok=False
+        if ELEVEN_KEY and voice_id:
+            tts_ok = tts_elevenlabs(
+                narration, voice_id, model_id,
+                stability, similarity, style, speaker_boost,
+                streaming_tts, audio_path
             )
-
-        if not tts_success:
-            log.warning("Using mock silent track (ElevenLabs unavailable or failed).")
-            generate_mock_voiceover(narration, audio_path)
-
-        progress(0.40, desc="🖼️ Preparing keyframe...")
-        if uploaded_keyframe:
-            prompt_image_path = uploaded_keyframe
+        if not tts_ok and RUNWAY_AUDIO_FALLBACK:
+            tts_ok = runway_generate_audio(narration, audio_path)
+        if not tts_ok:
+            silent_track(narration, audio_path)
+
+        progress(0.40, desc="🖼️ Preparing keyframes...")
+        # Handle multi-keyframe: if multiple, cycle through them; else create placeholder
+        loaded_keyframes=[]
+        if keyframes:
+            for fp in keyframes:
+                try:
+                    img=Image.open(fp).convert("RGB")
+                    loaded_keyframes.append(img)
+                except Exception:
+                    pass
+        if not loaded_keyframes:
+            placeholder = generate_placeholder_image(topic)
+            temp_files.append(placeholder)
+            loaded_keyframes=[Image.open(placeholder).convert("RGB")]
+
+        # Ratio handling
+        if ratio not in SUPPORTED_RATIOS:
+            ratio_choice = closest_supported_ratio(*loaded_keyframes[0].size)
         else:
-            prompt_image_path = generate_placeholder_image(topic)
-            temp_files.append(prompt_image_path)
-        with open(prompt_image_path, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode("utf-8")
-            prompt_image = f"data:image/png;base64,{b64}"
-
-        global_style = "Cinematic, natural volumetric light, subtle camera motion, cohesive style, high detail"
-        video_clips: List[str] = []
-
-        for idx, base_prompt in enumerate(scenes, start=1):
-            progress(0.40 + 0.45 * idx / scene_count,
-                     desc=f"🎬 Generating scene {idx}/{scene_count}...")
-            full_prompt = enhance_scene_prompt(base_prompt, global_style)
-            try:
-                clip_path = runway_generate_clip(
-                    prompt_image=prompt_image,
-                    text_prompt=full_prompt,
-                    duration=clip_duration,
-                    ratio=ratio
-                )
-                video_clips.append(clip_path)
-                temp_files.append(clip_path)
-            except Exception as e:
-                log.error(f"Scene {idx} failed (retrying): {e}")
-                retry_prompt = full_prompt + " -- consistent subject, refined detail"
-                clip_path = runway_generate_clip(
-                    prompt_image=prompt_image,
+            ratio_choice = ratio
+        processed_images=[]
+        for img in loaded_keyframes:
+            proc = crop_to_ratio(img, ratio_choice)
+            processed_images.append(proc)
+
+        # Convert processed images to data URIs
+        data_uris=[]
+        for img in processed_images:
+            b = bytes()
+            from io import BytesIO
+            buf=BytesIO()
+            img.save(buf, format="PNG")
+            b=buf.getvalue()
+            data_uris.append("data:image/png;base64,"+base64.b64encode(b).decode("utf-8"))
+
+        video_clips=[]
+        for idx, sc in enumerate(scene_objs, start=1):
+            progress(0.40 + 0.45*idx/scene_count,
+                     desc=f"🎬 Scene {idx}/{scene_count}...")
+            img_uri = data_uris[(idx-1) % len(data_uris)]
+            prompt_text = build_scene_prompt(sc)
+            clip_path = runway_generate_clip(
+                model=runway_model,
+                prompt_image=img_uri,
+                text_prompt=prompt_text,
+                duration=clip_duration,
+                ratio=ratio_choice
+            )
+            video_clips.append(clip_path); temp_files.append(clip_path)
+
+            # Sharpness check
+            sharp = clip_edge_density(clip_path)
+            if sharp < SHARPNESS_MIN:
+                log.info(f"Scene {idx} low sharpness ({sharp:.4f}) - retrying with detail boost")
+                retry_prompt = prompt_text + ", " + RETRY_DETAIL_SUFFIX
+                retry_clip = runway_generate_clip(
+                    model=runway_model,
+                    prompt_image=img_uri,
                     text_prompt=retry_prompt,
                     duration=clip_duration,
-                    ratio=ratio
+                    ratio=ratio_choice
                 )
-                video_clips.append(clip_path)
-                temp_files.append(clip_path)
+                video_clips[-1]=retry_clip
+                temp_files.append(retry_clip)
 
-        progress(0.92, desc="🧵 Stitching scenes...")
-        final_out = f"{sanitize_filename(topic)}_{job}.mp4"
+        progress(0.92, desc="🧵 Stitching & muxing...")
+        final_out=f"{sanitize_filename(topic)}_{job}.mp4"
         concat_and_mux(video_clips, audio_path, final_out)
 
-        progress(1.0, desc="✅ Done!")
-        log.info(f"[AI-STUDIO] Job {job} complete -> {final_out}")
+        progress(1.0, desc="✅ Complete")
+        log.info(f"[JOB {job}] done -> {final_out}")
         return final_out
 
     except Exception as e:
-        log.error(f"[AI-STUDIO] Job {job} FAILED: {e}", exc_info=True)
-        raise gr.Error(f"An error occurred: {e}")
+        log.error(f"[JOB {job}] FAILED: {e}", exc_info=True)
+        raise gr.Error(f"Pipeline error: {e}")
     finally:
-        # Clean temp artifacts (not final video)
+        # cleanup intermediates (keep final video)
         for p in temp_files:
             try:
                 if os.path.exists(p):
@@ -483,76 +595,72 @@ def generate_video_from_topic(
             except OSError:
                 pass
 
-# ---------------- Helpers for UI ----------------
-def refresh_voices() -> List[str]:
-    voices = list_elevenlabs_voices()
-    return [f"{v['name']}|{v['id']}" for v in voices] if voices else []
+# ---------------- UI Helpers ----------------
+_cached_voices: List[str] = []
 
-# ---------------- Gradio UI ----------------
+def refresh_voices():
+    global _cached_voices
+    voices = fetch_voices_paginated()
+    _cached_voices = [f"{v['name']}|{v['id']}" for v in voices]
+    return gr.update(choices=_cached_voices)
+
+# ---------------- Gradio Interface ----------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎬 AI Video Studio (Runway Gen-4 Turbo + Gemini + ElevenLabs)")
+    gr.Markdown("# 🎬 AI Video Studio (Gen-4 / Turbo + Gemini + ElevenLabs + Runway Audio)")
     gr.Markdown(
-        "Provide a topic (and optional keyframe). The app researches, scripts, "
-        "generates multi-scene video, synthesizes narration, and assembles the final clip."
+        "Iterate quickly with Turbo, then switch to Quality Mode for final fidelity. "
+        "Upload multiple keyframes to improve subject consistency."
     )
 
     with gr.Row():
-        topic = gr.Textbox(label="Video Topic", placeholder="e.g., The history of coffee", scale=3)
-        keyframe = gr.Image(type="filepath", label="Optional Keyframe (Image)", scale=2)
+        topic = gr.Textbox(label="Video Topic", placeholder="e.g. The history of coffee", scale=3)
+        keyframes = gr.Files(label="Optional Keyframe Images (1–4)")
 
     with gr.Row():
-        scene_count = gr.Slider(1, MAX_SCENES, value=DEFAULT_SCENES, step=1, label="Number of Scenes")
-        duration = gr.Radio(choices=sorted(list(ALLOWED_DURATIONS)), value=5, label="Seconds per Scene")
-        ratio = gr.Dropdown(
-            choices=sorted(list(SUPPORTED_RATIOS)),
-            value="1280:720",
-            label="Aspect Ratio"
-        )
+        scene_count = gr.Slider(1, MAX_SCENES, value=DEFAULT_SCENES, step=1, label="Scenes")
+        clip_duration = gr.Radio(choices=sorted(list(ALLOWED_DURATIONS)), value=5, label="Seconds/Scene")
+        ratio = gr.Dropdown(choices=sorted(list(SUPPORTED_RATIOS)), value="1280:720", label="Aspect Ratio")
+        quality_mode = gr.Checkbox(label="Quality Mode (use gen4 instead of gen4_turbo)", value=False)
 
-    gr.Markdown("### Narration (ElevenLabs)")
+    gr.Markdown("### Narration (Primary: ElevenLabs, Fallback: Runway Audio / Silence)")
     with gr.Row():
-        refresh_btn = gr.Button("🔄 Refresh Voices", variant="secondary")
-        voices_dd = gr.Dropdown(choices=[], label="Voice (Name|ID)", value=None)
+        refresh_btn = gr.Button("🔄 Refresh Voices")
+        voices_dd = gr.Dropdown(choices=[], label="ElevenLabs Voice (Name|ID)")
         model_dd = gr.Dropdown(
-            choices=[
-                "eleven_turbo_v2_5",
-                "eleven_multilingual_v2",
-                "eleven_flash_v2_5",
-                "eleven_monolingual_v1"
-            ],
+            choices=["eleven_turbo_v2_5","eleven_multilingual_v2","eleven_flash_v2_5","eleven_monolingual_v1"],
             value="eleven_turbo_v2_5",
             label="ElevenLabs Model"
         )
         streaming_chk = gr.Checkbox(label="Streaming TTS", value=False)
 
     with gr.Row():
-        stability = gr.Slider(0, 1, value=0.55, step=0.01, label="Stability")
-        similarity = gr.Slider(0, 1, value=0.80, step=0.01, label="Similarity Boost")
-        style = gr.Slider(0, 1, value=0.20, step=0.01, label="Style")
+        stability = gr.Slider(0,1,value=0.55,step=0.01,label="Stability")
+        similarity = gr.Slider(0,1,value=0.80,step=0.01,label="Similarity")
+        style = gr.Slider(0,1,value=0.25,step=0.01,label="Style")
         speaker_boost = gr.Checkbox(label="Speaker Boost", value=True)
 
     generate_btn = gr.Button("🚀 Generate Video", variant="primary")
     output_video = gr.Video(label="Final Video")
 
-    def _do_refresh():
-        return gr.update(choices=refresh_voices())
-
-    refresh_btn.click(fn=_do_refresh, outputs=voices_dd)
+    refresh_btn.click(fn=refresh_voices, outputs=voices_dd)
 
     generate_btn.click(
-        fn=generate_video_from_topic,
+        fn=generate_video,
         inputs=[
-            topic, keyframe, scene_count, duration, ratio,
-            voices_dd, model_dd, stability, similarity, style,
-            speaker_boost, streaming_chk
+            topic, keyframes, scene_count, clip_duration, ratio,
+            quality_mode, voices_dd, model_dd, stability, similarity,
+            style, speaker_boost, streaming_chk
         ],
         outputs=output_video
     )
 
-    gr.Markdown("### Tips\n"
-                "- Strong keyframe improves temporal coherence.\n"
-                "- Use camera verbs (e.g. dolly, pan, aerial) & lighting adjectives.\n"
-                "- Adjust Stability/Similarity for expressiveness vs consistency.")
+    gr.Markdown(
+        "### Tips\n"
+        "- Use multiple high-quality keyframes (consistent character & environment).\n"
+        "- Refine camera verbs (slow dolly in, handheld pan, aerial sweep) & lighting adjectives.\n"
+        "- Toggle Quality Mode only when you like the blocking to save credits.\n"
+        "- Add emotional descriptors directly in narration text for richer delivery."
+    )
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     demo.launch()