"""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", }