.

app.py

@@ -14,6 +14,7 @@ import json
 import base64
 import tempfile
 import random
+import threading
 from pathlib import Path
 
 import time
@@ -75,6 +76,20 @@ print("CLAP model pre-downloaded.")
 # ================================================================== #
 
 MAX_SLOTS = 8   # max parallel generation slots shown in UI
+MAX_SEGS  = 8   # max segments per slot (same as MAX_SLOTS; video ≤ ~64 s at 8 s/seg)
+
+# Per-slot reentrant locks — prevent concurrent regens on the same slot from
+# producing a race condition where the second regen reads stale state
+# (the shared seg_state textbox hasn't been updated yet by the first regen).
+# Locks are keyed by slot_id string (e.g. "taro_0", "mma_2").
+_SLOT_LOCKS: dict = {}
+_SLOT_LOCKS_MUTEX = threading.Lock()
+
+def _get_slot_lock(slot_id: str) -> threading.Lock:
+    with _SLOT_LOCKS_MUTEX:
+        if slot_id not in _SLOT_LOCKS:
+            _SLOT_LOCKS[slot_id] = threading.Lock()
+        return _SLOT_LOCKS[slot_id]
 
 def set_global_seed(seed: int):
     np.random.seed(seed % (2**32))
@@ -1085,6 +1100,59 @@ def _pad_outputs(outputs: list) -> list:
 # WaveSurfer waveform + segment marker HTML builder                   #
 # ------------------------------------------------------------------ #
 
+def _build_regen_pending_html(segments: list, regen_seg_idx: int, slot_id: str,
+                              hidden_input_id: str) -> str:
+    """Return a waveform placeholder shown while a segment is being regenerated.
+
+    Renders a dark bar with the active segment highlighted in amber + a spinner.
+    """
+    segs_json = json.dumps(segments)
+    seg_colors = ["rgba(100,180,255,0.25)", "rgba(255,160,100,0.25)",
+                  "rgba(120,220,140,0.25)", "rgba(220,120,220,0.25)",
+                  "rgba(255,220,80,0.25)",  "rgba(80,220,220,0.25)",
+                  "rgba(255,100,100,0.25)", "rgba(180,255,180,0.25)"]
+    active_color = "rgba(255,180,0,0.55)"
+    duration = segments[-1][1] if segments else 1.0
+
+    seg_divs = ""
+    for i, seg in enumerate(segments):
+        left_pct  = seg[0] / duration * 100
+        width_pct = (seg[1] - seg[0]) / duration * 100
+        color     = active_color if i == regen_seg_idx else seg_colors[i % len(seg_colors)]
+        extra     = "border:2px solid #ffb300;animation:wf_pulse 0.8s ease-in-out infinite alternate;" if i == regen_seg_idx else ""
+        seg_divs += (
+            f'<div style="position:absolute;top:0;left:{left_pct:.2f}%;'
+            f'width:{width_pct:.2f}%;height:100%;background:{color};{extra}">'
+            f'<span style="color:rgba(255,255,255,0.7);font-size:10px;padding:2px 3px;">Seg {i+1}</span>'
+            f'</div>'
+        )
+
+    spinner = (
+        '<div style="position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);'
+        'display:flex;align-items:center;gap:6px;">'
+        '<div style="width:14px;height:14px;border:2px solid #ffb300;'
+        'border-top-color:transparent;border-radius:50%;'
+        'animation:wf_spin 0.7s linear infinite;"></div>'
+        f'<span style="color:#ffb300;font-size:12px;white-space:nowrap;">'
+        f'Regenerating Seg {regen_seg_idx+1}…</span>'
+        '</div>'
+    )
+
+    return f"""
+<style>
+@keyframes wf_pulse {{from{{opacity:0.5}}to{{opacity:1}}}}
+@keyframes wf_spin  {{to{{transform:rotate(360deg)}}}}
+</style>
+<div style="background:#1a1a1a;border-radius:8px;padding:10px;margin-top:6px;">
+  <div style="position:relative;width:100%;height:80px;background:#1e1e2e;border-radius:4px;overflow:hidden;">
+    {seg_divs}
+    {spinner}
+  </div>
+  <div style="color:#888;font-size:11px;margin-top:6px;">Regenerating — please wait…</div>
+</div>
+"""
+
+
 def _build_waveform_html(audio_path: str, segments: list, slot_id: str,
                          hidden_input_id: str) -> str:
     """Return a self-contained HTML block with a Canvas waveform (display only),
@@ -1336,7 +1404,9 @@ def _build_waveform_html(audio_path: str, segments: list, slot_id: str,
 def _make_output_slots(tab_prefix: str) -> tuple:
     """Build MAX_SLOTS output groups for one tab.
 
