Upload app.py with huggingface_hub

app.py

@@ -63,8 +63,7 @@ def has_audio_stream(path: str) -> bool:
     return bool(result.stdout.strip())
 
 
-@spaces.GPU(duration=120)
-def _gpu_encode_frames(
+def _encode_frames(
     frame_bytes: list[bytes],
     timestamps: list[float],
     duration: float,
@@ -72,25 +71,22 @@ def _gpu_encode_frames(
     h: int,
 ) -> str:
     """
-    Decode PNG frames in memory, GPU-resize, encode to H.264 with PyAV.
-    Avoids writing hundreds of individual PNG files to disk.
+    Decode PNG frames in memory, encode to H.264 with PyAV (libx264).
+    No resize needed — Chrome always delivers frames at exactly w×h via
+    Emulation.setDeviceMetricsOverride + screencast maxWidth/maxHeight.
     """
     import av
     import numpy as np
-    import torch
-    import torchvision.transforms.functional as TF
     from PIL import Image
 
     t0 = time.monotonic()
-    n_in = len(frame_bytes)
-    print(f"[wr] GPU: {n_in} frames in memory, target {w}x{h} @ {TARGET_FPS}fps", flush=True)
+    print(f"[wr] encode: {len(frame_bytes)} frames → {w}x{h} @ {TARGET_FPS}fps", flush=True)
 
-    # Select frames evenly at TARGET_FPS
+    # Select frames evenly at TARGET_FPS via binary search on timestamps
     n_out = max(1, int(duration * TARGET_FPS))
     selected = []
     for i in range(n_out):
         t = i / TARGET_FPS
-        # Binary search for the closest timestamp
         lo, hi = 0, len(timestamps) - 1
         while lo < hi:
             mid = (lo + hi) // 2
@@ -99,7 +95,7 @@ def _gpu_encode_frames(
             else:
                 hi = mid
         selected.append(lo)
-    print(f"[wr] GPU: selected {len(selected)} frames", flush=True)
+    print(f"[wr] encode: selected {len(selected)} frames", flush=True)
 
     out_path = f"/tmp/main_{os.getpid()}_{int(time.time())}.mp4"
     container = av.open(out_path, "w")
@@ -109,35 +105,19 @@ def _gpu_encode_frames(
     stream.pix_fmt = "yuv420p"
     stream.options = {"crf": "15", "preset": "fast", "profile": "high", "level": "4.2"}
 
-    needs_resize = None  # determined on first frame
-
     for i, frame_idx in enumerate(selected):
-        png = frame_bytes[frame_idx]
-        img = Image.open(io.BytesIO(png)).convert("RGB")
-
-        if needs_resize is None:
-            needs_resize = img.size != (w, h)
-            print(f"[wr] GPU: source frame size {img.size}, resize={needs_resize}", flush=True)
-
-        if needs_resize:
-            t_img = TF.to_tensor(img).cuda()                     # (C, H, W) float32 on GPU
-            t_img = TF.resize(t_img, [h, w], antialias=True)     # GPU resize
-            np_frame = (t_img.permute(1, 2, 0).cpu().numpy() * 255).astype(np.uint8)
-        else:
-            np_frame = np.array(img)
-
-        av_frame = av.VideoFrame.from_ndarray(np_frame, format="rgb24")
+        img = Image.open(io.BytesIO(frame_bytes[frame_idx])).convert("RGB")
+        av_frame = av.VideoFrame.from_ndarray(np.array(img), format="rgb24")
         for pkt in stream.encode(av_frame):
             container.mux(pkt)
-
         if i % 100 == 0:
-            print(f"[wr] GPU: encoded {i}/{len(selected)} frames", flush=True)
+            print(f"[wr] encode: {i}/{len(selected)} frames", flush=True)
 
-    for pkt in stream.encode():  # flush encoder
+    for pkt in stream.encode():
         container.mux(pkt)
     container.close()
 
-    print(f"[wr] GPU: done in {time.monotonic()-t0:.1f}s → {out_path}", flush=True)
+    print(f"[wr] encode: done in {time.monotonic()-t0:.1f}s → {out_path}", flush=True)
     return out_path
 
 
@@ -466,8 +446,8 @@ async def _record_async(
     timestamps  = [f[0] for f in frames]
     frame_bytes = [f[1] for f in frames]
 
-    log(f"encoding {len(frames)} frames via GPU (PyAV/libx264, no disk I/O)...")
-    main_path = _gpu_encode_frames(frame_bytes, timestamps, float(duration), w, h)
+    log(f"encoding {len(frames)} frames (PyAV/libx264, no disk I/O)...")
+    main_path = _encode_frames(frame_bytes, timestamps, float(duration), w, h)
     log(f"main recording encoded: {main_path}")
 
     log("assembling final video (audio + segments)...")