| from __future__ import annotations |
|
|
| import copy |
| import json |
| import math |
| from typing import Any |
|
|
| import folder_paths |
| import nodes as comfy_nodes |
| from comfy_api.latest import InputImpl, io |
| from comfy_execution.graph_utils import ExecutionBlocker, GraphBuilder, is_link |
| from comfy.utils import ProgressBar |
|
|
| from ..utils import instrument_node_timing, log_node_info |
| from ..utils.h3_presets import get_h3_preset_keys, load_h3_presets, select_h3_preset |
| from ..utils.h3_project import ( |
| clear_h3_project_segments_from, |
| compose_h3_project_video, |
| h3_generation_mode, |
| h3_locked_audio_track, |
| h3_locked_video_track, |
| minimax_frame_count, |
| h3_project_filename_prefix, |
| h3_second_pass_dimensions, |
| has_h3_context_latent, |
| has_h3_first_pass_checkpoint, |
| h3_task_entries, |
| h3_task_type, |
| initialize_h3_project, |
| parse_tracks_info, |
| crop_multitrack_project_media, |
| prepare_multitrack_project_media, |
| prepare_multitrack_project_task_info, |
| safe_h3_project_name, |
| select_h3_task_entries, |
| validate_h3_project_outputs, |
| ) |
| from ..utils.models import detect_turbo_lora_from_prompt, detect_turbo_model |
| from ..utils.rtx_vsr import restore_project_video_resolution |
| from ..utils.project_memory import ( |
| BOUNDARY_META, |
| SEGMENT_META, |
| install_project_memory_cleanup, |
| ) |
| from ..utils.multitrack import ( |
| MULTITRACK_RUNTIME_CACHE_KEY, |
| multitrack_runtime_cache, |
| ) |
|
|
|
|
| TYPE_FAST_MODEL_LOADER = io.Custom(io_type="FAST_MODEL_LOADER") |
| TYPE_TRACKS_INFO = io.Custom(io_type="TRACKS_INFO") |
| TYPE_PROJECT_DATA = io.Custom(io_type="PROJECT_DATA") |
| TYPE_H3_PROJECT_STATIC_DATA = io.Custom(io_type="H3_PROJECT_STATIC_DATA") |
| H3_CONTEXT_CONTINUITY_MODES = {"context", "context_swap"} |
| H3_CONTEXT_SOURCE_FRAMES = 22 |
|
|
|
|
| def _first_input(value: Any, default: Any = None) -> Any: |
| if isinstance(value, (list, tuple)): |
| return value[0] if value else default |
| return value if value is not None else default |
|
|
|
|
| def _raw_project_input(value: Any) -> Any: |
| """Unwrap list inputs without splitting a raw graph link.""" |
| if is_link(value): |
| return value |
| if isinstance(value, (list, tuple)) and len(value) == 1 and is_link(value[0]): |
| return value[0] |
| return _first_input(value) |
|
|
|
|
| def _hidden_project_input_link(hidden_inputs: Any, name: str) -> Any | None: |
| """Recover the original prompt link after an input was materialized.""" |
| prompt = _first_input(getattr(hidden_inputs, "prompt", None)) |
| unique_id = str(_first_input(getattr(hidden_inputs, "unique_id", None), "")) |
| if not isinstance(prompt, dict) or not unique_id: |
| return None |
| node = prompt.get(unique_id) |
| if not isinstance(node, dict): |
| return None |
| inputs = node.get("inputs") |
| if not isinstance(inputs, dict): |
| return None |
| value = inputs.get(name) |
| return value if is_link(value) else None |
|
|
|
|
| def _require_minimax_h3_model(model: Any) -> None: |
| """Reject project expansion for models other than ComfyUI's MiniMaxH3.""" |
| base_model = getattr(model, "model", None) |
| model_config = getattr(base_model, "model_config", None) |
| config_name = type(model_config).__name__ if model_config is not None else "unknown" |
| unet_config = getattr(model_config, "unet_config", None) |
| image_model = ( |
| unet_config.get("image_model") |
| if isinstance(unet_config, dict) |
| else None |
| ) |
| if config_name != "MiniMaxH3" and image_model != "minimax_h3": |
| raise ValueError( |
| "easy multitrackProject currently supports only MiniMaxH3 models; " |
| f"received {config_name}." |
| ) |
|
|
|
|
| def _h3_node_mapping(node_id: str) -> Any | None: |
| mappings = getattr(comfy_nodes, "NODE_CLASS_MAPPINGS", {}) |
| return mappings.get(node_id) if isinstance(mappings, dict) else None |
|
|
|
|
| def _h3_required_node_defaults(node_id: str) -> dict[str, Any]: |
| node_class = _h3_node_mapping(node_id) |
| if node_class is None: |
| return {} |
| input_types = getattr(node_class, "INPUT_TYPES", None) |
| if not callable(input_types): |
| return {} |
| try: |
| schema = input_types() |
| except (AttributeError, RuntimeError, TypeError) as error: |
| raise RuntimeError(f"Unable to inspect {node_id} inputs: {error}") from error |
| required = schema.get("required", {}) if isinstance(schema, dict) else {} |
| defaults: dict[str, Any] = {} |
| for name, specification in required.items(): |
| if ( |
| isinstance(specification, (list, tuple)) |
| and len(specification) > 1 |
| and isinstance(specification[1], dict) |
| and "default" in specification[1] |
| ): |
| defaults[name] = specification[1]["default"] |
| elif ( |
| isinstance(specification, (list, tuple)) |
| and specification |
| and isinstance(specification[0], (list, tuple)) |
| and specification[0] |
| ): |
| defaults[name] = specification[0][0] |
| return defaults |
|
|
|
|
| def _h3_image_resize_inputs( |
| image: Any, width: int, height: int |
| ) -> dict[str, Any]: |
| node_class = _h3_node_mapping("ImageResizeKJv2") |
| if node_class is None: |
| raise RuntimeError( |
| "Dual H3 sampling without a latent upscale model requires " |
| "ImageResizeKJv2 from ComfyUI-KJNodes." |
| ) |
| input_types = getattr(node_class, "INPUT_TYPES", None) |
| schema = input_types() if callable(input_types) else {} |
| required = schema.get("required", {}) if isinstance(schema, dict) else {} |
| method_spec = required.get("upscale_method") |
| methods = method_spec[0] if isinstance(method_spec, (list, tuple)) else [] |
| if "nvidia_rtx_vsr" not in methods: |
| raise RuntimeError( |
| "The installed ImageResizeKJv2 does not support the required " |
| "nvidia_rtx_vsr upscale method." |
| ) |
| inputs = _h3_required_node_defaults("ImageResizeKJv2") |
| inputs.update( |
| { |
| "image": image, |
| "width": width, |
| "height": height, |
| "upscale_method": "nvidia_rtx_vsr", |
| } |
| ) |
| return inputs |
|
|
|
|
| def _h3_latent_upscale_inputs( |
| latent: Any, |
| model_name: str, |
| width: int, |
| height: int, |
| ) -> dict[str, Any]: |
| return { |
| "latent": latent, |
| "model_name": model_name, |
| "mode": "target dimensions", |
| "mode.width": width, |
| "mode.height": height, |
| "align": 32, |
| "enable_temporal_chunking": True, |
| "force_unload": True, |
| } |
|
|
|
|
| def _h3_encode_context_media( |
| graph: GraphBuilder, |
| images: Any, |
| audio: Any, |
| vae: Any, |
| audio_vae: Any, |
| node_prefix: str, |
| context_frames: int = 22, |
| ) -> Any: |
| """Encode a phase-aligned video suffix and the delivered audio timeline.""" |
| video_tail = graph.node( |
| "easy h3ContextMediaTrim", |
| id=f"{node_prefix}_encode_trim", |
| images=images, |
| audio=audio, |
| trim_frames=0, |
| output_frames=int(context_frames), |
| phase_align_video_encode=True, |
| ) |
| encoded_video = graph.node( |
| "VAEEncode", |
| id=f"{node_prefix}_video_encode", |
| pixels=video_tail.out(0), |
| vae=vae, |
| ) |
| encoded_audio = graph.node( |
| "VAEEncodeAudio", |
| id=f"{node_prefix}_audio_encode", |
| audio=video_tail.out(1), |
| vae=audio_vae, |
| ) |
| return graph.node( |
| "LTXVConcatAVLatent", |
| id=f"{node_prefix}_concat", |
| video_latent=encoded_video.out(0), |
| audio_latent=encoded_audio.out(0), |
| ).out(0) |
|
|
|
|
| def _h3_encode_audio_context( |
| graph: GraphBuilder, |
| audio: Any, |
| audio_vae: Any, |
| trim_frames: Any, |
| output_frames: Any, |
| fps: float, |
| pad_audio: bool, |
| prefix: str, |
| ) -> tuple[Any, Any]: |
| """Trim and encode an audio-only context without touching the video VAE.""" |
| trimmed = graph.node( |
| "easy h3ContextMediaTrim", |
| id=f"{prefix}_trim", |
| audio=audio, |
| trim_frames=trim_frames, |
| output_frames=output_frames, |
| fps=fps, |
| pad_audio=pad_audio, |
| ).out(1) |
| encoded = graph.node( |
| "VAEEncodeAudio", id=f"{prefix}_encode", audio=trimmed, vae=audio_vae, |
| ).out(0) |
| context = graph.node( |
| "easy h3AudioContextLatent", id=f"{prefix}_latent", |
| audio_latent=encoded, output_frames=output_frames, |
| ).out(0) |
| return trimmed, context |
|
|
| def _timed_h3_project_graph( |
| graph: GraphBuilder, |
| project_name: str, |
| segment_nodes: dict[str, int] | None = None, |
| ) -> dict[str, Any]: |
| """Tag timing and segment cache lifetimes without changing node inputs.""" |
| expanded = graph.finalize() |
| timed_types = { |
| "SamplerCustomAdvanced", |
| "easy h3SamplingPreviewSampler", |
| "VAEEncode", |
| "VAEEncodeAudio", |
| "VAEDecode", |
| "VAEDecodeAudio", |
| } |
| persistent_media_types = { |
| "easy h3ProjectStaticPrepare", |
| "easy multiTrackTaskOutput", |
| } |
| for node_id, node in expanded.items(): |
| if ( |
| segment_nodes is not None |
| and node_id in segment_nodes |
| and node["class_type"] not in persistent_media_types |
| ): |
| node.setdefault("_meta", {})[SEGMENT_META] = segment_nodes[node_id] |
| if node["class_type"] == "easy h3ProjectArtifact": |
| node["_meta"][BOUNDARY_META] = True |
| if node["class_type"] not in timed_types: |
| continue |
| target = _h3_node_mapping(node["class_type"]) |
| if target is not None: |
| instrument_node_timing(target) |
| operation = node_id.rsplit(".", 1)[-1] |
| node.setdefault("_meta", {})["easy_media_timing"] = f"{project_name} / {operation}" |
| if segment_nodes: |
| install_project_memory_cleanup() |
| return expanded |
|
|
| def _h3_resolve_pass_sampling( |
| graph: GraphBuilder, |
| *, |
| pass_name: str, |
| sampler: Any, |
| sigmas: Any, |
| preset_name: str, |
| has_second_pass: bool, |
| is_turbo: bool, |
| ) -> tuple[Any, Any]: |
| if preset_name == "custom" or sampler is not None or sigmas is not None: |
| if sampler is None or sigmas is None: |
| raise ValueError( |
| f"Custom H3 {pass_name.replace('_', ' ')} sampling requires " |
| "both sampler and sigmas." |
| ) |
| return sampler, sigmas |
|
|
| preset = select_h3_preset( |
| load_h3_presets(), |
| preset_name, |
| "dual" if has_second_pass else "single", |
| is_turbo, |
| ) |
| sampler_key = "sampler_2nd" if pass_name == "second_pass" else "sampler" |
| sigmas_key = "sigmas_2nd" if pass_name == "second_pass" else "sigmas" |
| sampler = graph.node( |
| "KSamplerSelect", |
| id=f"{pass_name}_sampler", |
| sampler_name=preset.get(sampler_key, preset["sampler"]), |
| ).out(0) |
| sigma_node = graph.node( |
| "ManualSigmas", |
| id=f"{pass_name}_sigmas", |
| sigmas=preset.get(sigmas_key, preset["sigmas"]), |
| ) |
| sigmas = sigma_node.out(0) |
| if has_second_pass and "split_step" in preset: |
| split = graph.node( |
| "SplitSigmas", |
| id=f"{pass_name}_split_sigmas", |
| sigmas=sigmas, |
| step=int(preset["split_step"]), |
| ) |
| sigmas = split.out(1 if pass_name == "second_pass" else 0) |
| return sampler, sigmas |
|
|
|
|
| def _h3_resolve_context_second_pass_sigmas( |
| graph: GraphBuilder, |
| *, |
| preset_name: str, |
| is_turbo: bool, |
| has_custom_second_pass_sampling: bool, |
| ) -> Any | None: |
| """Build the preset-only sigma schedule used by context pass two.""" |
| if has_custom_second_pass_sampling or preset_name == "custom": |
| return None |
| preset = select_h3_preset( |
| load_h3_presets(), |
| preset_name, |
| "dual", |
| is_turbo, |
| ) |
| context_sigmas = preset.get("sigmas_2nd_context") |
| if context_sigmas is None: |
| return None |
| return graph.node( |
| "ManualSigmas", |
| id="second_pass_context_sigmas", |
| sigmas=context_sigmas, |
| ).out(0) |
|
|
|
|
| def _h3_sampling_mode_config(value: Any) -> tuple[str, dict[str, Any]]: |
| """Normalize the DynamicCombo value and accept a plain legacy mode value.""" |
| config = _first_input(value) |
| if config is None: |
| return "single", {} |
| if isinstance(config, str): |
| config = {"sampling_mode": config} |
| if not isinstance(config, dict): |
| raise TypeError("sampling_mode must be a DynamicCombo configuration dictionary.") |
|
|
| sampling_mode = str(_first_input(config.get("sampling_mode"), "single")) |
| |
| if sampling_mode == "dual_selflift": |
| sampling_mode = "selflift" |
| if sampling_mode not in {"single", "dual", "selflift", "passthrough"}: |
| raise ValueError("sampling_mode must be 'single', 'dual', 'selflift', or 'passthrough'") |
| return sampling_mode, config |
|
|
|
|
| def _h3_tiling_config(value: Any) -> tuple[bool, int]: |
| config = _first_input(value) |
| if config is None: |
| return False, 0 |
| if isinstance(config, str): |
| enabled = config.lower() == "true" |
| return enabled, 2 if enabled else 0 |
| if not isinstance(config, dict): |
| raise TypeError("enabled_tiling must be a DynamicCombo configuration dictionary") |
| enabled = str(_first_input(config.get("enabled_tiling"), "false")).lower() == "true" |
| if not enabled: |
| return False, 0 |
| tile_count = int(_first_input(config.get("tile_count"), 2)) |
| if not 2 <= tile_count <= 8: |
| raise ValueError("tile_count must be between 2 and 8") |
| return True, tile_count |
|
|
|
|
| def _h3_resolve_selflift_sigmas( |
| graph: GraphBuilder, |
| *, |
| sigmas: Any, |
| preset_name: str, |
| is_turbo: bool, |
| ) -> Any: |
| """Resolve one complete schedule for the progressive SelfLift sampler.""" |
| if sigmas is not None: |
| return sigmas |
| if preset_name == "custom": |
| raise ValueError( |
| "selflift with the custom sampling plan requires sigmas; " |
| "the sampler itself is always Euler" |
| ) |
| preset = select_h3_preset( |
| load_h3_presets(), |
| preset_name, |
| "single", |
| is_turbo, |
| ) |
| return graph.node( |
| "ManualSigmas", |
| id="selflift_sigmas", |
| sigmas=preset["sigmas"], |
| ).out(0) |
|
|
|
|
| def _h3_second_pass_model( |
| value: Any, |
| *, |
| model: Any, |
| ) -> Any: |
| """Resolve the optional second-pass model while preserving latent compatibility.""" |
| model_loader = _first_input(value) |
| if model_loader is None: |
| return model |
| if not isinstance(model_loader, dict): |
| raise TypeError("model_loader_2nd must contain a FAST_MODEL_LOADER dictionary.") |
|
|
| second_model = model_loader.get("model") |
| if second_model is None: |
| raise ValueError("model_loader_2nd is missing required component: model") |
| return second_model |
|
|
|
|
| class EasyH3SamplingPreviewSampler(io.ComfyNode): |
| """SamplerCustomAdvanced with an optional preview-VAE event callback.""" |
|
|
| @classmethod |
| def define_schema(cls) -> io.Schema: |
| return io.Schema( |
| node_id="easy h3SamplingPreviewSampler", |
| display_name="H3 Sampling Preview Sampler", |
| category="EasyUse/H3/dev", |
| inputs=[ |
| io.Noise.Input("noise"), |
| io.Guider.Input("guider"), |
| io.Sampler.Input("sampler"), |
| io.Sigmas.Input("sigmas"), |
| io.Latent.Input("latent_image"), |
| io.Boolean.Input("enabled_tiling", default=False, optional=True), |
| io.Int.Input( |
| "tile_count", |
| default=2, |
| min=2, |
| max=8, |
| step=1, |
| optional=True, |
| ), |
| io.Vae.Input("preview_vae", optional=True), |
| io.String.Input("preview_node_id", default="", optional=True), |
| io.Int.Input( |
| "generated_frame_count", default=1, min=1, optional=True |
| ), |
| io.Float.Input("preview_fps", default=24.0, min=0.01, optional=True), |
| io.Int.Input("segment_index", default=0, min=0, optional=True), |
| io.String.Input("sampling_pass", default="sampling", optional=True), |
| ], |
| outputs=[ |
| io.Latent.Output(display_name="output"), |
| io.Latent.Output(display_name="denoised_output"), |
| ], |
| is_dev_only=True, |
| ) |
|
|
| @classmethod |
| def execute( |
| cls, |
| noise: Any, |
| guider: Any, |
| sampler: Any, |
| sigmas: Any, |
| latent_image: dict[str, Any], |
| enabled_tiling: bool = False, |
| tile_count: int = 2, |
| preview_vae: Any | None = None, |
| preview_node_id: str = "", |
| generated_frame_count: int = 1, |
| preview_fps: float = 24.0, |
| segment_index: int = 0, |
| sampling_pass: str = "sampling", |
| ) -> io.NodeOutput: |
| import comfy.model_management |
| import comfy.nested_tensor |
| import comfy.sample |
| import comfy.utils |
| import latent_preview |
|
|
| from ..utils.sampling_preview import ( |
| create_preview_callback, |
| preview_frame_count, |
| preview_playback_fps, |
| ) |
|
|
| latent = latent_image.copy() |
| samples = comfy.sample.fix_empty_latent_channels( |
| guider.model_patcher, |
| latent["samples"], |
| latent.get("downscale_ratio_spacial"), |
| latent.get("downscale_ratio_temporal"), |
| ) |
| latent["samples"] = samples |
| sampling_guider = guider |
| if enabled_tiling: |
| streams = ( |
| list(samples.unbind()) |
| if getattr(samples, "is_nested", False) |
| else [samples] |
| ) |
| from ..modules.selflift.h3_tiling import tiled_model |
|
|
| patched_model = tiled_model( |
| guider.model_patcher, |
| [tuple(stream.shape) for stream in streams], |
| tile_count=int(tile_count), |
| ) |
| sampling_guider = copy.copy(guider) |
| sampling_guider.model_patcher = patched_model |
| sampling_guider.model_options = patched_model.model_options |
|
|
| noise_mask = latent.get("noise_mask") |
| x0_output: dict[str, Any] = {} |
| if preview_vae is not None and preview_node_id: |
| preview_callback = create_preview_callback( |
| sampling_guider.model_patcher, |
| preview_vae, |
| node_id=preview_node_id, |
| requested_frames=preview_frame_count(generated_frame_count), |
| fps=preview_playback_fps(generated_frame_count, preview_fps), |
| segment_index=int(segment_index), |
| sampling_pass=sampling_pass, |
| ) |
| progress = comfy.utils.ProgressBar(int(sigmas.shape[-1]) - 1) |
|
|
| def callback(step: int, x0: Any, state: Any, total: int) -> None: |
| x0_output["x0"] = x0 |
| preview_callback(step, x0, state, total) |
| progress.update_absolute(step + 1, total) |
| else: |
| callback = latent_preview.prepare_callback( |
| sampling_guider.model_patcher, |
| int(sigmas.shape[-1]) - 1, |
| x0_output, |
| ) |
|
|
| disable_pbar = not comfy.utils.PROGRESS_BAR_ENABLED |
| sampled = sampling_guider.sample( |
| noise.generate_noise(latent), |
| samples, |
| sampler, |
| sigmas, |
| denoise_mask=noise_mask, |
| callback=callback, |
| disable_pbar=disable_pbar, |
| seed=noise.seed, |
| ).to(comfy.model_management.intermediate_device()) |
|
|
| output = latent.copy() |
| output.pop("downscale_ratio_spacial", None) |
| output.pop("downscale_ratio_temporal", None) |
| output["samples"] = sampled |
| if "x0" not in x0_output: |
| return io.NodeOutput(output, output) |
|
|
| denoised = x0_output["x0"] |
| if getattr(sampled, "is_nested", False) and not getattr( |
| denoised, "is_nested", False |
| ): |
| latent_shapes = [tensor.shape for tensor in sampled.unbind()] |
| denoised = comfy.nested_tensor.NestedTensor( |
| comfy.utils.unpack_latents(denoised, latent_shapes) |
| ) |
| denoised = sampling_guider.model_patcher.model.process_latent_out( |
| denoised.cpu() |
| ) |
| denoised_output = latent.copy() |
| denoised_output["samples"] = denoised |
| return io.NodeOutput(output, denoised_output) |
|
|
|
|
|
|
| class EasyH3ProjectStaticPrepare(io.ComfyNode): |
| """Resolve seed-independent model, media, and sampling resources.""" |
|
|
| @classmethod |
| def define_schema(cls) -> io.Schema: |
| return io.Schema( |
| node_id="easy h3ProjectStaticPrepare", |
| display_name="H3 Project Static Prepare", |
| category="EasyUse/H3/dev", |
| is_dev_only=True, |
| enable_expand=True, |
| inputs=[ |
| TYPE_FAST_MODEL_LOADER.Input("model_loader", optional=True), |
| TYPE_FAST_MODEL_LOADER.Input("model_loader_2nd", optional=True), |
| TYPE_TRACKS_INFO.Input("tracks_info", optional=True), |
| TYPE_H3_PROJECT_STATIC_DATA.Input("project_static", optional=True), |
| io.AnyType.Input( |
| "previous", |
| optional=True, |
| tooltip="Optional dependency on the previous saved segment.", |
| ), |
| io.Int.Input("task_start_frame", default=0, min=0, optional=True), |
| io.Int.Input("task_index", default=0, min=0, optional=True), |
| io.Int.Input("task_duration_frames", default=1, min=1, optional=True), |
| io.Float.Input("fps", default=24.0, min=0.001, optional=True), |
| io.Combo.Input("generation_mode", options=["reference", "multi_frames", "last_frame"], default="multi_frames", optional=True), |
| io.String.Input("sampling_plan", default="light", optional=True), |
| io.Combo.Input("sampling_mode", options=["single", "dual", "selflift", "passthrough"], default="single", optional=True), |
| io.Sampler.Input("sampler", optional=True, raw_link=True), |
| io.Sigmas.Input("sigmas", optional=True, raw_link=True), |
| io.Sampler.Input("sampler_2nd", optional=True, raw_link=True), |
| io.Sigmas.Input("sigmas_2nd", optional=True, raw_link=True), |
| io.Boolean.Input("run_second_pass", default=False, optional=True), |
| io.Boolean.Input("has_context_second_pass", default=False, optional=True), |
| io.Boolean.Input("turbo_hint", default=False, optional=True), |
| ], |
| outputs=[ |
| TYPE_H3_PROJECT_STATIC_DATA.Output("PROJECT_STATIC"), |
| TYPE_TRACKS_INFO.Output("TASK_TRACKS_INFO"), |
| io.Model.Output("MODEL"), io.Model.Output("MODEL_2ND"), |
| io.Clip.Output("CLIP"), io.Vae.Output("VAE"), |
| io.Vae.Output("AUDIO_VAE"), io.Vae.Output("PREVIEW_VAE"), |
| io.Audio.Output("LOCKED_AUDIO"), |
| io.Sampler.Output("SAMPLER"), io.Sigmas.Output("SIGMAS"), |
| io.Sampler.Output("SAMPLER_2ND"), io.Sigmas.Output("SIGMAS_2ND"), |
| io.Sigmas.Output("CONTEXT_SIGMAS_2ND"), |
| ], |
| ) |
|
|
| @classmethod |
| def execute( |
| cls, |
| model_loader: Any | None = None, |
| model_loader_2nd: Any | None = None, |
| tracks_info: Any | None = None, |
| project_static: Any | None = None, |
| previous: Any | None = None, |
| task_start_frame: int = 0, |
| task_index: int = 0, |
| task_duration_frames: int = 1, |
| fps: float = 24.0, |
| generation_mode: str = "multi_frames", |
| sampling_plan: str = "light", |
| sampling_mode: str = "single", |
| sampler: Any | None = None, |
| sigmas: Any | None = None, |
| sampler_2nd: Any | None = None, |
| sigmas_2nd: Any | None = None, |
| run_second_pass: bool = False, |
| has_context_second_pass: bool = False, |
| turbo_hint: bool = False, |
| ) -> io.NodeOutput: |
| del previous |
| try: |
| if project_static is not None: |
| if not isinstance(project_static, dict): |
| raise TypeError("project_static must contain H3 project static data") |
| segment_cache = project_static.get("_segment_cache") |
| segment_cache_key = ( |
| "h3_project_segment", |
| int(task_start_frame), |
| int(task_index), |
| int(task_duration_frames), |
| float(fps), |
| str(generation_mode), |
| ) |
| cached_segment = ( |
| segment_cache.get(segment_cache_key) |
| if isinstance(segment_cache, dict) |
| else None |
| ) |
| if ( |
| isinstance(cached_segment, tuple) |
| and len(cached_segment) == 2 |
| ): |
| cached_task_info = cached_segment[0] |
| cached_task_info["_easy_media_cache_status"] = { |
| **project_static.get("_cache_status", {}), |
| "segment_media": "cache-hit", |
| } |
| return io.NodeOutput( |
| project_static, |
| cached_task_info, |
| None, None, None, None, None, None, |
| cached_segment[1], |
| None, None, None, None, None, |
| ) |
| task_audio, task_video, task_locked_audio = crop_multitrack_project_media( |
| project_static["shared_audio"], project_static["shared_video"], |
| project_static["full_locked_audio"], int(task_start_frame), |
| int(task_duration_frames), float(fps), |
| ) |
| task_info = prepare_multitrack_project_task_info( |
| project_static["task_tracks_info_base"], project_static["shared_images"], |
| task_audio if generation_mode == "reference" else [], |
| task_video if generation_mode == "reference" else [], |
| task_entry=next( |
| (entry for index, entry in enumerate(h3_task_entries(project_static["task_tracks_info_base"])) |
| if index == int(task_index)), |
| None, |
| ), |
| ) |
| multitrack_runtime_cache(task_info, create=True) |
| task_info["_easy_media_cache_status"] = { |
| **project_static.get("_cache_status", {}), |
| "segment_media": "first-load", |
| } |
| if isinstance(segment_cache, dict): |
| segment_cache[segment_cache_key] = ( |
| task_info, |
| task_locked_audio, |
| ) |
| return io.NodeOutput( |
| project_static, task_info, None, None, None, None, None, |
| None, task_locked_audio, |
| None, None, None, None, None, |
| ) |
|
|
| media_data = None |
| locked = None |
| if tracks_info is not None: |
| runtime_cache = multitrack_runtime_cache( |
| tracks_info, |
| create=True, |
| ) |
| cached_media = ( |
| runtime_cache.get("h3_project_media") |
| if isinstance(runtime_cache, dict) |
| else None |
| ) |
| if isinstance(cached_media, dict): |
| media_data = cached_media |
| locked = cached_media.get("full_locked_audio") |
| media_data["_cache_status"] = { |
| "project_media": "cache-hit", |
| } |
| else: |
| info = parse_tracks_info(tracks_info) |
| log_node_info( |
| "H3 Project Static Prepare", |
| "loading project media (incl. locked video audio)", |
| ) |
| task_base, images, audio, video, locked = ( |
| prepare_multitrack_project_media(info) |
| ) |
| log_node_info("H3 Project Static Prepare", "project media loaded") |
| task_base.pop(MULTITRACK_RUNTIME_CACHE_KEY, None) |
| media_data = { |
| "task_tracks_info_base": task_base, |
| "shared_images": images, |
| "shared_audio": audio, |
| "shared_video": video, |
| "full_locked_audio": locked, |
| "_segment_cache": {}, |
| "_cache_status": { |
| "project_media": "first-load", |
| }, |
| } |
| if isinstance(runtime_cache, dict): |
| runtime_cache["h3_project_media"] = media_data |
| if model_loader is None: |
| return io.NodeOutput( |
| media_data, None, None, None, None, None, None, None, |
| locked, None, None, None, None, None, |
| ) |
|
|
| loader = _first_input(model_loader) |
| if not isinstance(loader, dict): |
| raise TypeError("model_loader must contain a FAST_MODEL_LOADER dictionary") |
| model, clip, vae = loader.get("model"), loader.get("clip"), loader.get("vae") |
| audio_vae, preview_vae = loader.get("audio_vae"), loader.get("preview_vae") |
| missing = [name for name, value in (("model", model), ("clip", clip), |
| ("vae", vae), ("audio_vae", audio_vae)) if value is None] |
| if missing: |
| raise ValueError("model_loader is missing required components: " + ", ".join(missing)) |
| _require_minimax_h3_model(model) |
| second_model = _h3_second_pass_model(model_loader_2nd, model=model) |
| _require_minimax_h3_model(second_model) |
| static_data = { |
| "model": model, "second_model": second_model, "clip": clip, |
| "vae": vae, "audio_vae": audio_vae, |
| "preview_vae": preview_vae, |
| } |
| if media_data is not None: |
| static_data = {**media_data, **static_data} |
| first_is_turbo = detect_turbo_model(model).is_turbo or bool(turbo_hint) |
| second_is_turbo = first_is_turbo |
| if run_second_pass and second_model is not model: |
| second_is_turbo = detect_turbo_model(second_model).is_turbo |
| graph = GraphBuilder() |
| first_sampler = None |
| if sampling_mode == "passthrough": |
| first_sampler = first_sigmas = None |
| elif sampling_mode == "selflift": |
| first_sigmas = _h3_resolve_selflift_sigmas( |
| graph, sigmas=sigmas, preset_name=str(sampling_plan), |
| is_turbo=first_is_turbo, |
| ) |
| else: |
| first_sampler, first_sigmas = _h3_resolve_pass_sampling( |
| graph, pass_name="first_pass", sampler=sampler, sigmas=sigmas, |
| preset_name=str(sampling_plan), has_second_pass=sampling_mode == "dual", |
| is_turbo=first_is_turbo, |
| ) |
| second_sampler = second_sigmas = context_sigmas = None |
| if run_second_pass: |
| custom_second = sampler_2nd is not None or sigmas_2nd is not None |
| second_sampler, second_sigmas = _h3_resolve_pass_sampling( |
| graph, pass_name="second_pass", sampler=sampler_2nd, |
| sigmas=sigmas_2nd, preset_name=str(sampling_plan), |
| has_second_pass=True, is_turbo=second_is_turbo, |
| ) |
| if has_context_second_pass: |
| context_sigmas = _h3_resolve_context_second_pass_sigmas( |
| graph, preset_name=str(sampling_plan), is_turbo=second_is_turbo, |
| has_custom_second_pass_sampling=custom_second, |
| ) |
| return io.NodeOutput( |
| static_data, None, model, second_model, clip, vae, audio_vae, |
| preview_vae, locked, first_sampler, first_sigmas, second_sampler, |
| second_sigmas, context_sigmas, expand=graph.finalize(), |
| ) |
| except (KeyError, TypeError, ValueError, RuntimeError) as error: |
| raise RuntimeError(f"Failed to prepare H3 project static inputs: {error}") from error |
|
|
|
|
| class EasyMultiTrackProject(io.ComfyNode): |
| @classmethod |
| def _sampling_plan_options(cls) -> list[str]: |
| """Return sorted sampling plan keys: user presets first, then 'custom'.""" |
| return get_h3_preset_keys() |
|
|
| @classmethod |
| def define_schema(cls) -> io.Schema: |
| return io.Schema( |
| node_id="easy multitrackProject", |
| display_name="MultiTrack Project", |
| category="EasyUse/MultiTrackEditor", |
| description=( |
| "Build and execute a multi-track Moxie project with optional " |
| "first-pass and second-pass sampling." |
| ), |
| is_input_list=True, |
| enable_expand=True, |
| not_idempotent=True, |
| inputs=[ |
| TYPE_TRACKS_INFO.Input("tracks_info"), |
| TYPE_FAST_MODEL_LOADER.Input( |
| "model_loader", raw_link=True, lazy=True, |
| ), |
| TYPE_FAST_MODEL_LOADER.Input( |
| "model_loader_2nd", |
| optional=True, |
| raw_link=True, |
| lazy=True, |
| tooltip=( |
| "Optional second-pass model for Dual sampling or the " |
| "high-resolution SelfLift stage. Encoding and VAE " |
| "components remain from the first-pass loader." |
| ), |
| ), |
| io.Sampler.Input( |
| "sampler", optional=True, raw_link=True, lazy=True, |
| ), |
| io.Sampler.Input("sampler_2nd", optional=True, raw_link=True, lazy=True, tooltip=( |
| "Optional second-pass sampler. " |
| )), |
| io.Sigmas.Input( |
| "sigmas", optional=True, raw_link=True, lazy=True, |
| ), |
| io.Sigmas.Input("sigmas_2nd", optional=True, raw_link=True, lazy=True, tooltip=( |
| "Optional second-pass sigmas. " |
| )), |
| io.String.Input("project_name", default=""), |
| io.Combo.Input( |
| "project_save", |
| options=["new", "override"], |
| default="override", |
| ), |
| io.Int.Input( |
| "segment_start_number", |
| default=1, |
| min=1, |
| max=0x7FFFFFFF, |
| step=1, |
| tooltip="The task segment start number." |
| ), |
| io.Int.Input( |
| "segment_count", |
| default=-1, |
| min=-1, |
| max=0x7FFFFFFF, |
| step=1, |
| tooltip=( |
| "Maximum task segments in this queue. When set to -1, " |
| "override mode deletes saved segments from " |
| "segment_start_number onward before regeneration; new " |
| "mode preserves existing video and latent files." |
| ), |
| ), |
| io.Int.Input( |
| "seed", |
| default=42, |
| min=0, |
| max=0xFFFFFFFFFFFFFFFF, |
| step=1, |
| control_after_generate=io.ControlAfterGenerate.fixed, |
| ), |
| io.Combo.Input( |
| "sampling_plan", |
| options=cls._sampling_plan_options(), |
| default="light", |
| ), |
| io.DynamicCombo.Input( |
| "sampling_mode", |
| options=[ |
| io.DynamicCombo.Option("single", []), |
| io.DynamicCombo.Option("dual", []), |
| io.DynamicCombo.Option( |
| "selflift", |
| [ |
| io.Float.Input( |
| "transition_ratio", |
| default=0.6, |
| min=0.05, |
| max=0.95, |
| step=0.05, |
| tooltip=( |
| "Fraction of denoiser evaluations performed " |
| "at low resolution." |
| ), |
| ), |
| io.Float.Input( |
| "lowres_scale", |
| default=0.6, |
| min=0.25, |
| max=1.0, |
| step=0.001, |
| round=0.001, |
| extra_dict={"precision": 3}, |
| tooltip=( |
| "Scale of the low-resolution prefix relative " |
| "to the target latent." |
| ), |
| ), |
| ], |
| ), |
| io.DynamicCombo.Option("passthrough", []), |
| ], |
| ), |
| io.Boolean.Input( |
| "1st_pass_only", |
| default=False, |
| tooltip=( |
| "Run and save only the first selected segment's " |
| "first pass. Turn this off on the next run to " |
| "resume directly from that checkpoint at pass two." |
| ), |
| ), |
| io.Boolean.Input("disable_2nd_noise", default=False, tooltip="Disable noise in second-pass for dual-sampling"), |
| io.Float.Input( |
| "upscale_by", |
| default=1.250, |
| min=1.0, |
| max=8.0, |
| step=0.001, |
| round=0.001, |
| extra_dict={"precision": 3}, |
| ), |
| io.Combo.Input( |
| "upscale_model", |
| options=["None"] |
| + folder_paths.get_filename_list("latent_upscale_models"), |
| default="None", |
| ), |
| io.DynamicCombo.Input( |
| "enabled_tiling", |
| options=[ |
| io.DynamicCombo.Option("false", []), |
| io.DynamicCombo.Option( |
| "true", |
| [ |
| io.Int.Input( |
| "tile_count", |
| default=2, |
| min=2, |
| max=8, |
| step=1, |
| tooltip="Spatial tile count shared by Dual and SelfLift high-res sampling.", |
| ), |
| ], |
| ), |
| ], |
| tooltip="Enable shared high-resolution H3 spatial tiling.", |
| ), |
| ], |
| hidden=[io.Hidden.prompt, io.Hidden.unique_id], |
| outputs=[ |
| io.String.Output("PROJECT_NAME"), |
| io.Audio.Output("LOCKED_AUDIO"), |
| ], |
| ) |
|
|
| @classmethod |
| def execute(cls, **kwargs: Any) -> io.NodeOutput: |
| node_name = "MultiTrack Project" |
| progress_total = 100 |
| progress_bar = ProgressBar(progress_total) |
| progress_value = 0 |
|
|
| def report_step(target: float) -> None: |
| nonlocal progress_value |
| progress_value = max( |
| progress_value, |
| min(progress_total, int(round(target))), |
| ) |
| progress_bar.update_absolute(progress_value, progress_total) |
|
|
| report_step(0) |
| selected_model_loader = _raw_project_input(kwargs.get("model_loader")) |
| uses_linked_prepare = is_link(selected_model_loader) |
| if not uses_linked_prepare and not isinstance(selected_model_loader, dict): |
| raise TypeError("model_loader must contain a FAST_MODEL_LOADER dictionary.") |
|
|
| model = None if uses_linked_prepare else selected_model_loader.get("model") |
| clip = None if uses_linked_prepare else selected_model_loader.get("clip") |
| vae = None if uses_linked_prepare else selected_model_loader.get("vae") |
| audio_vae = None if uses_linked_prepare else selected_model_loader.get("audio_vae") |
| preview_vae = None if uses_linked_prepare else selected_model_loader.get("preview_vae") |
| preview_node_id = str( |
| _first_input( |
| getattr(getattr(cls, "hidden", None), "unique_id", None), |
| "", |
| ) |
| ) |
| has_sampling_preview = bool(preview_node_id) and (uses_linked_prepare or preview_vae is not None) |
| missing_components = [] if uses_linked_prepare else [ |
| name |
| for name, value in (("model", model), ("clip", clip), ("vae", vae)) |
| if value is None |
| ] |
| if missing_components: |
| raise ValueError( |
| "model_loader is missing required components: " |
| + ", ".join(missing_components) |
| ) |
| if not uses_linked_prepare: |
| _require_minimax_h3_model(model) |
| info = parse_tracks_info(kwargs.get("tracks_info")) |
| hidden_inputs = getattr(cls, "hidden", None) |
| validate_h3_project_outputs( |
| info, |
| getattr(hidden_inputs, "prompt", None), |
| getattr(hidden_inputs, "unique_id", None), |
| ) |
| report_step(5) |
|
|
| sampling_mode, sampling_config = _h3_sampling_mode_config( |
| kwargs.get("sampling_mode") |
| ) |
| is_passthrough = sampling_mode == "passthrough" |
| is_selflift = sampling_mode == "selflift" |
| has_second_pass = sampling_mode == "dual" |
| transition_ratio = 0.6 |
| lowres_scale = 0.6 |
| tiling_enabled, tile_count = _h3_tiling_config(kwargs.get("enabled_tiling")) |
| if is_selflift: |
| transition_ratio = float( |
| _first_input(sampling_config.get("transition_ratio"), 0.6) |
| ) |
| lowres_scale = float( |
| _first_input(sampling_config.get("lowres_scale"), 0.6) |
| ) |
| legacy_highres_tiling = bool( |
| _first_input(sampling_config.get("highres_tiling"), False) |
| ) |
| if legacy_highres_tiling and not tiling_enabled: |
| tiling_enabled = True |
| tile_count = 0 |
| first_pass_only = bool( |
| _first_input( |
| sampling_config.get("1st_pass_only"), |
| _first_input(kwargs.get("1st_pass_only"), False), |
| ) |
| ) |
| run_second_pass = has_second_pass and not first_pass_only |
| if is_selflift: |
| first_pass_only = False |
| disable_2nd_noise = bool( |
| _first_input( |
| sampling_config.get("disable_2nd_noise"), |
| _first_input(kwargs.get("disable_2nd_noise"), False), |
| ) |
| ) |
| second_model = model |
| second_model_loader = None |
| if run_second_pass or is_selflift: |
| configured_second_loader = sampling_config.get("model_loader_2nd") |
| second_model_loader = _raw_project_input( |
| configured_second_loader if configured_second_loader is not None |
| else kwargs.get("model_loader_2nd") |
| ) |
| if not uses_linked_prepare: |
| second_model = _h3_second_pass_model(second_model_loader, model=model) |
| _require_minimax_h3_model(second_model) |
| report_step(10) |
|
|
| hidden_inputs = getattr(cls, "hidden", None) |
| prompt_turbo_detection = None |
| turbo_detection = None if uses_linked_prepare else detect_turbo_model(model) |
| if uses_linked_prepare or not turbo_detection.is_turbo: |
| prompt_turbo_detection = detect_turbo_lora_from_prompt( |
| getattr(hidden_inputs, "prompt", None), |
| getattr(hidden_inputs, "unique_id", None), |
| ) |
| if uses_linked_prepare or prompt_turbo_detection is not None: |
| turbo_detection = prompt_turbo_detection |
| first_is_turbo = bool(turbo_detection and turbo_detection.is_turbo) |
| report_step(15) |
| second_turbo_detection = turbo_detection |
| if run_second_pass and not uses_linked_prepare and second_model is not model: |
| second_turbo_detection = detect_turbo_model(second_model) |
| report_step(16) |
| second_is_turbo = bool(second_turbo_detection and second_turbo_detection.is_turbo) |
|
|
| safe_project_name = safe_h3_project_name(kwargs.get("project_name")) |
| project_save = str(_first_input(kwargs.get("project_save"), "new")) |
| if project_save not in {"new", "override"}: |
| raise ValueError("project_save must be 'new' or 'override'") |
| upscale_by = float( |
| _first_input( |
| sampling_config.get("upscale_by"), |
| _first_input(kwargs.get("upscale_by"), 1.250), |
| ) |
| ) |
| if not math.isfinite(upscale_by) or upscale_by < 1: |
| raise ValueError( |
| "upscale_by must be a finite value greater than or equal to 1" |
| ) |
|
|
| editor_width = int(info["width"]) |
| editor_height = int(info["height"]) |
| audio_only = (editor_width, editor_height) == (32, 32) |
| fps = float(info["frame_rate"]) |
| |
| |
| |
| |
| |
| first_pass_width, first_pass_height = editor_width, editor_height |
| if sampling_mode == "single" and not audio_only: |
| half_width = max(32, editor_width // 2) |
| half_height = max(32, editor_height // 2) |
| if (half_width, half_height) != (32, 32): |
| first_pass_width, first_pass_height = half_width, half_height |
| target_width, target_height = h3_second_pass_dimensions( |
| editor_width, |
| editor_height, |
| run_second_pass, |
| upscale_by, |
| ) |
| |
| output_info = {**info, "width": target_width, "height": target_height} |
| initialize_h3_project( |
| safe_project_name, |
| output_info, |
| folder_paths.get_output_directory(), |
| ) |
| all_entries = h3_task_entries(info) |
| segment_start_number = int(_first_input(kwargs.get("segment_start_number"), 1)) |
| if segment_start_number < 1: |
| raise ValueError("segment_start_number must be at least 1") |
| segment_start_index = segment_start_number - 1 |
| segment_count = int(_first_input(kwargs.get("segment_count"), -1)) |
| selected_entries = select_h3_task_entries( |
| all_entries, |
| segment_start_index, |
| segment_count, |
| ) |
| if not selected_entries: |
| raise ValueError( |
| "No H3 task segments are available from segment_start_number." |
| ) |
|
|
| first_selected_index, first_selected_entry = selected_entries[0] |
| first_selected_task = first_selected_entry.get("task", {}) |
| first_selected_content = ( |
| first_selected_task.get("content", {}) |
| if isinstance(first_selected_task, dict) |
| else {} |
| ) |
| first_selected_continuity = ( |
| str(first_selected_content.get("continuity_mode", "shot")).lower() |
| if isinstance(first_selected_content, dict) |
| else "shot" |
| ) |
| if first_selected_continuity == "context_test": |
| first_selected_continuity = "context" |
| if ( |
| first_selected_index > 0 |
| and first_selected_continuity in H3_CONTEXT_CONTINUITY_MODES |
| and not is_passthrough |
| ): |
| previous_index = first_selected_index - 1 |
| if not has_h3_context_latent( |
| safe_project_name, |
| previous_index, |
| resolution="high", |
| output_directory=folder_paths.get_output_directory(), |
| ): |
| raise ValueError( |
| f"Cannot start segment {first_selected_index + 1} with " |
| f"{first_selected_continuity}: segment {previous_index + 1} " |
| "has no active context latent. Generate or restore the " |
| "previous segment first." |
| ) |
| if is_selflift and not has_h3_context_latent( |
| safe_project_name, |
| previous_index, |
| resolution="low", |
| output_directory=folder_paths.get_output_directory(), |
| allow_low_fallback=False, |
| ): |
| raise ValueError( |
| f"Cannot start SelfLift segment {first_selected_index + 1} " |
| f"with {first_selected_continuity}: segment " |
| f"{previous_index + 1} has no active low-resolution context " |
| "latent. Regenerate the previous segment with SelfLift first." |
| ) |
| resume_task_index: int | None = None |
| if run_second_pass and selected_entries: |
| first_selected_index = selected_entries[0][0] |
| if has_h3_first_pass_checkpoint( |
| safe_project_name, |
| first_selected_index, |
| folder_paths.get_output_directory(), |
| ): |
| resume_task_index = first_selected_index |
| log_node_info( |
| node_name, |
| f"Resuming segment {first_selected_index} from its first-pass checkpoint", |
| ) |
|
|
| if project_save == "override" and segment_count == -1: |
| clear_h3_project_segments_from( |
| safe_project_name, |
| ( |
| resume_task_index + 1 |
| if resume_task_index is not None |
| else segment_start_index |
| ), |
| folder_paths.get_output_directory(), |
| ) |
| report_step(19) |
|
|
| if first_pass_only and has_second_pass: |
| selected_entries = selected_entries[:1] |
| log_node_info( |
| node_name, |
| f"Found {len(all_entries)} segments; processing {len(selected_entries)}", |
| ) |
| report_step(20) |
| first_pass_seed = int(_first_input(kwargs.get("seed"), 42)) |
| second_pass_seed = first_pass_seed |
| selected_upscale_model = str( |
| _first_input( |
| sampling_config.get("upscale_model"), |
| _first_input(kwargs.get("upscale_model"), "None"), |
| ) |
| ) |
| if not uses_linked_prepare and audio_vae is None: |
| raise ValueError( |
| "model_loader must include audio_vae to decode Moxie audio." |
| ) |
| report_step(25) |
|
|
| graph = GraphBuilder() |
| report_step(27) |
| preset_name = str(_first_input(kwargs.get("sampling_plan"), "medium")) |
| has_context_second_pass = run_second_pass and any( |
| task_index > 0 and isinstance(entry.get("task"), dict) |
| and isinstance(entry["task"].get("content"), dict) |
| and str(entry["task"]["content"].get("continuity_mode", "shot")).lower() |
| in H3_CONTEXT_CONTINUITY_MODES for task_index, entry in selected_entries |
| ) |
| if uses_linked_prepare: |
| def raw_sampling_input(name: str) -> Any: |
| value = sampling_config.get(name) |
| return _raw_project_input(value if value is not None else kwargs.get(name)) |
|
|
| tracks_info_link = _hidden_project_input_link( |
| hidden_inputs, |
| "tracks_info", |
| ) |
| project_media_static = graph.node( |
| "easy h3ProjectStaticPrepare", |
| id="project_media_prepare", |
| tracks_info=tracks_info_link or info, |
| ) |
| model_inputs = { |
| "model_loader": selected_model_loader, |
| "sampling_plan": preset_name, "sampling_mode": sampling_mode, |
| "run_second_pass": run_second_pass, |
| "has_context_second_pass": has_context_second_pass, |
| "turbo_hint": first_is_turbo, |
| } |
| for name, value in ( |
| ("model_loader_2nd", second_model_loader), |
| ("sampler", raw_sampling_input("sampler")), |
| ("sigmas", raw_sampling_input("sigmas")), |
| ("sampler_2nd", raw_sampling_input("sampler_2nd")), |
| ("sigmas_2nd", raw_sampling_input("sigmas_2nd")), |
| ): |
| if value is not None: |
| model_inputs[name] = value |
| project_model_static = graph.node( |
| "easy h3ProjectStaticPrepare", |
| id="project_model_prepare", |
| **model_inputs, |
| ) |
| model, second_model = project_model_static.out(2), project_model_static.out(3) |
| clip, vae = project_model_static.out(4), project_model_static.out(5) |
| audio_vae, preview_vae = project_model_static.out(6), project_model_static.out(7) |
| full_locked_audio = project_media_static.out(8) |
| first_pass_sampler, first_pass_sigmas = project_model_static.out(9), project_model_static.out(10) |
| second_pass_sampler, second_pass_sigmas = project_model_static.out(11), project_model_static.out(12) |
| context_second_pass_sigmas = project_model_static.out(13) |
| task_tracks_info_base = shared_images = shared_audio = shared_video = None |
| else: |
| (task_tracks_info_base, shared_images, shared_audio, shared_video, |
| full_locked_audio) = prepare_multitrack_project_media(info) |
| first_pass_sampler = first_pass_sigmas = None |
| if not is_passthrough and any(task_index != resume_task_index for task_index, _ in selected_entries): |
| if is_selflift: |
| first_pass_sigmas = _h3_resolve_selflift_sigmas( |
| graph, sigmas=_first_input(kwargs.get("sigmas")), |
| preset_name=preset_name, is_turbo=first_is_turbo) |
| else: |
| first_pass_sampler, first_pass_sigmas = _h3_resolve_pass_sampling( |
| graph, pass_name="first_pass", sampler=_first_input(kwargs.get("sampler")), |
| sigmas=_first_input(kwargs.get("sigmas")), preset_name=preset_name, |
| has_second_pass=has_second_pass, is_turbo=first_is_turbo) |
| second_pass_sampler = second_pass_sigmas = context_second_pass_sigmas = None |
| if run_second_pass: |
| configured_sampler = _first_input(sampling_config.get("sampler_2nd"), _first_input(kwargs.get("sampler_2nd"))) |
| configured_sigmas = _first_input(sampling_config.get("sigmas_2nd"), _first_input(kwargs.get("sigmas_2nd"))) |
| custom_second = configured_sampler is not None or configured_sigmas is not None |
| second_pass_sampler, second_pass_sigmas = _h3_resolve_pass_sampling( |
| graph, pass_name="second_pass", sampler=configured_sampler, |
| sigmas=configured_sigmas, preset_name=preset_name, |
| has_second_pass=True, is_turbo=second_is_turbo) |
| if has_context_second_pass: |
| context_second_pass_sigmas = _h3_resolve_context_second_pass_sigmas( |
| graph, preset_name=preset_name, is_turbo=second_is_turbo, |
| has_custom_second_pass_sampling=custom_second) |
| report_step(31) |
|
|
| report_step(33) |
|
|
| previous_hires_context_latent: Any | None = None |
| previous_low_context_latent: Any | None = None |
| previous_artifact: Any | None = None |
| last_project_output: Any | None = None |
| report_step(35) |
|
|
| segment_total = len(selected_entries) |
| segment_nodes: dict[str, int] = {} |
| for segment_position, (task_index, entry) in enumerate(selected_entries): |
| previous_graph_nodes = set(graph.nodes) |
| def report_segment_step( |
| phase: float, |
| *, |
| current_position: int = segment_position, |
| ) -> None: |
| target = 35 + 60 * (current_position + phase) / segment_total |
| report_step(target) |
|
|
| task_type = h3_task_type(entry, info) |
| generation_mode = h3_generation_mode(task_type) |
| task = entry.get("task", {}) |
| content = task.get("content", {}) if isinstance(task, dict) else {} |
| continuity_mode = ( |
| str(content.get("continuity_mode", "shot")).lower() |
| if isinstance(content, dict) |
| else "shot" |
| ) |
| if continuity_mode == "context_test": |
| continuity_mode = "context" |
| uses_context = continuity_mode in H3_CONTEXT_CONTINUITY_MODES |
| uses_swap = continuity_mode == "context_swap" |
| locked_audio_track = h3_locked_audio_track(entry, info) |
| locked_video_track = h3_locked_video_track(entry, info) |
| has_task_locked_audio = locked_audio_track is not None |
| preserve_source_timing = not audio_only and ( |
| has_task_locked_audio or locked_video_track is not None |
| ) |
| fit_locked_video_timing = ( |
| preserve_source_timing |
| and locked_video_track is not None |
| ) |
|
|
| ref_image_size = ( |
| str(content.get("ref_image_size", "match")).lower() |
| if isinstance(content, dict) |
| else "match" |
| ) |
| report_segment_step(0.0) |
| report_segment_step(0.04) |
| task_start_frame = max(0, int(entry.get("start_frame", 0))) |
| task_end_frame = max( |
| task_start_frame, |
| int(entry.get("end_frame", task_start_frame)), |
| ) |
| task_duration_frames = max(1, task_end_frame - task_start_frame) |
| if uses_linked_prepare: |
| segment_static = graph.node( |
| "easy h3ProjectStaticPrepare", id=f"segment_static_prepare_{task_index}", |
| project_static=project_media_static.out(0), task_start_frame=task_start_frame, |
| task_index=task_index, |
| task_duration_frames=task_duration_frames, fps=fps, |
| generation_mode="reference" if is_passthrough else generation_mode, |
| **( |
| {"previous": previous_artifact} |
| if previous_artifact is not None |
| else {} |
| ), |
| ) |
| task_tracks_info, task_locked_audio = segment_static.out(1), segment_static.out(8) |
| task_output = graph.node( |
| "easy multiTrackTaskOutput", |
| id=f"task_{task_index}", |
| tracks_info=task_tracks_info, |
| task_index=task_index, |
| prompt_format="default", |
| ) |
| base_task_length = task_output.out(3) |
| if preserve_source_timing: |
| base_task_length = task_duration_frames |
| else: |
| task_shared_audio, task_shared_video, task_locked_audio = crop_multitrack_project_media( |
| shared_audio, shared_video, full_locked_audio, task_start_frame, |
| task_duration_frames, fps, |
| ) |
| task_tracks_info = prepare_multitrack_project_task_info( |
| task_tracks_info_base, shared_images, |
| task_shared_audio if generation_mode == "reference" or is_passthrough else [], |
| task_shared_video if generation_mode == "reference" or is_passthrough else [], |
| task_entry=entry, |
| ) |
| task_output = graph.node( |
| "easy multiTrackTaskOutput", id=f"task_{task_index}", |
| tracks_info=task_tracks_info, |
| **({"previous": previous_artifact} if previous_artifact is not None else {}), |
| task_index=task_index, prompt_format="default", |
| ) |
| base_task_length = task_output.out(3) |
| if preserve_source_timing: |
| base_task_length = task_duration_frames |
| if is_passthrough: |
| if audio_only: |
| raise ValueError("Passthrough requires a video project, not audio-only mode") |
| passthrough = graph.node( |
| "easy h3PassthroughVideo", |
| id=f"passthrough_video_{task_index}", |
| videos=task_output.out(6), |
| frame_count=task_duration_frames, |
| fps=fps, |
| ) |
| output_images, output_audio = passthrough.out(0), passthrough.out(1) |
| context_latent = _h3_encode_context_media( |
| graph, output_images, output_audio, vae, audio_vae, |
| f"passthrough_context_{task_index}", |
| ) |
| runtime_context_latent = graph.node( |
| "easy h3MotionContextLatentTrim", |
| id=f"trim_hires_context_latent_{task_index}", |
| latent=context_latent, |
| context_length=str(H3_CONTEXT_SOURCE_FRAMES), |
| ).out(0) |
| saved_video = graph.node( |
| "easy saveVideo", |
| id=f"save_video_{task_index}", |
| input_mode="images+audio", |
| **{ |
| "input_mode.images": output_images, |
| "input_mode.audio": output_audio, |
| "input_mode.fps": fps, |
| "output_mode": "hide&save", |
| }, |
| filename_prefix=( |
| f"easy_media/projects/{safe_project_name}/" |
| f".staging_video_{task_index}" |
| ), |
| ) |
| saved_video_end = graph.node( |
| "easy h3SegmentSaveEnd", |
| id=f"save_end_{task_index}", |
| video_path=saved_video.out(1), |
| project_name=safe_project_name, |
| segment_index=task_index, |
| ) |
| artifact_inputs = { |
| "project_name": safe_project_name, |
| "project_save": project_save, |
| "segment_index": task_index, |
| "context_latent": runtime_context_latent, |
| "video_path": saved_video_end.out(0), |
| "tracks_info": output_info, |
| "continuity_mode": continuity_mode, |
| "seed": first_pass_seed, |
| "sampling_pass": "single", |
| } |
| if previous_artifact is not None: |
| artifact_inputs["previous"] = previous_artifact |
| artifact = graph.node( |
| "easy h3ProjectArtifact", |
| id=f"artifact_{task_index}", |
| **artifact_inputs, |
| ) |
| previous_artifact = last_project_output = artifact.out(0) |
| previous_hires_context_latent = runtime_context_latent |
| previous_low_context_latent = runtime_context_latent |
| segment_nodes.update({ |
| node_id: task_index |
| for node_id in graph.nodes.keys() - previous_graph_nodes |
| }) |
| report_segment_step(1.0) |
| continue |
| aligned_task_length: Any = ( |
| minimax_frame_count(base_task_length, round_up=True) |
| if preserve_source_timing |
| else base_task_length |
| ) |
| task_length: Any = aligned_task_length |
| will_have_context_continuity = ( |
| uses_context |
| and (previous_hires_context_latent is not None or task_index > 0) |
| ) |
| context_source_frames = H3_CONTEXT_SOURCE_FRAMES |
| context_generation_frames = 34 |
| if will_have_context_continuity: |
| task_length = graph.node( |
| "ComfyMathExpression", |
| id=f"context_length_{task_index}", |
| expression=f"a + {context_generation_frames}", |
| **{"values.a": task_length}, |
| ).out(1) |
| report_segment_step(0.10) |
| conditioning_inputs = { |
| "clip": clip, "vae": vae, "audio_vae": audio_vae, |
| "images": task_output.out(4), "prompt": task_output.out(1), |
| "mode": generation_mode, |
| "width": target_width if is_selflift else first_pass_width, |
| "height": target_height if is_selflift else first_pass_height, |
| "length": task_length, "ref_image_size": ref_image_size, |
| } |
| if generation_mode == "reference": |
| conditioning_inputs.update({ |
| "audios": task_output.out(5), |
| "videos": task_output.out(6), |
| }) |
| if fit_locked_video_timing: |
| conditioning_inputs["locked_video_timing_frames"] = ( |
| aligned_task_length |
| ) |
| encoded_conditioning = graph.node( |
| "easy minimaxH3ToVideo", |
| id=f"conditioning_{task_index}", |
| **conditioning_inputs, |
| ) |
| conditioning = graph.node( |
| "easy h3ConditioningCache", |
| id=f"conditioning_cache_{task_index}", |
| project_name=safe_project_name, |
| segment_index=task_index, |
| tracks_info=task_tracks_info, |
| task_output_ready=task_output.out(1), |
| model=model, |
| clip=clip, |
| vae=vae, |
| audio_vae=audio_vae, |
| conditioning=encoded_conditioning.out(0), |
| latent=encoded_conditioning.out(1), |
| ) |
| base_positive = second_pass_positive = conditioning.out(0) |
| |
| |
| if run_second_pass and generation_mode != "reference" and ( |
| first_pass_width, |
| first_pass_height, |
| ) != (target_width, target_height): |
| second_inputs = { |
| **conditioning_inputs, |
| "width": target_width, |
| "height": target_height, |
| } |
| second_pass_positive = graph.node( |
| "easy minimaxH3ToVideo", |
| id=f"second_pass_conditioning_{task_index}", |
| **second_inputs, |
| ).out(0) |
| initial_latent = conditioning.out(1) |
| positive = base_positive |
|
|
| if ( |
| uses_context |
| and previous_hires_context_latent is None |
| and task_index > 0 |
| ): |
| report_segment_step(0.14) |
| loaded_hires_context = graph.node( |
| "easy h3ProjectContextLatentLoad", |
| id=f"load_hires_context_{task_index}", |
| project_name=safe_project_name, |
| segment_index=task_index - 1, |
| resolution="high", |
| ) |
| previous_hires_context_latent = loaded_hires_context.out(0) |
| if has_second_pass or is_selflift: |
| loaded_low_context = graph.node( |
| "easy h3ProjectContextLatentLoad", |
| id=f"load_low_context_{task_index}", |
| project_name=safe_project_name, |
| segment_index=task_index - 1, |
| resolution="low", |
| ) |
| previous_low_context_latent = loaded_low_context.out(0) |
| else: |
| previous_low_context_latent = previous_hires_context_latent |
| report_segment_step(0.18) |
| context_trim_frames: Any | None = None |
| first_pass_context_trim_frames: Any | None = None |
| first_pass_context_latent = ( |
| previous_low_context_latent |
| if has_second_pass |
| else previous_hires_context_latent |
| ) |
| has_context_continuity = ( |
| uses_context |
| and first_pass_context_latent is not None |
| ) |
| |
| |
| |
| |
| if has_task_locked_audio: |
| report_segment_step(0.20) |
| initial_latent = graph.node( |
| "easy minimaxH3AudioLock", |
| id=f"audio_lock_{task_index}", |
| latent=initial_latent, |
| audio_vae=audio_vae, |
| audio=task_locked_audio, |
| remix_strength=1.0, |
| short_audio_mode="silence", |
| prepend_frames=( |
| context_source_frames if has_context_continuity else 0 |
| ), |
| frame_rate=fps, |
| ).out(0) |
|
|
| first_pass_sampling_model = model |
| if has_context_continuity: |
| report_segment_step(0.22) |
| if uses_swap: |
| context_swap = graph.node( |
| "easy MiniMaxH3ContextSwap", |
| id=f"first_pass_context_swap_noise_{task_index}", |
| model=model, |
| latent=initial_latent, |
| context_latent=first_pass_context_latent, |
| sigmas=first_pass_sigmas, |
| context_length=str(context_source_frames), |
| seed=(first_pass_seed + task_index) & 0xFFFFFFFFFFFFFFFF, |
| continue_audio=True, |
| freeze_audio=False, |
| ) |
| first_pass_sampling_model = context_swap.out(0) |
| initial_latent = context_swap.out(1) |
| first_pass_context_trim_frames = context_swap.out(2) |
| context_trim_frames = first_pass_context_trim_frames |
| else: |
| motion_context = graph.node( |
| "easy MiniMaxH3MotionContextHard", |
| id=f"hard_motion_context_{task_index}", |
| conditioning=positive, |
| vae=vae, |
| latent=initial_latent, |
| context_latent=first_pass_context_latent, |
| context_length=str(context_source_frames), |
| video_transition_steps=4, |
| audio_transition_steps=4, |
| video_anchor_only=not audio_only, |
| ) |
| positive = motion_context.out(0) |
| first_pass_context_trim_frames = motion_context.out(1) |
| context_trim_frames = first_pass_context_trim_frames |
| initial_latent = motion_context.out(2) |
| else: |
| report_segment_step(0.22) |
|
|
| report_segment_step(0.28) |
| selflift_low_latent: Any | None = None |
| if is_selflift: |
| report_segment_step(0.38) |
| selflift_inputs: dict[str, Any] = { |
| "model": first_pass_sampling_model, |
| "highres_model": ( |
| second_model |
| if second_model_loader is not None |
| else first_pass_sampling_model |
| ), |
| "positive": positive, |
| "vae": vae, |
| "latent_image": initial_latent, |
| "sigmas": first_pass_sigmas, |
| "seed": first_pass_seed, |
| "transition_ratio": transition_ratio, |
| "lowres_scale": lowres_scale, |
| "rho": 0.1 if has_context_continuity else 0.0, |
| "w_max": 0.7, |
| "w_min": 0.25, |
| "upscaler_model": selected_upscale_model, |
| "enabled_tiling": tiling_enabled, |
| "tile_count": tile_count, |
| } |
| if has_sampling_preview: |
| selflift_inputs.update({ |
| "preview_vae": preview_vae, |
| "preview_node_id": preview_node_id, |
| "generated_frame_count": task_length, |
| "preview_fps": fps, |
| "segment_index": task_index, |
| "sampling_pass": "selflift", |
| }) |
| if ( |
| has_context_continuity |
| and previous_low_context_latent is not None |
| ): |
| selflift_inputs["low_context_latent"] = previous_low_context_latent |
| if previous_artifact is not None: |
| selflift_inputs["previous"] = previous_artifact |
| selflift_sample = graph.node( |
| "easy minimaxH3SelfLiftSampler", |
| id=f"selflift_sample_{task_index}", |
| **selflift_inputs, |
| ) |
| first_pass_latent = selflift_sample.out(0) |
| selflift_low_latent = selflift_sample.out(1) |
| else: |
| first_pass_guider = graph.node( |
| "BasicGuider", |
| id=f"first_pass_guider_{task_index}", |
| model=first_pass_sampling_model, |
| conditioning=positive, |
| ) |
| if task_index == resume_task_index: |
| report_segment_step(0.38) |
| first_pass_latent = graph.node( |
| "easy h3ProjectContextLatentLoad", |
| id=f"resume_first_pass_{task_index}", |
| project_name=safe_project_name, |
| segment_index=task_index, |
| ).out(0) |
| else: |
| report_segment_step(0.32) |
| first_pass_noise = graph.node( |
| "RandomNoise", |
| id=f"first_pass_noise_{task_index}", |
| noise_seed=first_pass_seed, |
| ) |
| report_segment_step(0.38) |
| sampling_inputs: dict[str, Any] = { |
| "noise": first_pass_noise.out(0), |
| "guider": first_pass_guider.out(0), |
| "sampler": first_pass_sampler, |
| "sigmas": first_pass_sigmas, |
| "latent_image": initial_latent, |
| "project_name": safe_project_name, |
| "segment_index": task_index, |
| } |
| if previous_artifact is not None: |
| sampling_inputs["previous"] = previous_artifact |
| sampling_start = graph.node( |
| "easy h3SegmentSamplingStart", |
| id=f"sampling_start_{task_index}", |
| sampling_pass="first", |
| **sampling_inputs, |
| ) |
| preview_inputs = ( |
| { |
| "preview_vae": preview_vae, |
| "preview_node_id": preview_node_id, |
| "generated_frame_count": task_length, |
| "preview_fps": fps, |
| "segment_index": task_index, |
| "sampling_pass": "first", |
| } |
| if has_sampling_preview |
| else {} |
| ) |
| first_pass_sample = graph.node( |
| "easy h3SamplingPreviewSampler" |
| if has_sampling_preview |
| else "SamplerCustomAdvanced", |
| id=f"first_pass_sample_{task_index}", |
| noise=sampling_start.out(0), |
| guider=sampling_start.out(1), |
| sampler=sampling_start.out(2), |
| sigmas=sampling_start.out(3), |
| latent_image=sampling_start.out(4), |
| **preview_inputs, |
| ) |
| first_pass_latent = first_pass_sample.out(1) |
| final_latent = first_pass_latent |
| report_segment_step(0.42) |
|
|
| if run_second_pass: |
| segment_second_pass_sigmas = second_pass_sigmas |
| if ( |
| uses_context |
| and previous_hires_context_latent is not None |
| and context_second_pass_sigmas is not None |
| ): |
| segment_second_pass_sigmas = context_second_pass_sigmas |
| if audio_only or upscale_by <= 1: |
| report_segment_step(0.46) |
| upscaled_latent = final_latent |
| else: |
| report_segment_step(0.45) |
| separated = graph.node( |
| "LTXVSeparateAVLatent", |
| id=f"separate_first_pass_{task_index}", |
| av_latent=final_latent, |
| ) |
| if selected_upscale_model != "None": |
| report_segment_step(0.50) |
| upscaled_video = graph.node( |
| "easy minimaxH3LatentUpscaler", |
| id=f"latent_upscale_{task_index}", |
| **_h3_latent_upscale_inputs( |
| separated.out(0), |
| selected_upscale_model, |
| target_width, |
| target_height |
| ), |
| ) |
| video_latent = upscaled_video.out(0) |
| else: |
| report_segment_step(0.48) |
| first_pass_images = graph.node( |
| "VAEDecode", |
| id=f"first_pass_decode_{task_index}", |
| samples=separated.out(0), |
| vae=vae, |
| ) |
| report_segment_step(0.51) |
| resized = graph.node( |
| "ImageResizeKJv2", |
| id=f"first_pass_resize_{task_index}", |
| **_h3_image_resize_inputs( |
| first_pass_images.out(0), |
| target_width, |
| target_height, |
| ), |
| ) |
| report_segment_step(0.54) |
| encoded_video = graph.node( |
| "VAEEncode", |
| id=f"first_pass_reencode_{task_index}", |
| pixels=resized.out(0), |
| vae=vae, |
| ) |
| video_latent = encoded_video.out(0) |
|
|
| report_segment_step(0.57) |
| upscaled_latent = graph.node( |
| "LTXVConcatAVLatent", |
| id=f"first_pass_recombine_{task_index}", |
| video_latent=video_latent, |
| audio_latent=separated.out(1), |
| ).out(0) |
|
|
| second_pass_sampling_model = second_model |
| if ( |
| uses_context |
| and previous_hires_context_latent is not None |
| ): |
| report_segment_step(0.59) |
| |
| |
| hires_continuity = graph.node( |
| "easy MiniMaxH3HiResContinuity", |
| id=f"hires_continuity_{task_index}", |
| current_hires_latent=upscaled_latent, |
| previous_hires_latent=previous_hires_context_latent, |
| context_length=str(H3_CONTEXT_SOURCE_FRAMES), |
| video_transition_steps=4, |
| video_anchor_only=not audio_only, |
| ) |
| upscaled_latent = hires_continuity.out(0) |
| context_trim_frames = hires_continuity.out(1) |
|
|
| report_segment_step(0.62) |
| second_pass_noise = graph.node( |
| "DisableNoise" if disable_2nd_noise else "RandomNoise", |
| id=f"second_pass_noise_{task_index}", |
| **({} if disable_2nd_noise else {"noise_seed": second_pass_seed}), |
| ) |
| report_segment_step(0.66) |
| second_pass_guider = graph.node( |
| "BasicGuider", |
| id=f"second_pass_guider_{task_index}", |
| model=second_pass_sampling_model, |
| conditioning=second_pass_positive, |
| ) |
| report_segment_step(0.71) |
| second_sampling_start = graph.node( |
| "easy h3SegmentSamplingStart", |
| id=f"second_sampling_start_{task_index}", |
| noise=second_pass_noise.out(0), |
| guider=second_pass_guider.out(0), |
| sampler=second_pass_sampler, |
| sigmas=segment_second_pass_sigmas, |
| latent_image=upscaled_latent, |
| project_name=safe_project_name, |
| segment_index=task_index, |
| sampling_pass="second", |
| ) |
| second_preview_inputs = ( |
| { |
| "preview_vae": preview_vae, |
| "preview_node_id": preview_node_id, |
| "generated_frame_count": task_length, |
| "preview_fps": fps, |
| "segment_index": task_index, |
| "sampling_pass": "second", |
| } |
| if has_sampling_preview |
| else {} |
| ) |
| if tiling_enabled: |
| second_preview_inputs.update({ |
| "enabled_tiling": True, |
| "tile_count": tile_count, |
| }) |
| second_pass_sample = graph.node( |
| "easy h3SamplingPreviewSampler" |
| if has_sampling_preview or tiling_enabled |
| else "SamplerCustomAdvanced", |
| id=f"second_pass_sample_{task_index}", |
| noise=second_sampling_start.out(0), |
| guider=second_sampling_start.out(1), |
| sampler=second_sampling_start.out(2), |
| sigmas=second_sampling_start.out(3), |
| latent_image=second_sampling_start.out(4), |
| **second_preview_inputs, |
| ) |
| final_latent = second_pass_sample.out(1) |
| else: |
| report_segment_step(0.71) |
|
|
| low_stage_context_latent = ( |
| selflift_low_latent |
| if is_selflift and selflift_low_latent is not None |
| else first_pass_latent |
| if has_second_pass |
| else final_latent |
| ) |
| hires_context_reencoded = False |
| low_context_reencoded = False |
| if audio_only: |
| output_audio = graph.node( |
| "VAEDecodeAudio", |
| id=f"decode_audio_{task_index}", |
| samples=final_latent, |
| vae=audio_vae, |
| ).out(0) |
| project_hires_context_latent = final_latent |
| project_low_context_latent = low_stage_context_latent |
| if context_trim_frames is not None: |
| output_audio, project_hires_context_latent = _h3_encode_audio_context( |
| graph, output_audio, audio_vae, context_trim_frames, |
| base_task_length, fps, not has_task_locked_audio, |
| f"hires_audio_context_{task_index}", |
| ) |
| if (has_second_pass and run_second_pass) or ( |
| is_selflift and selflift_low_latent is not None |
| ): |
| low_audio = graph.node( |
| "VAEDecodeAudio", id=f"low_audio_context_decode_{task_index}", |
| samples=low_stage_context_latent, vae=audio_vae, |
| ).out(0) |
| _, project_low_context_latent = _h3_encode_audio_context( |
| graph, low_audio, audio_vae, first_pass_context_trim_frames, |
| base_task_length, fps, not has_task_locked_audio, |
| f"low_audio_context_{task_index}", |
| ) |
| else: |
| project_low_context_latent = project_hires_context_latent |
|
|
| report_segment_step(0.89) |
| saved_audio = output_audio |
| if has_task_locked_audio: |
| saved_audio = graph.node( |
| "easy h3LockedAudioSelect", |
| id=f"locked_audio_select_{task_index}", |
| generated_audio=output_audio, |
| locked_audio=task_locked_audio, |
| ).out(0) |
| saved_media_inputs = { |
| "audio": saved_audio, |
| } |
| else: |
| report_segment_step(0.76) |
| decoded_images = graph.node( |
| "VAEDecode", |
| id=f"decode_video_{task_index}", |
| samples=final_latent, |
| vae=vae, |
| ) |
| report_segment_step(0.80) |
| decoded_audio = graph.node( |
| "VAEDecodeAudio", |
| id=f"decode_audio_{task_index}", |
| samples=final_latent, |
| vae=audio_vae, |
| ) |
| output_images = decoded_images.out(0) |
| output_audio = decoded_audio.out(0) |
| if context_trim_frames is not None or preserve_source_timing: |
| report_segment_step(0.84) |
| trimmed = graph.node( |
| "easy h3ContextMediaTrim", |
| id=f"motion_context_trim_{task_index}", |
| images=output_images, |
| audio=output_audio, |
| trim_frames=( |
| context_trim_frames if context_trim_frames is not None else 0 |
| ), |
| output_frames=base_task_length, |
| pad_audio=not has_task_locked_audio, |
| **( |
| {"fit_video_duration": True} |
| if fit_locked_video_timing |
| else {} |
| ), |
| fps=fps, |
| ) |
| output_images = trimmed.out(0) |
| output_audio = trimmed.out(1) |
| else: |
| report_segment_step(0.84) |
|
|
| if has_task_locked_audio: |
| locked_audio_align = graph.node( |
| "easy h3LockedAudioDurationAlign", |
| id=f"locked_audio_duration_align_{task_index}", |
| images=output_images, |
| audio=output_audio, |
| fps=fps, |
| ) |
| output_audio = locked_audio_align.out(0) |
|
|
| saved_audio = output_audio |
| if has_task_locked_audio: |
| saved_audio = graph.node( |
| "easy h3LockedAudioSelect", |
| id=f"locked_audio_select_{task_index}", |
| generated_audio=output_audio, |
| locked_audio=task_locked_audio, |
| ).out(0) |
|
|
| project_hires_context_latent = final_latent |
| project_low_context_latent = low_stage_context_latent |
| low_delivered_images: Any | None = None |
| if context_trim_frames is not None or preserve_source_timing: |
| |
| |
| project_hires_context_latent = _h3_encode_context_media( |
| graph, |
| output_images, |
| output_audio, |
| vae, |
| audio_vae, |
| f"hires_context_{task_index}", |
| ) |
| hires_context_reencoded = True |
| if (has_second_pass and run_second_pass) or ( |
| is_selflift and selflift_low_latent is not None |
| ): |
| low_context_images = graph.node( |
| "VAEDecode", |
| id=f"low_context_video_decode_{task_index}", |
| samples=low_stage_context_latent, |
| vae=vae, |
| ) |
| low_context_audio = graph.node( |
| "VAEDecodeAudio", |
| id=f"low_context_audio_decode_{task_index}", |
| samples=low_stage_context_latent, |
| vae=audio_vae, |
| ) |
| low_context_media = graph.node( |
| "easy h3ContextMediaTrim", |
| id=f"low_context_trim_{task_index}", |
| images=low_context_images.out(0), |
| audio=low_context_audio.out(0), |
| trim_frames=( |
| first_pass_context_trim_frames |
| if first_pass_context_trim_frames is not None |
| else 0 |
| ), |
| output_frames=base_task_length, |
| **( |
| {"fit_video_duration": True} |
| if fit_locked_video_timing |
| else {} |
| ), |
| fps=fps, |
| ) |
| low_delivered_images = low_context_media.out(0) |
| project_low_context_latent = _h3_encode_context_media( |
| graph, |
| low_context_media.out(0), |
| low_context_media.out(1), |
| vae, |
| audio_vae, |
| f"low_context_{task_index}", |
| ) |
| low_context_reencoded = True |
| else: |
| project_low_context_latent = project_hires_context_latent |
| low_context_reencoded = hires_context_reencoded |
| report_segment_step(0.89) |
| |
| |
| saved_video = graph.node( |
| "easy saveVideo", |
| id=f"save_video_{task_index}", |
| input_mode="images+audio", |
| **{ |
| "input_mode.images": output_images, |
| "input_mode.audio": saved_audio, |
| "input_mode.fps": fps, |
| "output_mode": "hide&save", |
| }, |
| filename_prefix=( |
| f"easy_media/projects/{safe_project_name}/" |
| f".staging_video_{task_index}" |
| ), |
| ) |
| saved_video_end = graph.node( |
| "easy h3SegmentSaveEnd", |
| id=f"save_end_{task_index}", |
| video_path=saved_video.out(1), |
| project_name=safe_project_name, |
| segment_index=task_index, |
| ) |
| saved_media_inputs = {"video_path": saved_video_end.out(0)} |
|
|
| saved_hires_context_latent = project_hires_context_latent |
| saved_low_context_latent = project_low_context_latent |
| hires_trim_inputs: dict[str, Any] = { |
| "latent": saved_hires_context_latent, |
| "context_length": str(context_source_frames), |
| } |
| if not audio_only and not hires_context_reencoded: |
| hires_trim_inputs.update({"anchor_images": output_images, "vae": vae}) |
| runtime_hires_context_latent = graph.node( |
| "easy h3MotionContextLatentTrim", |
| id=f"trim_hires_context_latent_{task_index}", |
| **hires_trim_inputs, |
| ).out(0) |
| if has_second_pass or is_selflift: |
| low_trim_inputs: dict[str, Any] = { |
| "latent": saved_low_context_latent, |
| "context_length": str(context_source_frames), |
| } |
| if not audio_only and not low_context_reencoded: |
| low_anchor_images = low_delivered_images |
| if low_anchor_images is None: |
| if (has_second_pass and run_second_pass) or ( |
| is_selflift and selflift_low_latent is not None |
| ): |
| low_anchor_images = graph.node( |
| "VAEDecode", |
| id=f"low_anchor_decode_video_{task_index}", |
| samples=low_stage_context_latent, |
| vae=vae, |
| ).out(0) |
| else: |
| low_anchor_images = output_images |
| low_trim_inputs.update( |
| {"anchor_images": low_anchor_images, "vae": vae} |
| ) |
| runtime_low_context_latent = graph.node( |
| "easy h3MotionContextLatentTrim", |
| id=f"trim_low_context_latent_{task_index}", |
| **low_trim_inputs, |
| ).out(0) |
| else: |
| runtime_low_context_latent = runtime_hires_context_latent |
| completed_sampling_pass = ( |
| "first" |
| if first_pass_only and has_second_pass |
| else "second" |
| if has_second_pass |
| else "single" |
| ) |
| |
| |
| checkpoint_latent = ( |
| first_pass_latent if preserve_source_timing else saved_hires_context_latent |
| ) |
| artifact_inputs: dict[str, Any] = { |
| "project_name": safe_project_name, |
| "project_save": project_save, |
| "segment_index": task_index, |
| "context_latent": ( |
| checkpoint_latent |
| if completed_sampling_pass == "first" |
| else runtime_hires_context_latent |
| ), |
| **saved_media_inputs, |
| "tracks_info": output_info, |
| "continuity_mode": continuity_mode, |
| "seed": first_pass_seed, |
| "sampling_pass": completed_sampling_pass, |
| } |
| if has_second_pass or is_selflift: |
| artifact_inputs["context_latent_low"] = ( |
| saved_low_context_latent |
| if completed_sampling_pass == "first" |
| else runtime_low_context_latent |
| ) |
| if previous_artifact is not None: |
| artifact_inputs["previous"] = previous_artifact |
| report_segment_step(0.95) |
| artifact = graph.node( |
| "easy h3ProjectArtifact", |
| id=f"artifact_{task_index}", |
| **artifact_inputs, |
| ) |
| previous_artifact = artifact.out(0) |
| last_project_output = artifact.out(0) |
| previous_hires_context_latent = runtime_hires_context_latent |
| previous_low_context_latent = runtime_low_context_latent |
| segment_nodes.update({ |
| node_id: task_index |
| for node_id in graph.nodes.keys() - previous_graph_nodes |
| }) |
| report_segment_step(1.0) |
|
|
| if last_project_output is None: |
| log_node_info(node_name, "Project graph produced no task output") |
| raise RuntimeError("H3 project graph produced no task output") |
| report_step(100) |
| return io.NodeOutput( |
| last_project_output, |
| full_locked_audio, |
| expand=_timed_h3_project_graph(graph, safe_project_name, segment_nodes), |
| ) |
|
|
|
|
| class EasyMultiTrackProjectVideoCombine(io.ComfyNode): |
| """Combine a project timeline configured by the React project widget.""" |
|
|
| @classmethod |
| def define_schema(cls) -> io.Schema: |
| return io.Schema( |
| node_id="easy multitrackProjectVideoCombine", |
| display_name="MultiTrack Project Video Combine", |
| category="EasyUse/MultiTrackEditor", |
| description=( |
| "Preview and combine the active videos from a MultiTrack project." |
| ), |
| inputs=[ |
| io.String.Input("project_name", force_input=True), |
| TYPE_PROJECT_DATA.Input("project_data"), |
| ], |
| hidden=[io.Hidden.unique_id], |
| outputs=[ |
| io.Video.Output("VIDEO"), |
| io.String.Output("FILENAME_PREFIX"), |
| ], |
| not_idempotent=True, |
| ) |
|
|
| @classmethod |
| def execute(cls, project_name: str, project_data: Any) -> io.NodeOutput: |
| data = project_data |
| if isinstance(data, str): |
| try: |
| data = json.loads(data) |
| except json.JSONDecodeError as error: |
| raise ValueError(f"project_data is not valid JSON: {error}") from error |
| if not isinstance(data, dict): |
| raise TypeError("project_data must contain a dictionary or JSON object") |
| auto_combine = data.get("auto_combine", True) is not False |
| safe_name = safe_h3_project_name(project_name) |
| if safe_h3_project_name(data.get("project_name")) != safe_name: |
| data = {"project_name": safe_name, "clips": []} |
| try: |
| from server import PromptServer |
|
|
| PromptServer.instance.send_sync( |
| "easy-media.project.selected", |
| { |
| "node_id": str( |
| getattr(getattr(cls, "hidden", None), "unique_id", "") |
| ), |
| "project_name": safe_name, |
| }, |
| ) |
| except (AttributeError, ImportError, RuntimeError) as error: |
| print( |
| f"[Moxie][Project] Unable to notify the frontend: {error}" |
| ) |
| if not auto_combine: |
| blocker = ExecutionBlocker(None) |
| return io.NodeOutput(blocker, blocker) |
| composed_path = compose_h3_project_video(safe_name, data) |
| |
| |
| |
| |
| video = restore_project_video_resolution( |
| InputImpl.VideoFromFile(str(composed_path)), |
| safe_name, |
| source_path=str(composed_path), |
| ) |
| return io.NodeOutput( |
| video, |
| h3_project_filename_prefix(safe_name), |
| ) |
|
|
