Upload 46 files

custom_nodes/ComfyUI-Nugget/__init__.py

@@ -49,7 +49,8 @@ _NODES = []
 for _module, _label in (("nodes_transcribe", "transcriber"),
                         ("nodes_motion", "motion transfer"),
                         ("nodes_prompt", "prompt"),
-                        ("nodes_image", "image")):
+                        ("nodes_image", "image"),
+                        ("nodes_h3_tailtrim", "h3 tail trim")):
     try:
         _mod = importlib.import_module(f".{_module}", __name__)
         _NODES.extend(_mod.NODES)

custom_nodes/ComfyUI-Nugget/nodes_h3_tailtrim.py

@@ -0,0 +1,164 @@
+"""Drop the tail off an H3 Motion Context latent before it is pinned.
+
+H3's last ~1s of a clip is often the weakest part of the render. Because
+Motion Context pins the LAST frames of the previous clip, that weak tail is
+exactly what the next clip continues from, so the fault propagates down the
+whole chain.
+
+This node sits between `H3 Motion Context Load Latent` and
+`H3 Motion Context`, and shortens the loaded clip so the pinned window ends
+earlier -- before the bad part.
+
+    Load Latent -> H3 Context Tail Trim -> Motion Context.context_latent
+
+WHY 17 FRAMES AND NOT 24
+------------------------
+The H3 video VAE packs pixel frames into latent steps in a 1,4,4,4,4 cycle:
+5 latent steps cover exactly 17 pixel frames, and a legal clip is always
+17g+5 frames (5g+2 steps). Motion Context refuses to pin a run that does not
+start on a cycle boundary -- it would silently shift the join. So the tail can
+only come off in whole 17-frame units:
+
+    17 frames = 0.708 s
+    34 frames = 1.417 s
+    51 frames = 2.125 s
+
+Asking for anything else is rejected here rather than misaligned later.
+
+Written to match ComfyUI-H3-Motion-Context (NikoDemon80). This was originally
+a standalone single-file pack (ComfyUI-H3-Context-TailTrim); it now lives in
+the Nugget pack, rewritten in the new comfy_api node style so it can coexist
+with Nugget's other nodes. The node id is unchanged, so existing workflows
+that reference `MiniMaxH3ContextTailTrim` still resolve.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from comfy_api.latest import io
+
+log = logging.getLogger("Nugget")
+
+FRAME_PER_TOKEN = (1, 4, 4, 4, 4)   # pixel frames covered by each latent step
+FRAME_RESCALE = 5.0 / 3.0           # audio latent steps per pixel frame
+FRAMES_PER_CYCLE = 17               # 5 latent steps
+STEPS_PER_CYCLE = 5
+
+
+def _pixel_frames(latent_t):
+    """Pixel frames covered by latent_t latent steps."""
+    return sum(FRAME_PER_TOKEN[k % 5] for k in range(int(latent_t)))
+
+
+def _streams(latent):
+    """Pull [video, audio] out of the paired AV latent the Load node makes."""
+    if not isinstance(latent, dict) or "samples" not in latent:
+        raise ValueError(
+            "h3_tail_trim: expected an H3 AV latent from 'H3 Motion Context "
+            "Load Latent'. Got %r." % (type(latent),))
+    s = latent["samples"]
+    if not isinstance(s, (list, tuple)) or len(s) < 2:
+        raise ValueError(
+            "h3_tail_trim: this is not a paired video/audio latent. Wire the "
+            "output of 'H3 Motion Context Load Latent' here, not a normal "
+            "latent.")
+    return s[0], s[1]
+
+
+def _trim(latent, drop_frames=17):
+    """The core trim. Kept as a plain function so it is unit-testable without
+    ComfyUI, exactly as the original standalone node's method was."""
+    if latent is None:               # clip 1 -- nothing loaded
+        return None
+    n = int(drop_frames)
+    if n <= 0:
+        return latent
+    if n % FRAMES_PER_CYCLE:
+        raise ValueError(
+            "h3_tail_trim: drop_frames must be a multiple of %d "
+            "(0.708 s at 24 fps); got %d. The H3 video VAE packs %d "
+            "pixel frames into %d latent steps, and Motion Context "
+            "refuses a pinned run that does not start on that boundary."
+            % (FRAMES_PER_CYCLE, n, FRAMES_PER_CYCLE, STEPS_PER_CYCLE))
+
+    video, audio = _streams(latent)
+    if video.ndim == 4:
+        video = video.unsqueeze(0)
+    if video.ndim != 5:
+        raise ValueError("h3_tail_trim: expected video latent [B,C,T,H,W], "
+                         "got %s" % (tuple(video.shape),))
+    if audio.ndim == 3:
+        audio = audio.unsqueeze(0)
+
+    steps = int(video.shape[2])
+    drop_steps = n // FRAMES_PER_CYCLE * STEPS_PER_CYCLE
+    new_steps = steps - drop_steps
+    # 7 steps is the 22-frame window; below that there is nothing to pin.
+    if new_steps < 7:
+        raise ValueError(
+            "h3_tail_trim: dropping %d frames leaves %d latent steps, "
+            "which is less than the 7 steps a 22-frame context window "
+            "needs. Use a longer clip or a smaller drop."
+            % (n, max(0, new_steps)))
+
+    old_frames = _pixel_frames(steps)
+    new_frames = _pixel_frames(new_steps)
+    # H3's audio latent runs at 40 Hz against 24 fps picture. The pack
+    # accepts an overhang of 0 or +/-1/3 of a step, which is exactly what
+    # rounding gives for every legal clip length.
+    new_audio_t = int(round(FRAME_RESCALE * new_frames))
+    new_audio_t = min(new_audio_t, int(audio.shape[-1]))
+
+    out_video = video[:, :, :new_steps].contiguous().clone()
+    out_audio = audio[..., :new_audio_t].contiguous().clone()
+
+    log.info("[Nugget] h3_tail_trim: dropped %d frames (%d latent steps): "
+             "%d -> %d frames, audio %d -> %d steps",
+             n, drop_steps, old_frames, new_frames,
+             int(audio.shape[-1]), new_audio_t)
+
+    return {"samples": [out_video, out_audio]}
+
+
+class NuggetH3ContextTailTrim(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            # node id kept identical to the old standalone pack so existing
+            # workflows referencing MiniMaxH3ContextTailTrim still resolve.
+            node_id="MiniMaxH3ContextTailTrim",
+            display_name="H3 Context Tail Trim",
+            category="conditioning/minimax",
+            search_aliases=["h3", "tail", "trim", "motion context",
+                            "tailtrim"],
+            description=(
+                "Shorten a loaded H3 context latent so Motion Context pins an "
+                "earlier window, skipping the weak tail of the previous clip. "
+                "Trims in 17-frame steps; picture and sound together."),
+            inputs=[
+                io.Latent.Input(
+                    "latent",
+                    tooltip="From 'H3 Motion Context Load Latent'. Passes "
+                            "straight through when nothing is loaded (clip 1), "
+                            "so it is safe to leave wired for every block."),
+                io.Int.Input(
+                    "drop_frames", default=17, min=0, max=340,
+                    step=FRAMES_PER_CYCLE, display_name="drop frames",
+                    tooltip="Pixel frames to remove from the END of the "
+                            "previous clip before its last frames are pinned. "
+                            "Must be a multiple of 17 (0.708 s) -- that is the "
+                            "H3 latent's cycle length. 17 drops ~0.7 s, 34 "
+                            "drops ~1.4 s."),
+            ],
+            outputs=[
+                io.Latent.Output(display_name="latent"),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, latent=None, drop_frames=17) -> io.NodeOutput:
+        return io.NodeOutput(_trim(latent, drop_frames))
+
+
+NODES = [NuggetH3ContextTailTrim]