Add video segment compression for Replicate uploads. Implemented logic to prepare segments for upload, ensuring they meet the 100 MiB file size limit. Added functionality to compress segments exceeding the limit and updated upload handling to use the prepared segments.

app/main.py

@@ -27,6 +27,9 @@ API_BASE = "https://api.replicate.com/v1"
 MODEL_PATH = "heygen/video-translate"
 
 POLL_SECONDS = 8
+# Replicate Files API rejects uploads over 100 MiB.
+REPLICATE_MAX_UPLOAD_BYTES = 95 * 1024 * 1024
+UPLOAD_AUDIO_BITRATE = 128_000
 
 
 class RunCancelledError(RuntimeError):
@@ -62,6 +65,14 @@ assert _summarize_segment_failures(
 assert _summarize_segment_failures([{"error": "network timeout"}]) == "network timeout"
 
 
+def _target_video_bitrate(duration_seconds: float, max_bytes: int, factor: float) -> int:
+    audio_bps = UPLOAD_AUDIO_BITRATE
+    return max(400_000, int((max_bytes * 8 * factor) / max(duration_seconds, 1.0) - audio_bps))
+
+
+assert 1_000_000 < _target_video_bitrate(60, REPLICATE_MAX_UPLOAD_BYTES, 0.85) < 15_000_000
+
+
 def ensure_ffmpeg() -> None:
     if shutil.which("ffmpeg") is None:
         raise RuntimeError("`ffmpeg` is not installed or not on PATH.")
@@ -366,7 +377,7 @@ class TranslationRunManager:
             self._update_segment(run_id, index, status="uploading", error=None)
             if self._is_cancelled(run_id):
                 raise RunCancelledError("Run cancelled by user.")
-            file_url = self._upload_segment(Path(segment["path"]), token)
+            file_url = self._upload_segment(self._prepare_segment_for_upload(run_id, index), token)
             self._update_segment(run_id, index, input_video_url=file_url)
 
             self._update_segment(run_id, index, status="processing")
@@ -401,6 +412,70 @@ class TranslationRunManager:
             self._update_segment(run_id, index, status="failed", error=str(exc))
             return SegmentTaskResult(index=index, status="failed", error=str(exc))
 
+    def _prepare_segment_for_upload(self, run_id: str, index: int) -> Path:
+        run = self.get_run(run_id)
+        if not run:
+            raise RuntimeError("Run missing.")
+        segment = run["segments"][index]
+        src = Path(segment["path"])
+        dest = src.with_name(f"{src.stem}_fit.mp4")
+        if dest.exists() and 0 < dest.stat().st_size <= REPLICATE_MAX_UPLOAD_BYTES:
+            return dest
+        size = src.stat().st_size
+        if size <= REPLICATE_MAX_UPLOAD_BYTES:
+            return src
+        self._log(
+            run,
+            f"[{segment['name']}] {size // (1024 * 1024)} MiB exceeds Replicate's 100 MiB file limit; compressing.",
+        )
+        self._compress_for_upload(src, dest, REPLICATE_MAX_UPLOAD_BYTES)
+        fitted = dest.stat().st_size // (1024 * 1024)
+        self._log(run, f"[{segment['name']}] compressed to {fitted} MiB.")
+        return dest
+
+    @staticmethod
+    def _compress_for_upload(src: Path, dest: Path, max_bytes: int) -> None:
+        duration = TranslationRunManager._probe_duration(src) or 60.0
+        last_size = src.stat().st_size
+        for factor in (0.85, 0.55, 0.35):
+            video_bps = _target_video_bitrate(duration, max_bytes, factor)
+            command = [
+                "ffmpeg",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-y",
+                "-i",
+                str(src),
+                "-c:v",
+                "libx264",
+                "-preset",
+                "veryfast",
+                "-b:v",
+                str(video_bps),
+                "-maxrate",
+                str(video_bps),
+                "-bufsize",
+                str(video_bps * 2),
+                "-pix_fmt",
+                "yuv420p",
+                "-c:a",
+                "aac",
+                "-b:a",
+                "128k",
+                "-movflags",
+                "+faststart",
+                str(dest),
+            ]
+            TranslationRunManager._run_cmd(command, "Compressing segment for Replicate upload failed.")
+            last_size = dest.stat().st_size
+            if last_size <= max_bytes:
+                return
+        raise RuntimeError(
+            f"Segment still too large after compress ({last_size // (1024 * 1024)} MiB). "
+            "Replicate's file limit is 100 MiB."
+        )
+
     def _upload_segment(self, file_path: Path, token: str) -> str:
         with file_path.open("rb") as handle:
             response = requests.post(