Files
ComfyUI-H3-Continuum-Tiled/v3/seam_test_source.py
T

237 lines
7.8 KiB
Python

"""Deterministic decoded-chunk source for video seam validation."""
from __future__ import annotations
import math
from typing import Any
import torch
import torch.nn.functional as F
from ..hardening import enrich_assembly_plan
from .plan import (
ASSEMBLY_PLAN_MAGIC,
ASSEMBLY_PLAN_SCHEMA_VERSION,
FPS,
validate_assembly_plan,
)
TEST_SIZE_256 = "256 px (Fast)"
TEST_SIZE_512 = "512 px"
TEST_SIZE_INPUT = "Input Size"
TEST_SIZE_OPTIONS = (TEST_SIZE_256, TEST_SIZE_512, TEST_SIZE_INPUT)
def _prepare_image(image: Any, size_mode: str) -> torch.Tensor:
if not torch.is_tensor(image) or image.ndim != 4 or int(image.shape[-1]) < 3:
raise ValueError("image must be an IMAGE tensor [B,H,W,C]")
if int(image.shape[0]) != 1:
raise ValueError("Seam Test Source requires exactly one input image")
frame = image[0, ..., :3].detach().to(device="cpu", dtype=torch.float32)
if not bool(torch.isfinite(frame).all().item()):
raise ValueError("input image contains NaN or Inf")
frame = frame.clamp(0.0, 1.0)
if size_mode == TEST_SIZE_INPUT:
return frame.contiguous()
limits = {TEST_SIZE_256: 256, TEST_SIZE_512: 512}
if size_mode not in limits:
raise ValueError(f"unknown Test Resolution: {size_mode!r}")
height, width = int(frame.shape[0]), int(frame.shape[1])
scale = min(1.0, float(limits[size_mode]) / float(max(height, width)))
target_height = max(1, int(round(height * scale)))
target_width = max(1, int(round(width * scale)))
if (target_height, target_width) == (height, width):
return frame.contiguous()
resized = F.interpolate(
frame.permute(2, 0, 1).unsqueeze(0),
size=(target_height, target_width),
mode="bilinear",
align_corners=False,
)
return resized[0].permute(1, 2, 0).contiguous()
def _repeat_frame(frame: torch.Tensor, count: int) -> torch.Tensor:
return frame.unsqueeze(0).expand(int(count), -1, -1, -1).clone()
def _ramp_chunk(
previous_anchor: torch.Tensor,
*,
context_frames: int,
net_frames: int,
exposure_change: float,
) -> tuple[torch.Tensor, torch.Tensor]:
context = _repeat_frame(previous_anchor, context_frames)
ramp_count = 5
ramp_factors = torch.linspace(
1.0 - exposure_change,
1.0 - exposure_change * 2.0,
steps=ramp_count,
dtype=torch.float32,
)
ramp = (
previous_anchor.unsqueeze(0)
* ramp_factors.reshape(-1, 1, 1, 1)
).clamp(0.0, 1.0)
next_anchor = ramp[-1].contiguous()
tail = _repeat_frame(next_anchor, net_frames - ramp_count)
return torch.cat((context, ramp, tail), dim=0).contiguous(), next_anchor
def _silent_audio(total_frames: int, sample_rate: int) -> dict[str, Any]:
samples = int(math.ceil(total_frames / FPS * sample_rate)) + 8
return {
"waveform": torch.zeros((1, 2, samples), dtype=torch.float32),
"sample_rate": int(sample_rate),
}
def _assembly_plan(width: int, height: int) -> dict[str, Any]:
chunks = [
{
"sequence_index": 1,
"chunk_index": 1,
"total_frames": 124,
"trim_frames": 0,
"net_frames": 124,
"context_frames": 0,
"expected_video_latent_t": 32,
"expected_audio_latent_t": 207,
},
{
"sequence_index": 2,
"chunk_index": 2,
"total_frames": 141,
"trim_frames": 22,
"net_frames": 119,
"context_frames": 22,
"expected_video_latent_t": 36,
"expected_audio_latent_t": 235,
},
{
"sequence_index": 3,
"chunk_index": 3,
"total_frames": 141,
"trim_frames": 22,
"net_frames": 119,
"context_frames": 22,
"expected_video_latent_t": 36,
"expected_audio_latent_t": 235,
},
]
plan = {
"magic": ASSEMBLY_PLAN_MAGIC,
"schema_version": ASSEMBLY_PLAN_SCHEMA_VERSION,
"fps": FPS,
"width": int(width),
"height": int(height),
"chunk_seconds": 5.0,
"target_frames": 360,
"preserve_final_frame": True,
"chunks": chunks,
}
enrich_assembly_plan(plan)
return validate_assembly_plan(plan)
class H3ContinuumSeamTestSource:
DESCRIPTION = (
"Create deterministic decoded chunks for testing Video Seam modes. "
"Chunk 2 and Chunk 3 each begin with a controlled exposure ramp. "
"This node performs no H3 sampling."
)
SEARCH_ALIASES = ["H3 seam test", "H3 exposure ramp test"]
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"image": ("IMAGE",),
"exposure_change": (
"FLOAT",
{
"default": 0.08,
"min": 0.01,
"max": 0.20,
"step": 0.01,
"display_name": "Exposure Change",
"tooltip": (
"8% is the controlled default. Each new chunk ramps "
"from one step darker to two steps darker."
),
},
),
"test_resolution": (
TEST_SIZE_OPTIONS,
{
"default": TEST_SIZE_256,
"display_name": "Test Resolution",
"tooltip": (
"256 px is recommended for fast seam testing. "
"Input Size can require several GiB of RAM."
),
},
),
}
}
RETURN_TYPES = (
"IMAGE",
"AUDIO",
"H3_CONTINUUM_ASSEMBLY_PLAN",
"STRING",
)
RETURN_NAMES = ("images", "audio", "assembly_plan", "instructions")
OUTPUT_IS_LIST = (True, True, False, False)
FUNCTION = "create"
CATEGORY = "MiniMax H3/Continuum/Testing"
EXPERIMENTAL = True
def create(
self,
image,
exposure_change=0.08,
test_resolution=TEST_SIZE_256,
):
change = float(exposure_change)
if not math.isfinite(change) or not 0.01 <= change <= 0.20:
raise ValueError("Exposure Change must be between 0.01 and 0.20")
base = _prepare_image(image, str(test_resolution))
chunk_1 = _repeat_frame(base, 124)
chunk_2, anchor_2 = _ramp_chunk(
base,
context_frames=22,
net_frames=119,
exposure_change=change,
)
chunk_3, _anchor_3 = _ramp_chunk(
anchor_2,
context_frames=22,
net_frames=119,
exposure_change=change,
)
images = [chunk_1, chunk_2, chunk_3]
audio = [
_silent_audio(124, 32000),
_silent_audio(141, 32000),
_silent_audio(141, 32000),
]
plan = _assembly_plan(int(base.shape[1]), int(base.shape[0]))
instructions = (
"H3 Continuum Seam Test Source\n"
"1. Connect images, audio, and assembly_plan to the matching inputs "
"of H3 Continuum Assemble + Seam.\n"
"2. Set Audio Seam=Off and exact_total_duration=true.\n"
"3. Run Video Seam=Analyze Only, then Auto, then Auto 2.\n"
"4. Analyze Only should report class=exposure_ramp at both boundaries.\n"
"5. Auto should keep both native boundaries. Auto 2 should report "
"normalized exposure/color on 4 exposure ramp boundary frame(s).\n"
f"Source: 3 x 5 sec, 24 fps, {base.shape[1]}x{base.shape[0]}, "
f"exposure change={change:.0%}."
)
return images, audio, plan, instructions