Cap feature audio decode concurrency

osu_feature_pipeline/README.md

@@ -56,9 +56,9 @@ for its chunk. Shard writes still happen in the parent process, preserving the
 single commit boundary. The executor keeps only a bounded set of chunk futures
 in flight, so completed chunks cannot accumulate behind the writer.
 
-`--audio-workers` controls ffmpeg/audio extraction inside each active chunk.
-Audio blobs are claimed once across all workers, so shared audio is not decoded
-or written twice.
+`--audio-workers` controls ffmpeg/audio extraction across the whole process.
+It is not a per-chunk multiplier. Audio blobs are claimed
+once across all workers, so shared audio is not decoded or written twice.
 
 `--row-group-size` controls the maximum rows converted and written to Parquet
 at once. The default is `65536`. Closed shard size is still controlled by
@@ -131,6 +131,11 @@ FEATURES_PARENT="$(dirname "$FEATURES_ROOT")"
 
 rm -rf "$FEATURES_PARENT/.v1.scratch"
 rm -f "$FEATURES_PARENT/.v1.feature.lock"
+find /tmp -maxdepth 1 -type f \( \
+  -name 'tmp*mp3' -o -name 'tmp*ogg' -o -name 'tmp*wav' -o \
+  -name 'tmp*flac' -o -name 'tmp*m4a' -o -name 'tmp*aac' -o \
+  -name 'tmp*f32' \
+\) -delete
 ```
 
 Only remove the lock after `pgrep` shows no active feature job. If

osu_feature_pipeline/osu_features/audio.py

@@ -58,33 +58,36 @@ def decode_audio(audio_bytes: bytes, suffix: str, cfg: AudioConfig) -> tuple[np.
     with tempfile.NamedTemporaryFile(suffix=suffix or ".audio", delete=False) as tmp:
         tmp.write(audio_bytes)
         tmp_path = Path(tmp.name)
+    with tempfile.NamedTemporaryFile(suffix=".f32", delete=False) as raw_tmp:
+        raw_path = Path(raw_tmp.name)
     try:
-        proc = subprocess.run(
-            [
-                ffmpeg,
-                "-hide_banner",
-                "-loglevel",
-                "error",
-                "-i",
-                str(tmp_path),
-                "-f",
-                "f32le",
-                "-acodec",
-                "pcm_f32le",
-                "-ac",
-                "1",
-                "-ar",
-                str(cfg.sample_rate),
-                "-",
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            check=False,
-        )
+        with raw_path.open("wb") as raw:
+            proc = subprocess.run(
+                [
+                    ffmpeg,
+                    "-hide_banner",
+                    "-loglevel",
+                    "error",
+                    "-i",
+                    str(tmp_path),
+                    "-f",
+                    "f32le",
+                    "-acodec",
+                    "pcm_f32le",
+                    "-ac",
+                    "1",
+                    "-ar",
+                    str(cfg.sample_rate),
+                    "-",
+                ],
+                stdout=raw,
+                stderr=subprocess.PIPE,
+                check=False,
+            )
         if proc.returncode != 0:
             err = proc.stderr.decode("utf-8", "replace").strip().splitlines()
             return None, "ffmpeg_decode_failed:" + (err[-1] if err else str(proc.returncode))
-        y = np.frombuffer(proc.stdout, dtype=np.float32).copy()
+        y = np.fromfile(raw_path, dtype=np.float32)
         if y.size == 0:
             return None, "empty_audio"
         return np.nan_to_num(y, nan=0.0, posinf=0.0, neginf=0.0), "ok"
@@ -93,6 +96,10 @@ def decode_audio(audio_bytes: bytes, suffix: str, cfg: AudioConfig) -> tuple[np.
             tmp_path.unlink()
         except FileNotFoundError:
             pass
+        try:
+            raw_path.unlink()
+        except FileNotFoundError:
+            pass
 
 
 def _frame_audio(y: np.ndarray, n_fft: int, hop: int) -> np.ndarray:
@@ -298,4 +305,3 @@ def summarize_pool(rows: list[dict[str, Any]] | None, start_ms: int, end_ms: int
         "audio_onset_mean": float(np.mean([r["onset_mean"] for r in selected])),
         "audio_spectral_centroid_mean": float(np.mean([r["spectral_centroid_mean"] for r in selected])),
     }
-

osu_feature_pipeline/osu_features/builder.py

@@ -180,6 +180,7 @@ class FeatureBuilder:
         self.audio_status_cache: dict[str, str] = {}
         self.audio_pool_cache: dict[str, list[dict[str, Any]]] = {}
         self.audio_cache_blobs: set[str] = set()
+        self.audio_decode_semaphore = threading.BoundedSemaphore(max(1, config.audio_workers))
         self.audio_condition = threading.Condition()
         self.audio_progress: Any | None = None
         self.audio_status: dict[str, str] = {}
@@ -790,7 +791,8 @@ class FeatureBuilder:
 
         def run_one_safe(blob: str) -> tuple[str, dict[str, Any], list[dict[str, Any]], list[dict[str, Any]], str]:
             try:
-                return run_one(blob)
+                with self.audio_decode_semaphore:
+                    return run_one(blob)
             except Exception as exc:
                 status = f"audio_error:{type(exc).__name__}:{exc}"
                 return blob, missing_summary(blob, sources.get(blob), status), [], [], status