Fixed duplicate sound in last window

README.md

@@ -245,6 +245,22 @@ with its default RAM-pressure caching and is evicting node outputs mid-run.
 Start ComfyUI with `--cache-classic` (the RunPod script already does this). The
 generated audio is still correct either way — the re-execution only costs time.
 
+### Duplicate Sounds At Window Boundaries
+
+In `foley-sliding-window.json`, neighboring windows overlap (default `1.0`
+second) and each window generates its audio independently. If a distinct sound
+event (a door close, a footstep) falls inside an overlap region, both windows
+may render it slightly out of alignment, and you can hear the event twice
+around a window boundary. The run log's `planned N windows starts=[...]` line
+shows where the boundaries are (`start_frame / fps` seconds).
+
+If you hear this, reduce the **Window overlap** (`overlap_seconds` on the
+window-plan node), for example from `1.0` to `0.5`. A smaller overlap makes it
+less likely an event lands in the shared region, at the cost of a shorter
+crossfade between windows. Avoid large overlaps: the bigger the overlap, the
+more of the video is generated twice, which increases the chance of doubled
+sounds.
+
 ### Audio Artifacts On Some ComfyUI Versions
 
 The workflows have been tested on ComfyUI `v0.27.0` and run

ltx_foley_v2a/nodes.py

@@ -60,7 +60,24 @@ def _window_specs(source_frames: int, fps: float, window_frames: int, overlap_se
 
     starts = list(range(0, last_start + 1, hop_frames))
     if starts[-1] != last_start:
-        starts.append(last_start)
+        remainder = last_start - starts[-1]
+        if len(starts) > 1 and remainder <= overlap_frames:
+            # A snapped-to-end window this close to the previous start would
+            # show the model nearly the same frames twice, and the second
+            # generation can repeat events (e.g. a door close) near the end of
+            # the stitched audio. Merging is only safe up to overlap_frames:
+            # the window before the replaced start reaches exactly
+            # starts[-1] + overlap_frames, so any larger remainder would leave
+            # a zero-weight (silent) coverage gap instead.
+            print(
+                "[LTXFoley] merging final window: "
+                f"start {starts[-1]} -> {last_start} "
+                f"(remainder {remainder} <= overlap {overlap_frames})",
+                flush=True,
+            )
+            starts[-1] = last_start
+        else:
+            starts.append(last_start)
 
     return [
         {
@@ -615,14 +632,16 @@ class LTXFoleyWindowPlan:
             "truncated_by_max_windows": truncated,
             "window_specs": specs,
         }
+        start_frames = [spec["start_frame"] for spec in specs]
         if truncated:
             print(
                 "[LTXFoley] diagnostic truncation: "
-                f"planned {len(all_specs)} windows, running first {len(specs)} because max_windows={max_windows}",
+                f"planned {len(all_specs)} windows, running first {len(specs)} because max_windows={max_windows} "
+                f"starts={start_frames}",
                 flush=True,
             )
         else:
-            print(f"[LTXFoley] planned {len(specs)} windows", flush=True)
+            print(f"[LTXFoley] planned {len(specs)} windows starts={start_frames}", flush=True)
         return (plan, len(specs), json.dumps(plan, indent=2))