-    Each slot has: video, waveform HTML, hidden regen trigger textbox, seg state.
+    Each slot has: video, waveform HTML, hidden regen trigger textbox,
+    hidden JSON state textbox (replaces gr.State to fix Gradio 5 SSR
+    'Too many arguments' caused by gr.State not counting in endpoint outputs).
     Returns (grps, vids, waveforms, regen_triggers, seg_states).
     """
     grps, vids, waveforms, regen_triggers, seg_states = [], [], [], [], []
@@ -1347,14 +1417,20 @@ def _make_output_slots(tab_prefix: str) -> tuple:
             waveforms.append(gr.HTML(
                 value="<p style='color:#888;font-size:12px'>Generate audio to see waveform.</p>",
             ))
-            # Hidden textbox: JS writes "<slot_id>|<seg_idx>" here to trigger regen
+            # Hidden textbox: JS writes "<slot_id>|<seg_idx>" to trigger regen
             regen_triggers.append(gr.Textbox(
                 value="",
                 visible=False,
                 elem_id=f"regen_trigger_{slot_id}",
                 label=f"regen_trigger_{slot_id}",
             ))
-            seg_states.append(gr.State(value=None))
+            # Hidden JSON textbox instead of gr.State — Gradio 5 SSR counts
+            # gr.Textbox correctly in endpoint outputs but not gr.State.
+            seg_states.append(gr.Textbox(
+                value="",
+                visible=False,
+                label=f"seg_state_{slot_id}",
+            ))
         grps.append(g)
     return grps, vids, waveforms, regen_triggers, seg_states
 
@@ -1381,12 +1457,13 @@ def _unpack_outputs(flat: list, n: int, tab_prefix: str) -> list:
             hidden_el_id  = f"regen_trigger_{slot_id}"
             html = _build_waveform_html(aud_path, meta["segments"], slot_id, hidden_el_id)
             wave_updates.append(gr.update(value=html))
-            state_updates.append(meta)
+            # Serialize meta to JSON string (seg_states are now gr.Textbox)
+            state_updates.append(gr.update(value=json.dumps(meta)))
         else:
             wave_updates.append(gr.update(
                 value="<p style='color:#888;font-size:12px'>Generate audio to see waveform.</p>"
             ))
-            state_updates.append(None)
+            state_updates.append(gr.update(value=""))
     return vid_updates + wave_updates + state_updates
 
 
@@ -1571,20 +1648,28 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
             for _i, _rtrig in enumerate(taro_slot_rtrigs):
                 _slot_id = f"taro_{_i}"
                 def _make_taro_regen(_si, _sid):
-                    def _do(trigger_val, video, seed, cfg, steps, mode, cf_dur, cf_db, state):
-                        if not trigger_val or not state:
-                            return gr.update(), gr.update(), state, gr.update()
+                    def _do(trigger_val, video, seed, cfg, steps, mode, cf_dur, cf_db, state_json):
+                        if not trigger_val or not state_json:
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
-                            return gr.update(), gr.update(), state, gr.update()
-                        seg_idx    = int(parts[1])
-                        meta_json  = json.dumps(state)
-                        vid, aud, new_meta_json, html = regen_taro_segment(
-                            video, seg_idx, meta_json,
-                            seed, cfg, steps, mode, cf_dur, cf_db, _sid,
-                        )
-                        new_meta = json.loads(new_meta_json)
-                        return gr.update(value=vid), gr.update(value=html), new_meta, gr.update(value="")
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
+                        seg_idx = int(parts[1])
+                        # Acquire per-slot lock so concurrent regens on the same slot
+                        # don't read stale state (second regen waits for first to finish).
+                        lock = _get_slot_lock(_sid)
+                        with lock:
+                            state   = json.loads(state_json)
+                            pending_html = _build_regen_pending_html(
+                                state["segments"], seg_idx, _sid,
+                                f"regen_trigger_{_sid}"
+                            )
+                            yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
+                            vid, aud, new_meta_json, html = regen_taro_segment(
+                                video, seg_idx, state_json,
+                                seed, cfg, steps, mode, cf_dur, cf_db, _sid,
+                            )
+                            yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(
                     fn=_make_taro_regen(_i, _slot_id),
@@ -1645,20 +1730,26 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
             for _i, _rtrig in enumerate(mma_slot_rtrigs):
                 _slot_id = f"mma_{_i}"
                 def _make_mma_regen(_si, _sid):
-                    def _do(trigger_val, video, prompt, neg, seed, cfg, steps, cf_dur, cf_db, state):
-                        if not trigger_val or not state:
-                            return gr.update(), gr.update(), state, gr.update()
+                    def _do(trigger_val, video, prompt, neg, seed, cfg, steps, cf_dur, cf_db, state_json):
+                        if not trigger_val or not state_json:
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
-                            return gr.update(), gr.update(), state, gr.update()
-                        seg_idx   = int(parts[1])
-                        meta_json = json.dumps(state)
-                        vid, aud, new_meta_json, html = regen_mmaudio_segment(
-                            video, seg_idx, meta_json,
-                            prompt, neg, seed, cfg, steps, cf_dur, cf_db, _sid,
-                        )
-                        new_meta = json.loads(new_meta_json)
-                        return gr.update(value=vid), gr.update(value=html), new_meta, gr.update(value="")
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
+                        seg_idx = int(parts[1])
+                        lock = _get_slot_lock(_sid)
+                        with lock:
+                            state   = json.loads(state_json)
+                            pending_html = _build_regen_pending_html(
+                                state["segments"], seg_idx, _sid,
+                                f"regen_trigger_{_sid}"
+                            )
+                            yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
+                            vid, aud, new_meta_json, html = regen_mmaudio_segment(
+                                video, seg_idx, state_json,
+                                prompt, neg, seed, cfg, steps, cf_dur, cf_db, _sid,
+                            )
+                            yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(
                     fn=_make_mma_regen(_i, _slot_id),
@@ -1720,20 +1811,26 @@ with gr.Blocks(title="Generate Audio for Video", css=_SLOT_CSS, js=_GLOBAL_JS) a
             for _i, _rtrig in enumerate(hf_slot_rtrigs):
                 _slot_id = f"hf_{_i}"
                 def _make_hf_regen(_si, _sid):
-                    def _do(trigger_val, video, prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, state):
-                        if not trigger_val or not state:
-                            return gr.update(), gr.update(), state, gr.update()
+                    def _do(trigger_val, video, prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, state_json):
+                        if not trigger_val or not state_json:
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
                         parts = trigger_val.split("|")
                         if len(parts) != 2 or parts[0] != _sid:
-                            return gr.update(), gr.update(), state, gr.update()
-                        seg_idx   = int(parts[1])
-                        meta_json = json.dumps(state)
-                        vid, aud, new_meta_json, html = regen_hunyuan_segment(
-                            video, seg_idx, meta_json,
-                            prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, _sid,
-                        )
-                        new_meta = json.loads(new_meta_json)
-                        return gr.update(value=vid), gr.update(value=html), new_meta, gr.update(value="")
+                            return gr.update(), gr.update(), gr.update(value=""), gr.update()
+                        seg_idx = int(parts[1])
+                        lock = _get_slot_lock(_sid)
+                        with lock:
+                            state   = json.loads(state_json)
+                            pending_html = _build_regen_pending_html(
+                                state["segments"], seg_idx, _sid,
+                                f"regen_trigger_{_sid}"
+                            )
+                            yield gr.update(), gr.update(value=pending_html), gr.update(value=state_json), gr.update()
+                            vid, aud, new_meta_json, html = regen_hunyuan_segment(
+                                video, seg_idx, state_json,
+                                prompt, neg, seed, guidance, steps, size, cf_dur, cf_db, _sid,
+                            )
+                            yield gr.update(value=vid), gr.update(value=html), gr.update(value=new_meta_json), gr.update(value="")
                     return _do
                 _rtrig.change(
                     fn=_make_hf_regen(_i, _slot_id),