Unify all models to 48kHz; remove all FlashSR traces

- Rename _apply_flashsr → _upsample_taro (TARO 16kHz→48kHz sinc)
- Add _resample_to_target helper (any SR → TARGET_SR=48000, sinc, CPU)
- Add TARGET_SR=48000 constant as single source of truth
- MMAudio (44100Hz): resample in generate_mmaudio and
regen_mmaudio_segment post-processing → all outputs now 48kHz
- HunyuanFoley already native 48kHz — no change needed
- Update MODEL_CONFIGS mmaudio sr: 44100 → 48000
- Console logs confirm upsample ratios and output durations
- Remove FLASHSR_SR_IN/FLASHSR_SR_OUT, zero FlashSR references remain

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

app.py

@@ -367,7 +367,7 @@ MODEL_CONFIGS = {
     },
     "mmaudio": {
         "window_s":       MMAUDIO_WINDOW,        # 8.0 s
-        "sr":             44100,
+        "sr":             48000,   # resampled to 48kHz in post-processing
         "secs_per_step":  MMAUDIO_SECS_PER_STEP, # 0.25
         "load_overhead":  MMAUDIO_LOAD_OVERHEAD,  # 15
         "tab_prefix":     "mma",
@@ -499,30 +499,46 @@ def _taro_infer_segment(
 
 
 # ================================================================== #
-#                         FlashSR (16 → 48 kHz)                       #
+#                     TARO 16 kHz → 48 kHz upsample                   #
 # ================================================================== #
-# FlashSR is used as a post-processing step on TARO outputs only.
-# TARO generates at 16 kHz; FlashSR upsamples to 48 kHz so all three
-# models produce output at the same sample rate.
-# Model weights are downloaded once from HF Hub and cached on disk.
+# TARO generates at 16 kHz; all other models output at 44.1/48 kHz.
+# We upsample via sinc resampling (torchaudio, CPU-only) so the final
+# stitched audio is uniformly at 48 kHz across all three models.
 
-FLASHSR_SR_IN  = 16000
-FLASHSR_SR_OUT = 48000
+TARGET_SR   = 48000   # unified output sample rate for all three models
+TARO_SR_OUT = TARGET_SR
 
 
-def _apply_flashsr(wav_16k: np.ndarray) -> np.ndarray:
-    """Upsample a mono 16 kHz numpy array to 48 kHz using sinc resampling (CPU).
+def _resample_to_target(wav: np.ndarray, src_sr: int) -> np.ndarray:
+    """Resample *wav* (mono or stereo numpy float32) from src_sr to TARGET_SR (48kHz).
 
-    FlashSR was attempted but its dependencies trigger torch.cuda.is_available()
-    on import, which violates ZeroGPU's stateless-GPU rule and aborts subsequent
-    GPU tasks. High-quality sinc resampling via torchaudio is ZeroGPU-safe and
-    produces clean 16→48 kHz output for foley/ambient audio.
+    No-op if src_sr already equals TARGET_SR. Uses torchaudio Kaiser-windowed
+    sinc resampling — CPU-only, ZeroGPU-safe.
     """
-    print(f"[upsample] {len(wav_16k)/FLASHSR_SR_IN:.2f}s @ 16kHz → 48kHz (sinc, CPU) …")
-    t = torch.from_numpy(wav_16k.astype(np.float32)).unsqueeze(0)
-    out = torchaudio.functional.resample(t, FLASHSR_SR_IN, FLASHSR_SR_OUT)
-    result = out.squeeze().numpy()
-    print(f"[upsample] Done — {len(result)/FLASHSR_SR_OUT:.2f}s @ {FLASHSR_SR_OUT}Hz")
+    if src_sr == TARGET_SR:
+        return wav
+    stereo = wav.ndim == 2
+    t = torch.from_numpy(np.ascontiguousarray(wav.astype(np.float32)))
+    if not stereo:
+        t = t.unsqueeze(0)          # [1, T]
+    t = torchaudio.functional.resample(t, src_sr, TARGET_SR)
+    if not stereo:
+        t = t.squeeze(0)            # [T]
+    return t.numpy()
+
+
+def _upsample_taro(wav_16k: np.ndarray) -> np.ndarray:
+    """Upsample a mono 16 kHz numpy array to 48 kHz via sinc resampling (CPU).
+
+    torchaudio.functional.resample uses a Kaiser-windowed sinc filter —
+    mathematically optimal for bandlimited signals, zero CUDA risk.
+    Returns a mono float32 numpy array at 48 kHz.
+    """
+    dur_in = len(wav_16k) / TARO_SR
+    print(f"[TARO upsample] {dur_in:.2f}s @ {TARO_SR}Hz → {TARGET_SR}Hz (sinc, CPU) …")
+    result = _resample_to_target(wav_16k, TARO_SR)
+    print(f"[TARO upsample] done — {len(result)/TARGET_SR:.2f}s @ {TARGET_SR}Hz "
+          f"(expected {dur_in * 3:.2f}s, ratio 3×)")
     return result
 
 
@@ -699,11 +715,11 @@ def generate_taro(video_file, seed_val, cfg_scale, num_steps, mode,
     first_cavp_saved = False
     outputs = []
     for sample_idx, (wavs, cavp_feats, onset_feats) in enumerate(results):
-        # FlashSR: upsample each segment 16kHz → 48kHz (CPU-only, no GPU needed)
-        wavs = [_apply_flashsr(w) for w in wavs]
-        final_wav  = _stitch_wavs(wavs, crossfade_s, crossfade_db, total_dur_s, FLASHSR_SR_OUT)
+        # Upsample each segment 16kHz → 48kHz (sinc, CPU)
+        wavs = [_upsample_taro(w) for w in wavs]
+        final_wav  = _stitch_wavs(wavs, crossfade_s, crossfade_db, total_dur_s, TARO_SR_OUT)
         audio_path = os.path.join(tmp_dir, f"taro_{sample_idx}.wav")
-        _save_wav(audio_path, final_wav, FLASHSR_SR_OUT)
+        _save_wav(audio_path, final_wav, TARO_SR_OUT)
         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}")
@@ -715,7 +731,7 @@ def generate_taro(video_file, seed_val, cfg_scale, num_steps, mode,
             first_cavp_saved = True
         seg_meta = _build_seg_meta(
             segments=segments, wav_paths=wav_paths, audio_path=audio_path,
-            video_path=video_path, silent_video=silent_video, sr=FLASHSR_SR_OUT,
+            video_path=video_path, silent_video=silent_video, sr=TARO_SR_OUT,
             model="taro", crossfade_s=crossfade_s, crossfade_db=crossfade_db,
             total_dur_s=total_dur_s, cavp_path=cavp_path, onset_path=onset_path,
         )
@@ -854,6 +870,12 @@ def generate_mmaudio(video_file, prompt, negative_prompt, seed_val,
     # ── CPU post-processing ──
     outputs = []
     for sample_idx, (seg_audios, sr) in enumerate(results):
+        # Resample 44100 → 48000 Hz so all three models share the same output SR
+        if sr != TARGET_SR:
+            print(f"[MMAudio upsample] resampling {sr}Hz → {TARGET_SR}Hz (sinc, CPU) …")
+            seg_audios = [_resample_to_target(w, sr) for w in seg_audios]
+            print(f"[MMAudio upsample] done — {len(seg_audios)} seg(s) @ {TARGET_SR}Hz")
+            sr = TARGET_SR
         full_wav = _stitch_wavs(seg_audios, crossfade_s, crossfade_db, total_dur_s, sr)
 
         audio_path = os.path.join(tmp_dir, f"mmaudio_{sample_idx}.wav")
@@ -1178,8 +1200,8 @@ def regen_taro_segment(video_file, seg_idx, seg_meta_json,
                               seed_val, cfg_scale, num_steps, mode,
                               crossfade_s, crossfade_db, slot_id)
 
-    # FlashSR: upsample 16kHz → 48kHz on CPU (no GPU needed)
-    new_wav = _apply_flashsr(new_wav)
+    # Upsample 16kHz → 48kHz (sinc, CPU)
+    new_wav = _upsample_taro(new_wav)
     # CPU: splice, stitch, mux, save
     video_path, audio_path, updated_meta, waveform_html = _splice_and_save(
         new_wav, seg_idx, meta, slot_id
@@ -1269,6 +1291,11 @@ def regen_mmaudio_segment(video_file, seg_idx, seg_meta_json,
                                      prompt, negative_prompt, seed_val,
                                      cfg_strength, num_steps, crossfade_s, crossfade_db, slot_id)
 
+    # Resample to 48kHz if needed (MMAudio outputs at 44100 Hz)
+    if sr != TARGET_SR:
+        print(f"[MMAudio regen upsample] {sr}Hz → {TARGET_SR}Hz (sinc, CPU) …")
+        new_wav = _resample_to_target(new_wav, sr)
+        sr = TARGET_SR
     meta["sr"] = sr
 
     # CPU: splice, stitch, mux, save
@@ -1450,9 +1477,9 @@ def xregen_taro(seg_idx, state_json, slot_id,
     new_wav_raw = _regen_taro_gpu(None, seg_idx, state_json,
                                   seed_val, cfg_scale, num_steps, mode,
                                   crossfade_s, crossfade_db, slot_id)
-    # FlashSR: upsample 16kHz → 48kHz on CPU (no GPU needed)
-    new_wav_raw = _apply_flashsr(new_wav_raw)
-    video_path, waveform_html = _xregen_splice(new_wav_raw, FLASHSR_SR_OUT, meta, seg_idx, slot_id)
+    # Upsample 16kHz → 48kHz (sinc, CPU)
+    new_wav_raw = _upsample_taro(new_wav_raw)
+    video_path, waveform_html = _xregen_splice(new_wav_raw, TARO_SR_OUT, meta, seg_idx, slot_id)
     yield gr.update(value=video_path), gr.update(value=waveform_html)