Restore original visualization resize behavior

app.py

@@ -8,8 +8,8 @@ high local complexity = roughly what the encoder would spend bits on).
 
 Pipeline (mirrors codec_tools/pipeline/process_video_bitcost_readiness.py):
     1. Uniformly sample N frames from the input video.
-    2. Resize each sampled frame to a fixed square patch grid driven by
-       `patch_size`.
+    2. smart_resize each frame so dims are multiples of `patch` and the
+       total pixel count <= max_pixels.
     3. Slice every frame into a patch grid; score each patch by its
        Sobel gradient magnitude mean.
     4. Pick the top-K highest-scoring patches under the selected GOP
@@ -22,6 +22,7 @@ Pipeline (mirrors codec_tools/pipeline/process_video_bitcost_readiness.py):
 """
 
 import json
+import math
 import os
 import shutil
 import subprocess
@@ -48,7 +49,7 @@ DEMO_PRESET = (
     DEMO_VIDEO_PATH,  # video_in
     16,               # sample_frames
     14,               # patch_size
-    3136,             # total_patches  (= 16 * 14^2)
+    1024,             # total_patches
     150000,           # max_pixels
     "sbs",            # viz_mode
     0.55,             # heatmap_alpha
@@ -63,22 +64,16 @@ DEMO_PRESET = (
 
 
 def smart_resize(frame: np.ndarray, max_pixels: int, factor: int) -> np.ndarray:
-    """Resize each frame to a square patch grid.
-
-    The demo uses `factor` as both:
-      - patch size in pixels
-      - patches per side in the resized frame
-
-    So patch_size=14 means:
-      - each patch is 14 x 14 pixels
-      - each frame is resized to 14 x 14 patches
-      - each frame therefore contributes 14^2 = 196 patch slots
-
-    `max_pixels` is kept for API compatibility with earlier revisions, but
-    the frame token count is now controlled by `factor` directly.
-    """
-    side_px = int(factor) * int(factor)
-    return cv2.resize(frame, (side_px, side_px), interpolation=cv2.INTER_AREA)
+    """Resize so h,w are multiples of `factor` and h*w <= max_pixels."""
+    h, w = frame.shape[:2]
+    pixels = h * w
+    if pixels > max_pixels:
+        scale = math.sqrt(max_pixels / pixels)
+        h = max(factor, int(h * scale))
+        w = max(factor, int(w * scale))
+    h = max(factor, (h // factor) * factor)
+    w = max(factor, (w // factor) * factor)
+    return cv2.resize(frame, (w, h), interpolation=cv2.INTER_AREA)
 
 
 def sample_frame_ids(total: int, n: int) -> List[int]:
@@ -1399,14 +1394,12 @@ with gr.Blocks(**_BLOCK_KW) as demo:
                     4, 64, value=16, step=1, label="Sampled frames",
                 )
                 top_k = gr.Slider(
-                    16, 16384, value=3136, step=16,
+                    16, 16384, value=1024, step=16,
                     label="Total patches budget (whole video)",
-                    info="Default = sample_frames x patch_size^2 "
-                    "(16 x 14^2 = 3136). The uniform baseline spends "
-                    "this budget on evenly sampled complete frames; the "
-                    "codec path spends it on saliency-selected patches. If "
-                    "budget < sample_frames x patch_size^2, the full-frame "
-                    "baseline will use fewer frames than codec.",
+                    info="The single budget shared across the whole video. "
+                    "The uniform full-frame baseline will fit as many "
+                    "complete frames as this budget allows; the codec path "
+                    "spends the same budget on saliency-selected patches.",
                 )
                 patch_size = gr.Radio(
                     PATCH_CHOICES, value=14, label="Patch size (px)",