Update app.py

app.py

@@ -88,44 +88,124 @@ CRITICAL: Return ONLY raw JSON. No markdown. No ```json. No explanation. Pure JS
 
 
 # ── FAST VIDEO: Ken Burns effect (zoom + pan) — NO heavy model needed ─────────
-def generate_video(pil_image: Image.Image, duration_sec: int = 5, fps: int = 24) -> str:
+def ease_in_out(t):
+    """Smooth easing — no jerky motion."""
+    return t * t * (3 - 2 * t)
+
+def ease_out_bounce(t):
+    """Bouncy pop effect."""
+    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
+
+def apply_vignette(frame, strength=0.6):
+    """Dark edges — cinematic look."""
+    h, w = frame.shape[:2]
+    Y, X = np.ogrid[:h, :w]
+    cx, cy = w / 2, h / 2
+    dist = np.sqrt(((X - cx) / cx) ** 2 + ((Y - cy) / cy) ** 2)
+    mask = np.clip(1.0 - strength * (dist ** 1.5), 0, 1)
+    return (frame * mask[:, :, np.newaxis]).astype(np.uint8)
+
+def apply_color_grade(frame, style="premium"):
+    """Color grading per style."""
+    f = frame.astype(np.float32)
+    if style == "premium":
+        # Teal-orange grade: boost blues in shadows, warm highlights
+        f[:,:,0] = np.clip(f[:,:,0] * 1.05, 0, 255)   # R boost
+        f[:,:,2] = np.clip(f[:,:,2] * 1.08, 0, 255)   # B boost
+        f = np.clip(f * 1.05, 0, 255)                  # slight brightness
+    elif style == "energetic":
+        # Saturated vivid
+        gray = np.mean(f, axis=2, keepdims=True)
+        f = np.clip(gray + 1.4 * (f - gray), 0, 255)
+        f = np.clip(f * 1.1, 0, 255)
+    elif style == "fun":
+        # Warm, bright, punchy
+        f[:,:,0] = np.clip(f[:,:,0] * 1.1, 0, 255)   # R
+        f[:,:,1] = np.clip(f[:,:,1] * 1.05, 0, 255)  # G
+    return f.astype(np.uint8)
+
+def generate_video(pil_image: Image.Image, duration_sec: int = 5, fps: int = 24, style: str = "premium") -> str:
     """
-    Creates a cinematic 5-second video from a single image using:
-    - Ken Burns zoom-in effect
-    - Slow pan movement
-    - Brightness fade-in at start, fade-out at end
-    Pure OpenCV — generates in ~2-3 seconds, no GPU needed.
+    Cinematic 5-second video with:
+    - Segment 1 (0-1.5s): ZOOM IN burst + bounce pop
+    - Segment 2 (1.5-3s): Slow upward pan + subtle shake
+    - Segment 3 (3-4.2s): ZOOM OUT pull-back
+    - Segment 4 (4.2-5s): Fade out with color flash
+    - Vignette overlay
+    - Color grading
+    - Fade in/out
     """
-    total_frames = duration_sec * fps  # 5 * 24 = 120 frames
+    total_frames = duration_sec * fps  # 120 frames
 
-    # Resize image to 720p for good quality
     img = pil_image.convert("RGB")
-    target_w, target_h = 720, 1280   # vertical/reel format
+    target_w, target_h = 720, 1280
     img = img.resize((target_w, target_h), Image.LANCZOS)
-    frame_base = np.array(img)
 
     tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     out = cv2.VideoWriter(tmp.name, fourcc, fps, (target_w, target_h))
 
-    # Work on a larger canvas so zoom doesn't crop into black
-    pad = 80
+    # Large canvas to allow all movements without black borders
+    pad = 160
     big_h, big_w = target_h + pad * 2, target_w + pad * 2
     big_img = np.array(img.resize((big_w, big_h), Image.LANCZOS))
 
-    for i in range(total_frames):
-        t = i / (total_frames - 1)   # 0.0 → 1.0
-
-        # Zoom: start slightly zoomed in, zoom out slowly (or zoom in)
-        zoom = 1.0 + 0.08 * (1.0 - t)   # 1.08 → 1.00
+    # Segment boundaries (in frames)
+    s1_end = int(fps * 1.5)   # 36
+    s2_end = int(fps * 3.0)   # 72
+    s3_end = int(fps * 4.2)   # 100
+    s4_end = total_frames     # 120
 
-        # Pan: slow drift from center-left to center-right
-        pan_x = int(pad * 0.5 * t)
-        pan_y = int(pad * 0.3 * t)
+    for i in range(total_frames):
+        t_global = i / (total_frames - 1)
+
+        # ── SEGMENT 1: Zoom-in bounce pop (0 → 1.5s) ────────────────────────
+        if i < s1_end:
+            t = i / s1_end
+            te = ease_out_bounce(min(t * 1.1, 1.0))
+            zoom = 1.35 - 0.25 * te          # 1.35 → 1.10 with bounce
+            pan_x = int(pad * 0.1 * t)
+            pan_y = int(-pad * 0.15 * t)     # slight upward
+
+        # ── SEGMENT 2: Slow pan upward + micro shake (1.5s → 3s) ────────────
+        elif i < s2_end:
+            t = (i - s1_end) / (s2_end - s1_end)
+            te = ease_in_out(t)
+            zoom = 1.10 - 0.05 * te          # gentle zoom out
+            shake_x = int(3 * math.sin(i * 0.8))   # micro horizontal shake
+            shake_y = int(2 * math.cos(i * 1.1))
+            pan_x = int(pad * 0.1 + shake_x)
+            pan_y = int(-pad * 0.15 - pad * 0.20 * te + shake_y)
+
+        # ── SEGMENT 3: Zoom out pull-back (3s → 4.2s) ────���──────────────────
+        elif i < s3_end:
+            t = (i - s2_end) / (s3_end - s2_end)
+            te = ease_in_out(t)
+            zoom = 1.05 - 0.04 * te          # zoom out to near 1.0
+            pan_x = int(pad * 0.1 * (1 - te))
+            pan_y = int(-pad * 0.35 * (1 - te))
+
+        # ── SEGMENT 4: Final fade out (4.2s → 5s) ───────────────────────────
+        else:
+            t = (i - s3_end) / (s4_end - s3_end)
+            te = ease_in_out(t)
+            zoom = 1.01 + 0.03 * te          # subtle zoom in at end
+            pan_x = 0
+            pan_y = 0
 
+        # Crop from big canvas
         crop_w = int(target_w / zoom)
         crop_h = int(target_h / zoom)
-
         cx = big_w // 2 + pan_x
         cy = big_h // 2 + pan_y
 
@@ -134,21 +214,38 @@ def generate_video(pil_image: Image.Image, duration_sec: int = 5, fps: int = 24)
         x2 = min(big_w, x1 + crop_w)
         y2 = min(big_h, y1 + crop_h)
 
+        if x2 - x1 < 10 or y2 - y1 < 10:
+            x1, y1, x2, y2 = 0, 0, target_w, target_h
+
         cropped = big_img[y1:y2, x1:x2]
         frame = cv2.resize(cropped, (target_w, target_h), interpolation=cv2.INTER_LINEAR)
 
-        # Fade-in first 0.5s, fade-out last 0.5s
-        fade_frames = int(fps * 0.5)
-        if i < fade_frames:
-            alpha = i / fade_frames
-        elif i > total_frames - fade_frames:
-            alpha = (total_frames - i) / fade_frames
+        # ── COLOR GRADE ──────────────────────────────────────────────────────
+        frame = apply_color_grade(frame, style)
+
+        # ── VIGNETTE ─────────────────────────────────────────────────────────
+        frame = apply_vignette(frame, strength=0.55)
+
+        # ── FADE IN (first 0.4s) + FADE OUT (last 0.6s) ─────────────────────
+        fade_in_end  = int(fps * 0.4)
+        fade_out_sta = int(fps * 4.4)
+        if i < fade_in_end:
+            alpha = ease_in_out(i / fade_in_end)
+        elif i >= fade_out_sta:
+            alpha = ease_in_out(1.0 - (i - fade_out_sta) / (total_frames - fade_out_sta))
         else:
             alpha = 1.0
 
-        frame = (frame * alpha).astype(np.uint8)
+        # ── WHITE FLASH at segment transitions (frame 36, 72) ────────────────
+        flash_frames = {s1_end, s1_end+1, s2_end, s2_end+1}
+        if i in flash_frames:
+            flash_strength = 0.35 if i in {s1_end, s2_end} else 0.15
+            white = np.ones_like(frame) * 255
+            frame = cv2.addWeighted(frame, 1 - flash_strength, white.astype(np.uint8), flash_strength, 0)
 
-        # Convert RGB → BGR for OpenCV
+        frame = np.clip(frame.astype(np.float32) * alpha, 0, 255).astype(np.uint8)
+
+        # RGB → BGR for OpenCV
         frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
         out.write(frame_bgr)
 
@@ -156,6 +253,7 @@ def generate_video(pil_image: Image.Image, duration_sec: int = 5, fps: int = 24)
     return tmp.name
 
 
+
 # ── MAIN PIPELINE ─────────────────────────────────────────────────────────────
 def generate_ad(image, user_desc, language, style):
     if image is None:
@@ -175,7 +273,7 @@ def generate_ad(image, user_desc, language, style):
 
     # STEP 2 — Fast video (2-3 sec)
     try:
-        video_path = generate_video(pil_image, duration_sec=5, fps=24)
+        video_path = generate_video(pil_image, duration_sec=5, fps=24, style=style.lower())
     except Exception as e:
         return None, hook, f"❌ Video error: {e}\n\n{script}", cta