refactor: implement streaming LaMa inpainting, optimize crop aspect ratio matching, and add support for high-frame-rate video presets

app.py

@@ -381,37 +381,66 @@ def on_preview_crop(editor_value: dict | None, meta_state: dict | None, context_
 
 
 @spaces.GPU(duration=180)
-def _inpaint_frames_gpu(
+def _inpaint_composite_save_gpu(
     frame_paths: list,
     crop_region: CropRegion,
     inpaint_mask: np.ndarray,
+    out_dir,
     mode: str,
     total: int,
     progress,
-) -> list:
+) -> None:
     """
-    GPU-accelerated inpainting step.
-
-    This is the *only* function that holds the ZeroGPU allocation.
-    Frame extraction, compositing, and video encoding are all CPU-only and
-    run outside this function to avoid burning GPU quota on I/O work.
+    GPU-accelerated inpainting with immediate per-frame compositing and disk save.
+
+    Architecture
+    ------------
+    - The feathered alpha map is pre-computed **once** (static mask for the whole
+      video) so the Gaussian blur runs exactly once instead of once per frame.
+    - For LaMa (per-frame independent model): streams one frame at a time —
+      never holds more than one inpainted crop in RAM.
+    - For VACE (temporal model): must process the full sequence at once for
+      temporal coherence, then composites and saves frame-by-frame.
+    - Saves composited PNGs directly to *out_dir* so the caller never holds
+      the full crop list in memory.
     """
+    from pipeline.composite import composite_with_alpha, feathered_alpha
+
+    alpha = feathered_alpha(inpaint_mask)   # pre-compute once (static mask)
+    out_dir = Path(out_dir)
+
     if mode == "Fast (LaMa)":
-        from pipeline.lama import inpaint_frames_lama
+        from pipeline.lama import inpaint_frames_lama_stream
 
-        def _lama_progress(i: int) -> None:
+        def _prog(i: int) -> None:
             progress(
-                0.20 + 0.70 * ((i + 1) / total),
-                desc=f"LaMa frame {i + 1}/{total}…",
+                0.20 + 0.65 * ((i + 1) / total),
+                desc=f"LaMa {i + 1}/{total}…",
             )
 
-        return inpaint_frames_lama(
-            frame_paths, crop_region, inpaint_mask, progress_fn=_lama_progress
-        )
-    else:  # Quality (VACE)
+        for i, (fp, crop) in enumerate(
+            zip(
+                frame_paths,
+                inpaint_frames_lama_stream(
+                    frame_paths, crop_region, inpaint_mask, _prog
+                ),
+            )
+        ):
+            original = np.array(Image.open(fp).convert("RGB"))
+            composited = composite_with_alpha(original, crop, crop_region, alpha)
+            Image.fromarray(composited).save(out_dir / f"{i + 1:06d}.png")
+
+    else:  # Quality (VACE) — temporal model requires the full frame sequence
         from pipeline.vace import inpaint_frames_vace
-        progress(0.5, desc="Running VACE-14B…")
-        return inpaint_frames_vace(frame_paths, crop_region, inpaint_mask)
+
+        progress(0.45, desc="Running VACE-14B…")
+        crops = inpaint_frames_vace(frame_paths, crop_region, inpaint_mask)
+
+        progress(0.85, desc="Compositing…")
+        for i, (fp, crop) in enumerate(zip(frame_paths, crops)):
+            original = np.array(Image.open(fp).convert("RGB"))
+            composited = composite_with_alpha(original, crop, crop_region, alpha)
+            Image.fromarray(composited).save(out_dir / f"{i + 1:06d}.png")
 
 
 def run_pipeline(
@@ -425,9 +454,9 @@ def run_pipeline(
     """
     Pipeline orchestrator — CPU work only.
 
-    GPU allocation is acquired and released inside _inpaint_frames_gpu; the
-    rest of the pipeline (frame extraction, compositing, encoding) is pure
-    CPU/disk I/O and does not consume GPU quota.
+    GPU allocation is acquired and released inside _inpaint_composite_save_gpu.
+    Frame extraction, and video encoding/muxing are pure CPU/disk I/O and do
+    not consume GPU quota.
     """
     if video_path is None:
         raise gr.Error("Upload a video first.")
@@ -460,22 +489,14 @@ def run_pipeline(
         frame_paths = extract_frames(safe_video, ws.frames_dir, fps=meta.fps)
         total = len(frame_paths)
 
-        # ── GPU: inpainting only ───────────────────────────────────
+        # ── GPU: inpaint + composite + save ────────────────────────────
         progress(0.15, desc="Starting inpainting…")
-        inpainted_crops = _inpaint_frames_gpu(
-            frame_paths, crop_region, inpaint_mask, mode, total, progress
+        _inpaint_composite_save_gpu(
+            frame_paths, crop_region, inpaint_mask,
+            ws.out_frames_dir, mode, total, progress,
         )
 
-        # ── CPU: composite ──────────────────────────────────────────
-        progress(0.90, desc="Compositing frames…")
-        from pipeline.composite import composite_frame
-
-        for i, (fp, crop) in enumerate(zip(frame_paths, inpainted_crops)):
-            original = np.array(Image.open(fp).convert("RGB"))
-            composited = composite_frame(original, crop, crop_region, inpaint_mask)
-            Image.fromarray(composited).save(ws.out_frames_dir / f"{i+1:06d}.png")
-
-        # ── CPU: encode + mux ───────────────────────────────────────
+        # ── CPU: encode + mux ───────────────────────────────────────────
         progress(0.95, desc="Encoding video…")
         silent_path = ws.path("silent.mp4")
         frames_to_video(ws.out_frames_dir, silent_path, meta)
@@ -490,7 +511,7 @@ def run_pipeline(
             except OSError:
                 pass
             raise
-        # ws (frames, composited pngs, silent.mp4) cleaned up here
+        # ws cleaned up here by context manager
 
     progress(1.0, desc="Done!")
     return final_path, f"✓ Done — {total} frames processed ({mode})"

pipeline/composite.py

@@ -4,20 +4,21 @@ pipeline/composite.py
 Feathered alpha compositing: paste an inpainted crop back into the
 original full frame.
 
-The feather/blend zone creates a smooth transition along the crop border,
-avoiding hard edge seams. Only pixels inside the inpaint mask are replaced;
-the rest of the crop (the "context" ring) is discarded.
+Public API
+----------
+- feathered_alpha(mask, radius)              — convert mask → float alpha (call once)
+- composite_with_alpha(orig, crop, cr, alpha) — blend with a pre-computed alpha
+- composite_frame(orig, crop, cr, mask)      — convenience: alpha + blend in one call
+- composite_frames(paths, crops, cr, mask)   — batch; pre-computes alpha once
 
 Design
 ------
 Two-stage blend:
-  1. Mask feathering: the inpaint mask is Gaussian-blurred to create a
-     soft alpha ramp around the watermark boundary. This blends between
-     the inpainted content and the original frame within the crop.
-  2. Crop-border feathering (optional, default off): a second linear ramp
-     from the crop border inward, so the context ring blends too. Usually
-     not needed because context pixels in the crop are identical to the
-     original frame anyway (LaMa / VACE don't alter them much).
+  1. Mask feathering: the inpaint mask is Gaussian-blurred to create a soft alpha
+     ramp around the watermark boundary, blending inpainted ↔ original content.
+  2. Crop-border feathering (optional, default off): a linear ramp from the crop
+     border inward. Usually unnecessary because context pixels in the crop are
+     identical to the original frame.
 
 All operations are pure NumPy + PIL — no cv2 required.
 """
@@ -25,194 +26,187 @@ All operations are pure NumPy + PIL — no cv2 required.
 from __future__ import annotations
 
 import numpy as np
-from PIL import Image, ImageFilter
+from PIL import Image
 
 from pipeline.crop import CropRegion
 
 
-def composite_frame(
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def feathered_alpha(mask: np.ndarray, radius: int = 8) -> np.ndarray:
+    """
+    Convert a uint8 binary mask (0/255) to a float32 alpha map (0.0–1.0)
+    with a Gaussian-blurred soft edge.
+
+    **Call this once per unique mask** and pass the result to
+    :func:`composite_with_alpha` to avoid recomputing the Gaussian blur
+    on every frame (the mask is static for the whole video).
+
+    Parameters
+    ----------
+    mask : np.ndarray
+        Crop-local binary mask (H × W, uint8). 255 = inpaint, 0 = keep.
+    radius : int
+        Gaussian blur radius. 0 = hard composite (no feathering).
+
+    Returns
+    -------
+    np.ndarray
+        Float32 alpha map (H × W), values in [0.0, 1.0].
+    """
+    alpha_f = mask.astype(np.float32) / 255.0
+
+    if radius > 0:
+        # scipy gaussian_filter on float32 — avoids the 8-level staircase that
+        # uint8 Gaussian quantisation would produce over the feather ramp.
+        # sigma: radius ≈ 3σ is the standard Gaussian convention.
+        from scipy.ndimage import gaussian_filter
+        sigma = max(radius / 3.0, 0.5)
+        alpha_f = gaussian_filter(alpha_f, sigma=sigma)
+        alpha_f = np.clip(alpha_f, 0.0, 1.0)
+
+    return alpha_f
+
+
+def composite_with_alpha(
     original: np.ndarray,
     inpainted_crop: np.ndarray,
     crop_region: CropRegion,
-    inpaint_mask: np.ndarray,
-    feather_radius: int = 8,
+    alpha: np.ndarray,
 ) -> np.ndarray:
     """
-    Blend an inpainted crop back into the original full frame.
+    Blend *inpainted_crop* into *original* using a pre-computed *alpha* map.
 
     Parameters
     ----------
     original : np.ndarray
-        Full-frame image (H x W x 3, uint8 RGB). Modified in-place
-        on a copy — caller's array is not mutated.
+        Full-frame image (H × W × 3, uint8 RGB). Not mutated.
     inpainted_crop : np.ndarray
-        Inpainted crop image (crop_h x crop_w x 3, uint8 RGB).
-        Must match crop_region dimensions exactly.
+        Inpainted crop (crop_h × crop_w × 3, uint8 RGB).
     crop_region : CropRegion
         Defines where the crop sits in the full frame.
-    inpaint_mask : np.ndarray
-        Crop-local binary mask (crop_h x crop_w, uint8). 255=inpaint, 0=keep.
-        Same mask that was passed to the inpainting model.
-    feather_radius : int
-        Gaussian blur radius applied to the mask before blending.
-        Larger values = softer transition.
-        Set to 0 to disable feathering (hard composite).
+    alpha : np.ndarray
+        Float32 alpha map (crop_h × crop_w), pre-computed by
+        :func:`feathered_alpha`.
 
     Returns
     -------
     np.ndarray
-        Full-frame output (H x W x 3, uint8 RGB) with watermark removed.
+        Full-frame output (H × W × 3, uint8 RGB).
     """
     cr = crop_region
     result = original.copy()
 
-    # Sanity check dimensions
-    expected_h, expected_w = cr.frame_h, cr.frame_w
-    actual_h, actual_w = inpainted_crop.shape[:2]
-    if (actual_h, actual_w) != (expected_h, expected_w):
-        # Resize inpainted crop to match crop region (handles VACE resize case)
-        inpainted_crop = np.array(
-            Image.fromarray(inpainted_crop).resize(
-                (expected_w, expected_h), Image.LANCZOS
-            )
-        )
+    inpainted_crop = _resize_crop_if_needed(inpainted_crop, cr)
 
-    # ------------------------------------------------------------------
-    # Build the blend alpha from the inpaint mask
-    # ------------------------------------------------------------------
-    alpha = _feathered_alpha(inpaint_mask, feather_radius)  # float32, 0..1
-
-    # ------------------------------------------------------------------
-    # Composite: result = alpha * inpainted + (1 - alpha) * original_crop
-    # ------------------------------------------------------------------
     original_crop = result[
         cr.frame_y : cr.frame_y + cr.frame_h,
         cr.frame_x : cr.frame_x + cr.frame_w,
     ].astype(np.float32)
 
-    inpainted_f = inpainted_crop.astype(np.float32)
     alpha_3 = alpha[:, :, np.newaxis]   # broadcast over RGB channels
-
-    blended = alpha_3 * inpainted_f + (1.0 - alpha_3) * original_crop
-    blended_uint8 = np.clip(blended, 0, 255).astype(np.uint8)
-
+    blended = alpha_3 * inpainted_crop.astype(np.float32) + (1.0 - alpha_3) * original_crop
     result[
         cr.frame_y : cr.frame_y + cr.frame_h,
         cr.frame_x : cr.frame_x + cr.frame_w,
-    ] = blended_uint8
+    ] = np.clip(blended, 0, 255).astype(np.uint8)
 
     return result
 
 
-def composite_frames(
-    original_frame_paths,
-    inpainted_crops: list[np.ndarray],
+def composite_frame(
+    original: np.ndarray,
+    inpainted_crop: np.ndarray,
     crop_region: CropRegion,
     inpaint_mask: np.ndarray,
     feather_radius: int = 8,
-) -> list[np.ndarray]:
+) -> np.ndarray:
     """
-    Batch version: composite a list of inpainted crops onto their
-    corresponding original frames.
+    Blend an inpainted crop back into the original full frame.
+
+    Convenience wrapper that computes the feathered alpha internally.
+    When processing many frames with the same mask, prefer calling
+    :func:`feathered_alpha` once and :func:`composite_with_alpha` per frame
+    to avoid recomputing the Gaussian blur 450 times.
 
     Parameters
     ----------
-    original_frame_paths : List[Path]
-        Full-frame PNG paths (same order as inpainted_crops).
-    inpainted_crops : List[np.ndarray]
-        One inpainted crop per frame.
+    original : np.ndarray
+        Full-frame image (H × W × 3, uint8 RGB). Not mutated.
+    inpainted_crop : np.ndarray
+        Inpainted crop (crop_h × crop_w × 3, uint8 RGB).
     crop_region : CropRegion
     inpaint_mask : np.ndarray
-        Shared mask (same for all frames — watermark is static).
+        Crop-local binary mask (crop_h × crop_w, uint8). 255=inpaint, 0=keep.
     feather_radius : int
+        Gaussian blur radius. 0 = hard composite.
 
     Returns
     -------
-    List[np.ndarray]
-        Full-frame composited images (uint8 RGB), one per input frame.
+    np.ndarray
+        Full-frame output (H × W × 3, uint8 RGB).
     """
-    # Pre-compute feathered alpha once (shared mask)
-    alpha = _feathered_alpha(inpaint_mask, feather_radius)
-
-    composited: list[np.ndarray] = []
-    for frame_path, crop in zip(original_frame_paths, inpainted_crops):
-        original = np.array(Image.open(frame_path).convert("RGB"))
-        frame_out = _composite_with_alpha(original, crop, crop_region, alpha)
-        composited.append(frame_out)
-
-    return composited
+    alpha = feathered_alpha(inpaint_mask, feather_radius)
+    return composite_with_alpha(original, inpainted_crop, crop_region, alpha)
 
 
-# ---------------------------------------------------------------------------
-# Private helpers
-# ---------------------------------------------------------------------------
-
-def _feathered_alpha(mask: np.ndarray, radius: int) -> np.ndarray:
+def composite_frames(
+    original_frame_paths,
+    inpainted_crops: list[np.ndarray],
+    crop_region: CropRegion,
+    inpaint_mask: np.ndarray,
+    feather_radius: int = 8,
+) -> list[np.ndarray]:
     """
-    Convert a uint8 binary mask (0/255) to a float32 alpha map (0..1)
-    with a Gaussian-blurred soft edge.
+    Batch composite: pre-computes the feathered alpha *once*, then composites
+    each (frame, crop) pair.
+
+    Note: returns all composited frames in memory simultaneously. For large
+    clips prefer iterating with :func:`feathered_alpha` + :func:`composite_with_alpha`
+    and saving each result immediately.
 
     Parameters
     ----------
-    mask : np.ndarray
-        Crop-local binary mask (H x W, uint8).
-    radius : int
-        Gaussian blur radius. 0 = hard composite.
+    original_frame_paths : list[Path]
+        Full-frame PNG paths (same order as inpainted_crops).
+    inpainted_crops : list[np.ndarray]
+        One inpainted crop per frame.
+    crop_region : CropRegion
+    inpaint_mask : np.ndarray
+        Shared mask (static watermark — same for all frames).
+    feather_radius : int
 
     Returns
     -------
-    np.ndarray
-        Float32 alpha map (H x W), values in [0.0, 1.0].
+    list[np.ndarray]
+        Composited full-frame images (uint8 RGB), one per input frame.
     """
-    alpha_f = mask.astype(np.float32) / 255.0
-
-    if radius > 0:
-        # Use scipy gaussian_filter on float32 directly — avoids uint8 quantisation
-        # that would staircase the feather ramp over 8 discrete levels.
-        # sigma: radius ≈ 3σ is the standard Gaussian convention.
-        from scipy.ndimage import gaussian_filter
-        sigma = max(radius / 3.0, 0.5)
-        alpha_f = gaussian_filter(alpha_f, sigma=sigma)
-        alpha_f = np.clip(alpha_f, 0.0, 1.0)
+    alpha = feathered_alpha(inpaint_mask, feather_radius)
+    return [
+        composite_with_alpha(
+            np.array(Image.open(fp).convert("RGB")), crop, crop_region, alpha
+        )
+        for fp, crop in zip(original_frame_paths, inpainted_crops)
+    ]
 
-    return alpha_f
 
+# ---------------------------------------------------------------------------
+# Private helpers
+# ---------------------------------------------------------------------------
 
-def _composite_with_alpha(
-    original: np.ndarray,
+def _resize_crop_if_needed(
     inpainted_crop: np.ndarray,
-    crop_region: CropRegion,
-    alpha: np.ndarray,
+    cr: CropRegion,
 ) -> np.ndarray:
-    """
-    Internal composite given a pre-computed alpha map.
-    Returns a copy of original with the crop region blended in.
-    """
-    cr = crop_region
-    result = original.copy()
-
-    # Resize crop if needed (e.g. VACE returned a different resolution)
+    """Resize *inpainted_crop* to match *cr* dimensions if they differ."""
     expected_h, expected_w = cr.frame_h, cr.frame_w
     actual_h, actual_w = inpainted_crop.shape[:2]
     if (actual_h, actual_w) != (expected_h, expected_w):
-        inpainted_crop = np.array(
+        return np.array(
             Image.fromarray(inpainted_crop).resize(
                 (expected_w, expected_h), Image.LANCZOS
             )
         )
-
-    original_crop = result[
-        cr.frame_y : cr.frame_y + cr.frame_h,
-        cr.frame_x : cr.frame_x + cr.frame_w,
-    ].astype(np.float32)
-
-    alpha_3 = alpha[:, :, np.newaxis]
-    blended = alpha_3 * inpainted_crop.astype(np.float32) + (1.0 - alpha_3) * original_crop
-    blended_uint8 = np.clip(blended, 0, 255).astype(np.uint8)
-
-    result[
-        cr.frame_y : cr.frame_y + cr.frame_h,
-        cr.frame_x : cr.frame_x + cr.frame_w,
-    ] = blended_uint8
-
-    return result
+    return inpainted_crop

pipeline/crop.py

@@ -224,19 +224,30 @@ def find_target_resolution(
     (target_w, target_h) : Tuple[int, int]
         VACE resolution to use. Always >= (required_w, required_h).
     """
-    # VACE_RESOLUTIONS is sorted ascending by area; the first entry that
-    # satisfies both constraints is therefore the minimum-area fit.
-    best = next(
-        ((w, h) for (w, h) in VACE_RESOLUTIONS if w >= required_w and h >= required_h),
-        None,
-    )
-    if best is not None:
-        return best
+    # VACE_RESOLUTIONS is sorted ascending by area.  The first entry satisfying
+    # both constraints is minimum-area by construction.  When multiple entries
+    # share that minimum area (e.g. 512×768 and 768×512 have identical pixel
+    # counts), break the tie by preferring the one whose aspect ratio is closest
+    # to required_w / required_h — prevents a landscape canvas for a portrait crop.
+    fitting = [
+        (w, h) for (w, h) in VACE_RESOLUTIONS
+        if w >= required_w and h >= required_h
+    ]
+    if not fitting:
+        # Fallback: round up to nearest multiple of 32
+        return (
+            _ceil_to_multiple(required_w, 32),
+            _ceil_to_multiple(required_h, 32),
+        )
+
+    min_area = fitting[0][0] * fitting[0][1]
+    candidates = [(w, h) for (w, h) in fitting if w * h == min_area]
+
+    if len(candidates) == 1:
+        return candidates[0]
 
-    # Fallback: round up to nearest multiple of 32
-    fallback_w = _ceil_to_multiple(required_w, 32)
-    fallback_h = _ceil_to_multiple(required_h, 32)
-    return (fallback_w, fallback_h)
+    target_ratio = required_w / required_h
+    return min(candidates, key=lambda wh: abs(wh[0] / wh[1] - target_ratio))
 
 
 def compute_crop_region(

pipeline/lama.py

@@ -12,13 +12,18 @@ Pipeline for each frame:
   2. Run LaMa on the crop with the dilated inpaint mask.
   3. Return the inpainted crop; compositing is handled by composite.py.
 
+Public API
+----------
+- inpaint_frames_lama_stream — generator: one crop at a time (memory-efficient)
+- inpaint_frames_lama        — list version (convenience wrapper around the above)
+
 License: LaMa is Apache 2.0.
 """
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import List
+from typing import Generator, List
 
 import numpy as np
 from PIL import Image
@@ -30,8 +35,9 @@ from pipeline.crop import CropRegion
 # Model singleton
 # ---------------------------------------------------------------------------
 # Loaded lazily on first call; shared across all frames in a run.
-# Tracks the device it was loaded on — reloads if GPU becomes available
-# after a cold CPU-only initialisation (ZeroGPU warm/cold start handling).
+# Tracks the device it was loaded on — reloads only when upgrading from CPU
+# to GPU (ZeroGPU warm/cold start handling). Never reloads on cuda→cpu
+# because the process stays alive and the weights remain valid.
 _lama_model = None
 _lama_device: str | None = None
 
@@ -41,10 +47,6 @@ def _get_model():
     import torch
     current_device = "cuda" if torch.cuda.is_available() else "cpu"
     # One-way latch: only reload when *upgrading* from CPU to GPU.
-    # After the @spaces.GPU call ends the process returns to CPU, but we keep
-    # the model reference — it will be valid again on the next GPU allocation.
-    # Reloading on every cpu→cuda transition (once per cold start) is correct;
-    # reloading on cuda→cpu would double the startup cost for no benefit.
     if _lama_model is None or (current_device == "cuda" and _lama_device != "cuda"):
         from simple_lama_inpainting import SimpleLama  # type: ignore
         _lama_model = SimpleLama()
@@ -56,75 +58,76 @@ def _get_model():
 # Public API
 # ---------------------------------------------------------------------------
 
-def inpaint_frames_lama(
+def inpaint_frames_lama_stream(
     frame_paths: List[Path],
     crop_region: CropRegion,
     inpaint_mask: np.ndarray,
     progress_fn=None,
-) -> List[np.ndarray]:
+) -> Generator[np.ndarray, None, None]:
     """
-    Run LaMa inpainting on the crop region of each frame.
+    Streaming LaMa inpainting: yields one inpainted crop per frame.
+
+    Memory-efficient — never holds more than one crop in RAM at a time.
+    Use this when compositing and saving happen immediately after each yield
+    (e.g. in the GPU pipeline loop).
 
     Parameters
     ----------
     frame_paths : List[Path]
         Ordered list of full-frame PNG paths.
     crop_region : CropRegion
-        Defines the rectangle to extract from each frame.
     inpaint_mask : np.ndarray
-        Crop-local binary mask (H x W, uint8). 255=inpaint, 0=keep.
-        Must match crop_region dimensions.
+        Crop-local binary mask (H × W, uint8). 255 = inpaint, 0 = keep.
     progress_fn : callable, optional
-        Called as ``progress_fn(i)`` after each frame where i is the
-        0-based frame index. Use for Gradio progress reporting.
+        Called as ``progress_fn(i)`` (0-based frame index) after each frame.
 
-    Returns
-    -------
-    List[np.ndarray]
-        List of inpainted crop images (H x W x 3, uint8 RGB),
-        one per input frame. Full-frame compositing is done in composite.py.
+    Yields
+    ------
+    np.ndarray
+        Inpainted crop (crop_h × crop_w × 3, uint8 RGB).
     """
     model = _get_model()
-    # Create mask PIL image once — it is identical for every frame
+    # Build the mask PIL image once — identical for every frame.
     mask_pil = _mask_to_pil(inpaint_mask)
-    results: List[np.ndarray] = []
 
     for i, frame_path in enumerate(frame_paths):
         crop_np = _load_crop(frame_path, crop_region)
-        crop_pil = Image.fromarray(crop_np)
-
-        # simple-lama-inpainting expects (image: PIL.Image, mask: PIL.Image)
-        # mask must be mode "L": 255=inpaint, 0=keep
-        inpainted_pil: Image.Image = model(crop_pil, mask_pil)
-        results.append(np.array(inpainted_pil.convert("RGB")))
-
+        inpainted_pil: Image.Image = model(Image.fromarray(crop_np), mask_pil)
         if progress_fn is not None:
             progress_fn(i)
-
-    return results
+        yield np.array(inpainted_pil.convert("RGB"))
 
 
-def inpaint_image_lama(
-    image: np.ndarray,
+def inpaint_frames_lama(
+    frame_paths: List[Path],
     crop_region: CropRegion,
     inpaint_mask: np.ndarray,
-) -> np.ndarray:
+    progress_fn=None,
+) -> List[np.ndarray]:
     """
-    Run LaMa on a single already-loaded image array (H x W x 3 uint8 RGB).
-    Convenience wrapper used by the preview step in app.py.
+    Run LaMa inpainting on all frames and return a list of inpainted crops.
 
-    Returns the inpainted crop (crop_region dimensions, RGB uint8).
-    """
-    model = _get_model()
-    mask_pil = _mask_to_pil(inpaint_mask)
+    Convenience wrapper around :func:`inpaint_frames_lama_stream` that
+    materialises the full list. Prefer the streaming version when compositing
+    immediately to avoid holding all crops in RAM simultaneously.
 
-    cr = crop_region
-    crop_np = image[
-        cr.frame_y : cr.frame_y + cr.frame_h,
-        cr.frame_x : cr.frame_x + cr.frame_w,
-    ]
-    inpainted_pil: Image.Image = model(Image.fromarray(crop_np), mask_pil)
-    return np.array(inpainted_pil.convert("RGB"))
+    Parameters
+    ----------
+    frame_paths : List[Path]
+    crop_region : CropRegion
+    inpaint_mask : np.ndarray
+        Crop-local binary mask (H × W, uint8). 255 = inpaint, 0 = keep.
+    progress_fn : callable, optional
+        Called as ``progress_fn(i)`` after each frame.
+
+    Returns
+    -------
+    List[np.ndarray]
+        Inpainted crop images (crop_h × crop_w × 3, uint8 RGB), one per frame.
+    """
+    return list(
+        inpaint_frames_lama_stream(frame_paths, crop_region, inpaint_mask, progress_fn)
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -135,7 +138,7 @@ def _load_crop(frame_path: Path, crop_region: CropRegion) -> np.ndarray:
     """Load a frame and return only the crop region (RGB uint8)."""
     img = Image.open(frame_path).convert("RGB")
     cr = crop_region
-    # PIL box is (left, upper, right, lower)
+    # PIL box is (left, upper, right, lower) — exclusive right/lower
     box = (
         cr.frame_x,
         cr.frame_y,

pipeline/video.py

@@ -417,9 +417,11 @@ def _fps_str(fps: float) -> str:
     """Convert fps float to a clean string for FFmpeg -framerate."""
     # Keep common exact fractions (24000/1001, 30000/1001, etc.)
     common = {
-        23.976: "24000/1001",
-        29.97: "30000/1001",
-        59.94: "60000/1001",
+        23.976:  "24000/1001",
+        29.97:   "30000/1001",
+        47.952:  "48000/1001",   # 48p NTSC
+        59.94:   "60000/1001",
+        119.88:  "120000/1001",  # 120p (S1II high-frame-rate mode)
     }
     for approx, s in common.items():
         if abs(fps - approx) < 0.01:

requirements.txt

@@ -2,6 +2,9 @@
 # Pinned ranges are intentionally loose so HF's resolver can pick compatible versions.
 
 # ── Core ──────────────────────────────────────────────────────────────────
+# Keep <5.0.0: Gradio 5 changed the ImageEditor layer format in a breaking way
+# (_get_mask_from_editor relies on layers[*] being RGBA numpy arrays).
+# Revisit once the new API is stable and _get_mask_from_editor is updated.
 gradio>=4.44.0,<5.0.0
 numpy>=1.24.0
 Pillow>=10.0.0