Optimize GPU usage and fix resource leaks

- HunyuanFoley: extract visual features only per segment (reuse
text_feats from single initial extraction) — saves ~2-5s GPU/segment
- MMAudio/Hunyuan: add torch.cuda.empty_cache() between samples to
prevent VRAM fragmentation (TARO already had this)
- Regen duration floor lowered from 60s to 30s — single-segment regen
takes ~16-20s actual GPU, saving ~30s wasted ZeroGPU quota per call
- Register regen temp dirs with _register_tmp_dir for cleanup (was
leaking tmpfiles indefinitely)
- TARO: save CAVP/onset features once instead of per-sample (identical
data, depends only on video)
- Remove redundant import time in _splice_and_save

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -371,10 +371,12 @@ def _estimate_gpu_duration(model_key: str, num_samples: int, num_steps: int,
 
 
 def _estimate_regen_duration(model_key: str, num_steps: int) -> int:
-    """Generic GPU duration estimator for single-segment regen."""
+    """Generic GPU duration estimator for single-segment regen.
+    Uses a lower floor (30s) than initial generation since regen only runs
+    one segment — saves 30s of wasted ZeroGPU quota per regen call."""
     cfg  = MODEL_CONFIGS[model_key]
     secs = int(num_steps) * cfg["secs_per_step"] + cfg["load_overhead"]
-    result = min(GPU_DURATION_CAP, max(60, int(secs)))
+    result = min(GPU_DURATION_CAP, max(30, int(secs)))
     print(f"[duration] {cfg['label']} regen: 1 seg × {int(num_steps)} steps → {secs:.0f}s → capped {result}s")
     return result
 
@@ -578,6 +580,10 @@ def generate_taro(video_file, seed_val, cfg_scale, num_steps, mode,
                               crossfade_s, crossfade_db, num_samples)
 
     # ── CPU post-processing (no GPU needed) ──
+    # Cache CAVP + onset features once (same for all samples — they depend only on the video)
+    cavp_path  = os.path.join(tmp_dir, "taro_cavp.npy")
+    onset_path = os.path.join(tmp_dir, "taro_onset.npy")
+    first_cavp_saved = False
     outputs = []
     for sample_idx, (wavs, cavp_feats, onset_feats) in enumerate(results):
         final_wav  = _stitch_wavs(wavs, crossfade_s, crossfade_db, total_dur_s, TARO_SR)
@@ -586,12 +592,12 @@ def generate_taro(video_file, seed_val, cfg_scale, num_steps, mode,
         video_path = os.path.join(tmp_dir, f"taro_{sample_idx}.mp4")
         mux_video_audio(silent_video, audio_path, video_path)
         wav_paths = _save_seg_wavs(wavs, tmp_dir, f"taro_{sample_idx}")
-        # Cache CAVP + onset features so regen can skip re-extraction (~5-7s saved)
-        cavp_path  = os.path.join(tmp_dir, f"taro_{sample_idx}_cavp.npy")
-        onset_path = os.path.join(tmp_dir, f"taro_{sample_idx}_onset.npy")
-        np.save(cavp_path, cavp_feats)
-        if onset_feats is not None:
-            np.save(onset_path, onset_feats)
+        # Save shared features once (not per-sample — they're identical)
+        if not first_cavp_saved:
+            np.save(cavp_path, cavp_feats)
+            if onset_feats is not None:
+                np.save(onset_path, onset_feats)
+            first_cavp_saved = True
         seg_meta = {
             "segments":    segments,
             "wav_paths":   wav_paths,
@@ -711,6 +717,10 @@ def _mmaudio_gpu_infer(video_file, prompt, negative_prompt, seed_val,
               f"(current constant={MMAUDIO_SECS_PER_STEP})")
         results.append((seg_audios, sr))
 
+        # Free GPU memory between samples to prevent VRAM fragmentation
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
     return results
 
 _mmaudio_gpu_infer._cpu_ctx = {}
@@ -839,6 +849,10 @@ def _hunyuan_gpu_infer(video_file, prompt, negative_prompt, seed_val,
         neg_prompt=negative_prompt if negative_prompt else None,
     )
 
+    # Import visual-only feature extractor to avoid redundant text extraction
+    # per segment (text_feats already computed once above for the whole batch).
+    from hunyuanvideo_foley.utils.feature_utils import encode_video_features
+
     results = []
     for sample_idx in range(num_samples):
         seg_wavs = []
@@ -848,13 +862,8 @@ def _hunyuan_gpu_infer(video_file, prompt, negative_prompt, seed_val,
             seg_dur = seg_end - seg_start
             seg_path = seg_clip_paths[seg_i]
 
-            visual_feats, _, seg_audio_len = feature_process(
-                seg_path,
-                prompt if prompt else "",
-                model_dict,
-                cfg,
-                neg_prompt=negative_prompt if negative_prompt else None,
-            )
+            # Extract only visual features — reuse text_feats from above
+            visual_feats, seg_audio_len = encode_video_features(seg_path, model_dict)
             print(f"[HunyuanFoley] Sample {sample_idx+1} | seg {seg_i+1}/{len(segments)} "
                   f"{seg_start:.1f}–{seg_end:.1f}s → {seg_audio_len:.2f}s audio")
 
@@ -881,6 +890,10 @@ def _hunyuan_gpu_infer(video_file, prompt, negative_prompt, seed_val,
               f"(current constant={HUNYUAN_SECS_PER_STEP})")
         results.append((seg_wavs, sr, text_feats))
 
+        # Free GPU memory between samples to prevent VRAM fragmentation
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
     return results
 
 _hunyuan_gpu_infer._cpu_ctx = {}
@@ -1003,8 +1016,7 @@ def _splice_and_save(new_wav, seg_idx, meta, slot_id):
 
     # Save new audio — use a new timestamped filename so Gradio / the browser
     # treats it as a genuinely different file and reloads the video player.
-    import time as _time
-    _ts        = int(_time.time() * 1000)
+    _ts        = int(time.time() * 1000)
     tmp_dir    = os.path.dirname(meta["audio_path"])
     _base      = os.path.splitext(os.path.basename(meta["audio_path"]))[0]
     # Strip any previous timestamp suffix before adding a new one
@@ -1192,7 +1204,7 @@ def regen_mmaudio_segment(video_file, seg_idx, seg_meta_json,
 
     # CPU: pre-extract segment clip
     silent_video = meta["silent_video"]
-    tmp_dir      = tempfile.mkdtemp()
+    tmp_dir      = _register_tmp_dir(tempfile.mkdtemp())
     seg_path     = os.path.join(tmp_dir, "regen_seg.mp4")
     ffmpeg.input(silent_video, ss=seg_start, t=seg_dur).output(
         seg_path, vcodec="copy", an=None
@@ -1291,7 +1303,7 @@ def regen_hunyuan_segment(video_file, seg_idx, seg_meta_json,
 
     # CPU: pre-extract segment clip
     silent_video = meta["silent_video"]
-    tmp_dir      = tempfile.mkdtemp()
+    tmp_dir      = _register_tmp_dir(tempfile.mkdtemp())
     seg_path     = os.path.join(tmp_dir, "regen_seg.mp4")
     ffmpeg.input(silent_video, ss=seg_start, t=seg_dur).output(
         seg_path, vcodec="copy", an=None