Update app.py

app.py

@@ -1079,8 +1079,12 @@ def generate(
     new_chunk_state = None
     if chunk_enabled:
         prior_paths = chunk_state["paths"] if chunk_advance else []
-        chunk_paths = prior_paths + [path]
-        path = _concat_chunks(chunk_paths) if len(chunk_paths) > 1 else path
+        # The momentum-imposed opening is a *regeneration* of the previous chunk's own tail, not new content —
+        # trimmed here so concatenation doesn't duplicate it. Only continuation chunks that actually had momentum
+        # applied carry anything to trim; chunk one, and any chunk that fell back to a plain keyframe carry, don't.
+        chunk_output = _trim_head(path, float(momentum)) if (chunk_advance and given_video is not None) else path
+        chunk_paths = prior_paths + [chunk_output]
+        path = _concat_chunks(chunk_paths) if len(chunk_paths) > 1 else chunk_output
         new_chunk_state = {"paths": chunk_paths}
 
     return path, report, new_stage_state, new_chunk_state
@@ -1171,12 +1175,13 @@ def _last_frame_path(video_path: str) -> str | None:
 
 
 def _trailing_frames(video_path: str, seconds: float):
-    """The last `seconds` of `video_path`'s pixel frames, at MiniMax-H3's own native 24 fps, as `(num_frames, 3,
-    H, W)` float in `[0, 1]` — the format `MiniMaxH3MomentumConditionStep` expects for `given_video`. Strided
-    back down to 24 fps if the saved chunk was FILM-interpolated to a multiple of it: feeding the video VAE
-    frames at anything other than its own encoding rate would encode the motion at the wrong speed — a
-    real correctness point, not a cosmetic one, since FILM's own multiplier is read fresh from the UI on every
-    press. Runs on CPU; no GPU time.
+    """The last `snap_frames(seconds)` of `video_path`'s pixel frames, at MiniMax-H3's own native 24 fps, as
+    `(num_frames, 3, H, W)` **uint8** — `encode_vae_condition`'s own documented input convention (it does its
+    own `/255` and ImageNet normalization internally; pre-dividing here would double it). The frame count is
+    snapped to the same `17 * n + 5` the video VAE's temporal chunking requires for a multi-frame encode, per
+    that function's own docstring — the same alignment `snap_frames` already gives a full request. Strided back
+    to 24 fps first if the saved chunk was FILM-interpolated to a multiple of it: encoding frames at the wrong
+    rate would encode the motion at the wrong speed. Runs on CPU; no GPU time.
     """
     if not video_path or seconds <= 0:
         return None
@@ -1190,7 +1195,8 @@ def _trailing_frames(video_path: str, seconds: float):
     actual_fps = cap.get(cv2.CAP_PROP_FPS) or FPS
     stride = max(1, round(actual_fps / FPS))
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    start_frame = max(0, total_frames - round(seconds * actual_fps))
+    target_frames = snap_frames(seconds)
+    start_frame = max(0, total_frames - target_frames * stride)
 
     cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
     frames = []
@@ -1200,11 +1206,13 @@ def _trailing_frames(video_path: str, seconds: float):
             break
         if index % stride == 0:
             frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        if len(frames) == target_frames:
+            break
     cap.release()
-    if not frames:
-        return None
-    array = np.stack(frames).astype(np.float32) / 255.0
-    return torch.from_numpy(array).permute(0, 3, 1, 2).contiguous()
+    if len(frames) < target_frames:
+        return None  # not enough source frames for a full, correctly-aligned encode
+    array = np.stack(frames)
+    return torch.from_numpy(array).permute(0, 3, 1, 2).contiguous()  # uint8, (num_frames, 3, H, W)
 
 
 def _concat_chunks(paths: list[str]) -> str:
@@ -1226,6 +1234,22 @@ def _concat_chunks(paths: list[str]) -> str:
     )
     return out_path
 
+def _trim_head(video_path: str, seconds: float) -> str:
+    """`video_path` with its first `seconds` cut off — the momentum-imposed opening a continuation chunk
+    regenerates from the previous chunk's own tail, which would otherwise be duplicated once the chunks are
+    concatenated. Re-encodes rather than stream-copying: an arbitrary, non-keyframe-aligned cut point can't
+    always be trimmed losslessly with `-c copy`.
+    """
+    import subprocess
+
+    directory = os.path.join(tempfile.gettempdir(), "pk-h3-chunks")
+    os.makedirs(directory, exist_ok=True)
+    out_path = os.path.join(directory, f"trimmed-{int(time.time() * 1000)}.mp4")
+    subprocess.run(
+        ["ffmpeg", "-y", "-ss", str(seconds), "-i", video_path, out_path],
+        check=True, capture_output=True,
+    )
+    return out_path
 
 load_models()