Files
ComfyUI-H3-Continuum-Tiled/v3/hires_fix_nodes.py
T
2026-08-24 15:00:45 +09:00

464 lines
17 KiB
Python

"""V3.5 Continuum-aware Hi-res fix convenience node."""
from __future__ import annotations
from collections.abc import Callable, Mapping, Sequence
from typing import Any
from .pixel_vae_resize import (
resize_video_latents_via_vae,
resolve_pixel_latent_scale,
)
from .second_pass import SecondPassContractError, run_second_pass_groups
_MISSING = object()
HIRES_UPSCALE_METHODS = (
"lanczos",
"nearest-exact",
"bilinear",
"area",
"bicubic",
"bislerp",
)
_CONDITIONING_UPSCALE_METHOD = "bilinear"
def _single_list_input(name: str, value: Any) -> Any:
if not isinstance(value, list) or len(value) != 1:
raise ValueError(f"{name} must contain exactly one value")
return value[0]
def _enabled_value(value: Any) -> bool:
if isinstance(value, list):
value = _single_list_input("enabled", value)
return bool(value)
def _lazy_missing(value: Any) -> bool:
return value is None or (
isinstance(value, (list, tuple))
and len(value) == 1
and value[0] is None
)
def h3_core_native_canvas(
width: int,
height: int,
*,
adapt_canvas_fn: Callable[[int, int], tuple[int, int]] | None = None,
) -> tuple[int, int]:
"""Return the native canvas selected by ComfyUI Core for this aspect ratio."""
if width < 1 or height < 1:
raise SecondPassContractError("source pixel width and height must be positive")
if adapt_canvas_fn is None:
from comfy_extras.nodes_minimax_h3 import adapt_canvas
adapt_canvas_fn = adapt_canvas
target = adapt_canvas_fn(int(width), int(height))
if not isinstance(target, Sequence) or len(target) != 2:
raise SecondPassContractError("ComfyUI Core adapt_canvas returned invalid geometry")
target_width, target_height = (int(value) for value in target)
if target_width < 1 or target_height < 1:
raise SecondPassContractError("ComfyUI Core adapt_canvas returned invalid geometry")
return target_width, target_height
def resolve_h3_native_latent_target(
video_latents: Sequence[Mapping[str, Any]],
assembly_plan: Mapping[str, Any],
*,
adapt_canvas_fn: Callable[[int, int], tuple[int, int]] | None = None,
) -> dict[str, int | bool]:
"""Resolve Core's native canvas without shrinking an existing video latent."""
contract = assembly_plan.get("second_pass_contract")
if not isinstance(contract, Mapping):
raise SecondPassContractError("assembly_plan has no second_pass_contract")
groups = contract.get("physical_groups")
if not isinstance(groups, list) or not groups:
raise SecondPassContractError(
"second_pass_contract.physical_groups must be non-empty"
)
if not isinstance(video_latents, Sequence) or not video_latents:
raise SecondPassContractError("video_latents must be a non-empty sequence")
if len(video_latents) != len(groups):
raise SecondPassContractError("video latent group count changed")
first_group = groups[0]
if not isinstance(first_group, Mapping):
raise SecondPassContractError("physical group metadata must be a mapping")
source_width = int(first_group.get("source_width", -1))
source_height = int(first_group.get("source_height", -1))
source_latent_width = int(first_group.get("source_latent_w", -1))
source_latent_height = int(first_group.get("source_latent_h", -1))
if min(source_width, source_height, source_latent_width, source_latent_height) < 1:
raise SecondPassContractError("source pixel/latent geometry is invalid")
if source_width % source_latent_width or source_height % source_latent_height:
raise SecondPassContractError("source pixel/latent geometry is not integral")
pixel_scale_width = source_width // source_latent_width
pixel_scale_height = source_height // source_latent_height
current_geometry: tuple[int, int] | None = None
for position, (latent, group) in enumerate(zip(video_latents, groups, strict=True)):
if not isinstance(group, Mapping):
raise SecondPassContractError("physical group metadata must be a mapping")
if int(group.get("source_width", -1)) != source_width or int(
group.get("source_height", -1)
) != source_height:
raise SecondPassContractError("source geometry differs between physical groups")
if int(group.get("source_latent_w", -1)) != source_latent_width or int(
group.get("source_latent_h", -1)
) != source_latent_height:
raise SecondPassContractError(
"source latent geometry differs between physical groups"
)
if not isinstance(latent, Mapping) or "samples" not in latent:
raise SecondPassContractError(
f"video_latents[{position}] must be a LATENT mapping with samples"
)
samples = latent["samples"]
if not hasattr(samples, "shape") or len(samples.shape) != 5:
raise SecondPassContractError("video latent must have shape [B,C,T,H,W]")
geometry = (int(samples.shape[-2]), int(samples.shape[-1]))
if current_geometry is None:
current_geometry = geometry
elif geometry != current_geometry:
raise SecondPassContractError(
"all physical groups must use the same current H/W"
)
assert current_geometry is not None
native_width, native_height = h3_core_native_canvas(
source_width,
source_height,
adapt_canvas_fn=adapt_canvas_fn,
)
if native_width % pixel_scale_width or native_height % pixel_scale_height:
raise SecondPassContractError(
"ComfyUI Core native canvas is not aligned to the H3 latent scale"
)
native_latent_width = native_width // pixel_scale_width
native_latent_height = native_height // pixel_scale_height
current_height, current_width = current_geometry
preserve_current = (
native_latent_width < current_width
or native_latent_height < current_height
)
if preserve_current:
target_latent_width = current_width
target_latent_height = current_height
else:
target_latent_width = native_latent_width
target_latent_height = native_latent_height
return {
"source_width": source_width,
"source_height": source_height,
"native_width": native_width,
"native_height": native_height,
"target_width": target_latent_width * pixel_scale_width,
"target_height": target_latent_height * pixel_scale_height,
"target_latent_width": target_latent_width,
"target_latent_height": target_latent_height,
"preserved_current": preserve_current,
}
def _prepend_resize_status(
second_pass_status: str,
*,
backend: str,
mode: str,
upscale_method: str,
scale_by: float,
source_width: int,
source_height: int,
target_width: int,
target_height: int,
native_width: int,
native_height: int,
) -> str:
lines = [
"H3 Continuum Hi-Res Fix V3.5",
"Pixel/VAE resize: "
f"backend={backend}, mode={mode}, method={upscale_method}, "
f"scale_by={scale_by:g}, "
f"source={source_width}x{source_height}, "
f"target={target_width}x{target_height}, "
f"core_native={native_width}x{native_height}.",
]
if target_width > native_width or target_height > native_height:
lines.append(
"INFO: target exceeds the ComfyUI Core H3 base canvas; the Pixel/VAE "
"roundtrip is preserved and resource use may increase."
)
lines.append(second_pass_status)
return "\n".join(lines)
class H3ContinuumHiResFixV35:
"""Pixel/VAE resize and low-sigma refine complete physical video groups."""
DEPRECATED = False
DESCRIPTION = (
"Continuum-aware Hi-res fix. When enabled, each first-pass physical video "
"LATENT is decoded with the connected H3 Video VAE, resized in pixel space, "
"re-encoded with the same VAE, and refined once with the workflow SIGMAS. "
"scale_by 0 uses ComfyUI Core's H3 native canvas; positive values use the "
"manual multiplier. Connect the optional Continuum refine context to preserve "
"First/Last/Reference conditioning at the target geometry. "
"When disabled, first-pass video/audio LATENT objects and the original assembly "
"plan are returned unchanged."
)
@classmethod
def INPUT_TYPES(cls):
lazy = {"lazy": True}
return {
"required": {
"model": ("MODEL", lazy),
"clip": ("CLIP", lazy),
"sampler": ("SAMPLER", lazy),
"sigmas": ("SIGMAS", lazy),
"video_latents": ("LATENT",),
"audio_latents": ("LATENT",),
"assembly_plan": ("H3_CONTINUUM_ASSEMBLY_PLAN",),
"enabled": (
"BOOLEAN",
{
"default": True,
"tooltip": (
"Enable Resize + Second Pass. Off returns the first-pass "
"video/audio LATENT objects and assembly plan unchanged."
),
},
),
"upscale_method": (
HIRES_UPSCALE_METHODS,
{"default": "lanczos"},
),
"scale_by": (
"FLOAT",
{
"default": 2.0,
"min": 0.0,
"max": 4.0,
"step": 0.01,
"tooltip": (
"2.0 = validated 2x Pixel/VAE Hi-res Fix. 0 uses the "
"ComfyUI Core H3 native canvas automatically. Manual "
"values follow the existing Second Pass contract and must "
"be 1.0 or greater."
),
},
),
"refine_seed": (
"INT",
{
"default": 0,
"min": 0,
"max": 0xFFFFFFFFFFFFFFFF,
"control_after_generate": True,
"tooltip": "Base seed independently derived once per physical group.",
},
),
},
"optional": {
"refine_context": (
"H3_CONTINUUM_REFINE_CONTEXT",
{"lazy": True},
),
"video_vae": (
"VAE",
{
"lazy": True,
"tooltip": (
"Required while enabled for the safe Pixel/VAE roundtrip; "
"not evaluated while disabled."
),
},
),
},
}
INPUT_IS_LIST = True
RETURN_TYPES = ("LATENT", "LATENT", "H3_CONTINUUM_ASSEMBLY_PLAN", "STRING")
RETURN_NAMES = (
"video_latents",
"audio_latents",
"updated_assembly_plan",
"status",
)
OUTPUT_IS_LIST = (True, True, False, False)
FUNCTION = "apply"
CATEGORY = "MiniMax H3/Continuum"
def check_lazy_status(
self,
enabled,
model=None,
clip=None,
sampler=None,
sigmas=None,
refine_context=_MISSING,
video_vae=_MISSING,
**_kwargs,
):
if not _enabled_value(enabled):
return []
required = [
name
for name, value in (
("model", model),
("clip", clip),
("sampler", sampler),
("sigmas", sigmas),
)
if _lazy_missing(value)
]
required.extend(
name
for name, value in (
("refine_context", refine_context),
("video_vae", video_vae),
)
if value is not _MISSING and _lazy_missing(value)
)
return required
def apply(
self,
model,
clip,
sampler,
sigmas,
video_latents,
audio_latents,
assembly_plan,
enabled,
upscale_method,
scale_by,
refine_seed,
refine_context=None,
video_vae=None,
):
plan = _single_list_input("assembly_plan", assembly_plan)
if not _enabled_value(enabled):
return (
video_latents,
audio_latents,
plan,
"H3 Continuum Hi-Res Fix V3.5: disabled; first-pass video/audio "
"LATENT objects and assembly_plan returned unchanged.",
)
method = str(_single_list_input("upscale_method", upscale_method))
scale = float(_single_list_input("scale_by", scale_by))
if 0.0 < scale < 1.0:
raise SecondPassContractError(
"scale_by must be 0 for H3 native Auto or at least 1.0; the "
"existing Second Pass contract preserves or enlarges spatial size"
)
vae = (
None
if video_vae is None
else _single_list_input("video_vae", video_vae)
)
if vae is None:
raise SecondPassContractError(
"Hi-Res Fix enabled requires video_vae for the safe Pixel/VAE "
"roundtrip; legacy direct latent interpolation is disabled"
)
source_width = int(plan["width"])
source_height = int(plan["height"])
native_width, native_height = h3_core_native_canvas(
source_width,
source_height,
)
first_samples = video_latents[0]["samples"]
current_geometry = (
int(first_samples.shape[-2]),
int(first_samples.shape[-1]),
)
if scale == 0.0:
native_target = resolve_h3_native_latent_target(video_latents, plan)
target_latent_width = int(native_target["target_latent_width"])
target_latent_height = int(native_target["target_latent_height"])
target_width = int(native_target["target_width"])
target_height = int(native_target["target_height"])
resize_mode = "h3_native_canvas_auto"
else:
pixel_scale_width, pixel_scale_height = resolve_pixel_latent_scale(plan)
target_latent_width = round(current_geometry[1] * scale)
target_latent_height = round(current_geometry[0] * scale)
if target_latent_width < 1 or target_latent_height < 1:
raise SecondPassContractError(
"scale_by produced a non-positive target geometry"
)
target_width = target_latent_width * pixel_scale_width
target_height = target_latent_height * pixel_scale_height
resize_mode = "manual_scale_by"
if current_geometry == (target_latent_height, target_latent_width):
resized_video_latents = list(video_latents)
resize_backend = "direct_second_pass_no_resize"
else:
resized_video_latents = resize_video_latents_via_vae(
video_latents,
plan,
video_vae=vae,
target_width=target_width,
target_height=target_height,
upscale_method=method,
)
resize_backend = "sequential_pixel_vae_roundtrip"
refined_video, output_audio, updated_plan, status = run_second_pass_groups(
model=_single_list_input("model", model),
clip=_single_list_input("clip", clip),
sampler=_single_list_input("sampler", sampler),
sigmas=_single_list_input("sigmas", sigmas),
video_latents=resized_video_latents,
audio_latents=audio_latents,
assembly_plan=plan,
refine_seed=int(_single_list_input("refine_seed", refine_seed)),
refine_context=(
None
if refine_context is None
else _single_list_input("refine_context", refine_context)
),
video_vae=vae,
conditioning_upscale_method=_CONDITIONING_UPSCALE_METHOD,
)
return (
refined_video,
output_audio,
updated_plan,
_prepend_resize_status(
status,
backend=resize_backend,
mode=resize_mode,
upscale_method=method,
scale_by=scale,
source_width=source_width,
source_height=source_height,
target_width=int(updated_plan["width"]),
target_height=int(updated_plan["height"]),
native_width=native_width,
native_height=native_height,
),
)
NODE_CLASS_MAPPINGS = {
"H3ContinuumHiResFixV35": H3ContinuumHiResFixV35,
}
NODE_DISPLAY_NAME_MAPPINGS = {
"H3ContinuumHiResFixV35": "H3 Continuum Hi-Res Fix V3.5",
}