Show slot 0 by default; reveal extra slots on Generations slider drag

app.py

@@ -380,21 +380,25 @@ with gr.Blocks(title="TARO: Video-to-Audio Synthesis") as demo:
             run_btn       = gr.Button("Generate", variant="primary")
 
         with gr.Column():
-            # Pre-build MAX_SLOTS output slots; hide all initially
+            # All MAX_SLOTS slots pre-built.
+            # Slot 0 is always visible (shows loading progress during inference).
+            # Slots 1-N become visible when user drags the Generations slider.
             slot_videos = []
             slot_audios = []
+            slot_grps   = []
             for i in range(MAX_SLOTS):
-                with gr.Group(visible=False) as grp:
-                    sv = gr.Video(label=f"Sample {i+1} — Video")
-                    sa = gr.Audio(label=f"Sample {i+1} — Audio")
-                slot_videos.append((grp, sv))
-                slot_audios.append((grp, sa))
-
-    # ------------------------------------------------------------------ #
-    # Events                                                              #
-    # ------------------------------------------------------------------ #
-
-    # Update samples slider max when video uploaded or relevant sliders change
+                with gr.Group(visible=(i == 0)) as grp:
+                    sv = gr.Video(label=f"Generation {i+1} — Video")
+                    sa = gr.Audio(label=f"Generation {i+1} — Audio")
+                slot_grps.append(grp)
+                slot_videos.append(sv)
+                slot_audios.append(sa)
+
+    # -------------------------------------------------------------- #
+    # Events                                                           #
+    # -------------------------------------------------------------- #
+
+    # Update Generations slider max on video upload / steps / crossfade change
     def _update_samples_slider(video_file, num_steps, crossfade_s):
         return on_video_upload(video_file, num_steps, crossfade_s)
 
@@ -405,41 +409,33 @@ with gr.Blocks(title="TARO: Video-to-Audio Synthesis") as demo:
             outputs=[samples_input],
         )
 
-    # Collect all output components (flat: grp_visible, video, audio per slot)
-    all_outputs = []
-    for grp, sv in slot_videos:
-        all_outputs.append(grp)
-    for _, sa in slot_audios:
-        all_outputs.append(sa)
-    # Actually build properly: interleaved group + video + audio
-    all_outputs = []
-    slot_video_comps = [sv for _, sv in slot_videos]
-    slot_audio_comps = [sa for _, sa in slot_audios]
-    slot_grp_comps   = [grp for grp, _ in slot_videos]
+    # Show/hide output slots instantly when Generations slider is dragged
+    def _update_slot_visibility(num_samples):
+        n = int(num_samples)
+        return [gr.update(visible=(i < n)) for i in range(MAX_SLOTS)]
+
+    samples_input.change(
+        fn=_update_slot_visibility,
+        inputs=[samples_input],
+        outputs=slot_grps,
+    )
 
+    # Main generate: calls inference then populates slots
     def _generate_and_update(video_file, seed_val, cfg_scale, num_steps, mode,
-                              crossfade_s, crossfade_db, num_samples):
+                             crossfade_s, crossfade_db, num_samples):
         flat = generate_audio(video_file, seed_val, cfg_scale, num_steps, mode,
-                               crossfade_s, crossfade_db, num_samples)
-        num_samples = int(num_samples)
-        # flat = [vid0, aud0, vid1, aud1, ...]
-        grp_updates   = []
-        video_updates = []
-        audio_updates = []
-        for i in range(MAX_SLOTS):
-            visible = i < num_samples
-            vid = flat[i * 2]
-            aud = flat[i * 2 + 1]
-            grp_updates.append(gr.update(visible=visible))
-            video_updates.append(gr.update(value=vid))
-            audio_updates.append(gr.update(value=aud))
+                              crossfade_s, crossfade_db, num_samples)
+        n = int(num_samples)
+        grp_updates   = [gr.update(visible=(i < n)) for i in range(MAX_SLOTS)]
+        video_updates = [gr.update(value=flat[i * 2])     for i in range(MAX_SLOTS)]
+        audio_updates = [gr.update(value=flat[i * 2 + 1]) for i in range(MAX_SLOTS)]
         return grp_updates + video_updates + audio_updates
 
     run_btn.click(
         fn=_generate_and_update,
         inputs=[video_input, seed_input, cfg_input, steps_input, mode_input,
                 cf_dur_input, cf_db_input, samples_input],
-        outputs=slot_grp_comps + slot_video_comps + slot_audio_comps,
+        outputs=slot_grps + slot_videos + slot_audios,
     )
 
-demo.queue().launch()
+demo.queue().launch()