Bake enabled_tiling with tile_count 0 (automatic) into the Slow node's second pass: the engine picks the tile count from the available accelerator memory and bypasses tiling entirely when the full evaluation fits. This brings 1920x1080 output within reach of 12 GB cards and AMD/Intel GPUs - the tiling machinery only uses device-agnostic ComfyUI memory helpers. - _h3_tiling_config now accepts tile_count 0 (automatic) alongside 2-8 - easy h3SamplingPreviewSampler schema allows tile_count min 0 - tests: tiling config parsing, baked Slow passthrough, second-pass graph receives tile_count 0, sampler schema range - docs: CHANGELOG + multitrack-schema reference
335 lines
13 KiB
Python
335 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import comfy.samplers
|
|
import folder_paths
|
|
from comfy_api.latest import io
|
|
|
|
from .nodes.project import (
|
|
EasyMultiTrackProject,
|
|
H3_CONTEXT_LENGTH_OPTIONS,
|
|
H3_CONTEXT_SOURCE_FRAMES,
|
|
TYPE_TRACKS_INFO,
|
|
_first_input,
|
|
)
|
|
|
|
# Values baked from the reference workflow (Moxie-clean.json). End users only
|
|
# control project_name, steps and seed on this node.
|
|
BAKED_PROJECT_SETTINGS = {
|
|
"project_save": "override",
|
|
"segment_start_number": 1,
|
|
"segment_count": -1,
|
|
"sampling_plan": "custom",
|
|
"sampling_mode": "single",
|
|
"1st_pass_only": False,
|
|
"disable_2nd_noise": False,
|
|
"upscale_by": 1.5,
|
|
"upscale_model": "None",
|
|
"enabled_tiling": "false",
|
|
}
|
|
BAKED_SAMPLER_NAME = "euler"
|
|
BAKED_SCHEDULER = "beta"
|
|
|
|
# Moxie MultiTrack Project Slow: the hidden half-resolution first pass is
|
|
# upscaled to the final size by the H3 latent upscaler model and refined with
|
|
# a short low-denoise euler pass instead of the RTX VSR pixel restore.
|
|
SLOW_UPSCALE_MODEL = "minimax_h3_latent_upscaler_3d_fp16.safetensors"
|
|
SLOW_SECOND_PASS_STEPS = 2
|
|
SLOW_SECOND_PASS_DENOISE = 0.33
|
|
# Spatial tiling of the second pass with an automatic tile count: 0 lets the
|
|
# engine choose how many tiles fit into the available accelerator memory and
|
|
# skip tiling entirely when the full evaluation fits. The tiling module only
|
|
# uses device-agnostic ComfyUI memory helpers, so this also brings 1920x1080
|
|
# output within reach of 12 GB cards and AMD/Intel GPUs.
|
|
SLOW_TILING_SETTINGS = {"enabled_tiling": "true", "tile_count": 0}
|
|
SLOW_PROJECT_SETTINGS_DELTA = {
|
|
"sampling_mode": "dual",
|
|
# The first pass already runs at half the editor resolution, so the final
|
|
# size IS the editor size: a scale factor of 1.0 keeps the project
|
|
# manifest at the editor dimensions while the latent upscaler (target
|
|
# dimensions mode) bridges the half-res gap. The upscaler checkpoint is
|
|
# NOT baked: the Slow node exposes an upscale_model widget instead.
|
|
"upscale_by": 1.0,
|
|
"enabled_tiling": SLOW_TILING_SETTINGS,
|
|
}
|
|
|
|
|
|
def _require_moxie_components(model, clip, video_vae, audio_vae) -> None:
|
|
missing = [
|
|
name
|
|
for name, value in (
|
|
("model", model),
|
|
("clip", clip),
|
|
("video_vae", video_vae),
|
|
("audio_vae", audio_vae),
|
|
)
|
|
if value is None
|
|
]
|
|
if missing:
|
|
raise ValueError(
|
|
"MoxieProject: Missing required model components: "
|
|
+ ", ".join(missing)
|
|
+ ". Wire model, clip, video_vae, and audio_vae from Moxie Multimedia Loader."
|
|
)
|
|
|
|
|
|
def _denoise_truncated_sigmas(
|
|
model_sampling, scheduler: str, steps: int, denoise: float
|
|
):
|
|
"""Sigma schedule for `steps` steps at `denoise`, matching KSampler.
|
|
|
|
Replicates comfy KSampler.set_steps: build the schedule at
|
|
int(steps / denoise) total steps, then keep the last steps + 1 sigmas.
|
|
Written out because newer ComfyUI builds dropped the denoise kwarg from
|
|
comfy.samplers.calculate_sigmas.
|
|
"""
|
|
if denoise <= 0.0:
|
|
raise ValueError("denoise must be positive")
|
|
if denoise > 0.9999:
|
|
total_steps = steps
|
|
else:
|
|
total_steps = int(steps / denoise)
|
|
schedule = comfy.samplers.calculate_sigmas(
|
|
model_sampling, scheduler, total_steps
|
|
).cpu()
|
|
return schedule[-(steps + 1):]
|
|
|
|
|
|
class MoxieProject(EasyMultiTrackProject):
|
|
"""MultiTrack Project with the sampling stack consolidated.
|
|
|
|
Replaces: easy multitrackProject + 2x KSamplerSelect (euler / sa_solver)
|
|
+ BasicScheduler (beta) + ManualSigmas. Execution delegates to the
|
|
battle-tested Easy-Media implementation with sampler/sigmas computed
|
|
internally from the exposed `steps` widget.
|
|
"""
|
|
|
|
@classmethod
|
|
def _baked_project_settings(cls) -> dict:
|
|
return dict(BAKED_PROJECT_SETTINGS)
|
|
|
|
@classmethod
|
|
def _component_inputs(cls) -> list:
|
|
"""Extra inputs subclasses slot in after the model components."""
|
|
return []
|
|
|
|
@classmethod
|
|
def _project_inputs(cls) -> list:
|
|
inputs = [
|
|
TYPE_TRACKS_INFO.Input("tracks_info"),
|
|
io.Model.Input("model", tooltip="Diffusion model from Moxie Multimedia Loader (attention backend already applied)."),
|
|
io.Clip.Input("clip", tooltip="CLIP text encoder from Moxie Multimedia Loader."),
|
|
io.Vae.Input("video_vae", tooltip="Video VAE from Moxie Multimedia Loader."),
|
|
io.Vae.Input("audio_vae", tooltip="Audio VAE from Moxie Multimedia Loader (required to decode Moxie audio)."),
|
|
]
|
|
inputs.extend(cls._component_inputs())
|
|
inputs.extend(
|
|
[
|
|
io.String.Input("project_name", default="",
|
|
tooltip="Name of the project; used for output folders."),
|
|
io.Int.Input(
|
|
"steps",
|
|
default=3,
|
|
min=1,
|
|
max=10000,
|
|
tooltip="Sampling steps for the beta scheduler (3 for the baked-in 3-step distill; "
|
|
"8 for busy motion, 6 low motion, 4 runs/no dialogue).",
|
|
),
|
|
io.Combo.Input(
|
|
"context_frames",
|
|
options=[str(option) for option in H3_CONTEXT_LENGTH_OPTIONS],
|
|
default=str(H3_CONTEXT_SOURCE_FRAMES),
|
|
tooltip=(
|
|
"Video frames copied from the previous segment as "
|
|
"continuation context for segments whose continuity "
|
|
"mode is Context or Context Swap. Longer values hand "
|
|
"off motion more smoothly but generate that many extra "
|
|
"frames per segment. Values are H3 temporal-grid "
|
|
"lengths shared with the Moxie context sampler nodes."
|
|
),
|
|
),
|
|
io.Int.Input(
|
|
"seed",
|
|
default=42,
|
|
min=0,
|
|
max=0xFFFFFFFFFFFFFFFF,
|
|
step=1,
|
|
control_after_generate=io.ControlAfterGenerate.randomize,
|
|
),
|
|
]
|
|
)
|
|
return inputs
|
|
|
|
@classmethod
|
|
def define_schema(cls) -> io.Schema:
|
|
return io.Schema(
|
|
node_id="MoxieProject",
|
|
display_name="Moxie MultiTrack Project",
|
|
category="EasyUse/MultiTrackEditor",
|
|
description=(
|
|
"Build and execute a multi-track Moxie project. "
|
|
"Takes model, clip, video_vae and audio_vae directly from the Moxie Multimedia Loader. "
|
|
"Sampling is baked to a single pass with euler + beta sigmas; set only steps and seed."
|
|
),
|
|
is_input_list=True,
|
|
enable_expand=True,
|
|
not_idempotent=True,
|
|
inputs=cls._project_inputs(),
|
|
hidden=[io.Hidden.prompt, io.Hidden.unique_id],
|
|
outputs=[
|
|
io.String.Output("PROJECT_NAME"),
|
|
io.Audio.Output("LOCKED_AUDIO"),
|
|
],
|
|
)
|
|
|
|
@classmethod
|
|
def execute(cls, **kwargs) -> io.NodeOutput:
|
|
steps = int(_first_input(kwargs.get("steps"), 3))
|
|
|
|
model = _first_input(kwargs.get("model"))
|
|
clip = _first_input(kwargs.get("clip"))
|
|
video_vae = _first_input(kwargs.get("video_vae"))
|
|
audio_vae = _first_input(kwargs.get("audio_vae"))
|
|
_require_moxie_components(model, clip, video_vae, audio_vae)
|
|
|
|
# Pack the direct inputs into the loader dict consumed by
|
|
# EasyMultiTrackProject.execute (internal plumbing only).
|
|
synthesized_loader = {
|
|
"model": model,
|
|
"clip": clip,
|
|
"vae": video_vae,
|
|
"audio_vae": audio_vae,
|
|
}
|
|
|
|
# Same math as the native BasicScheduler node (scheduler=beta, denoise=1.0).
|
|
sigmas = comfy.samplers.calculate_sigmas(
|
|
model.get_model_object("model_sampling"), BAKED_SCHEDULER, steps
|
|
).cpu()
|
|
sigmas = sigmas[-(steps + 1):]
|
|
sampler = comfy.samplers.sampler_object(BAKED_SAMPLER_NAME)
|
|
|
|
baked = dict(kwargs)
|
|
baked.update(cls._baked_project_settings())
|
|
baked["model_loader"] = synthesized_loader
|
|
baked["sampler"] = sampler
|
|
baked["sigmas"] = sigmas
|
|
return super().execute(**baked)
|
|
|
|
|
|
class MoxieProjectSlow(MoxieProject):
|
|
"""Moxie MultiTrack Project with a latent-upscale refine pass.
|
|
|
|
Identical pipeline to MoxieProject (hidden half-resolution first pass,
|
|
euler + beta sampling from `steps`), except the low-resolution latent is
|
|
upscaled to the final size by a latent upscaler model chosen in the
|
|
`upscale_model` widget and refined with a 2-step euler pass at 0.33
|
|
denoise. The refine pass samples through automatic spatial tiling, so
|
|
large projects (up to 1920x1080) also run on 12 GB cards and on AMD or
|
|
Intel GPUs; the tile count adapts to the machine and tiling is skipped
|
|
entirely when the whole evaluation fits in memory. Segments are saved at
|
|
the project resolution, so the Video Combine RTX restore passes through
|
|
untouched - no NVIDIA RTX VSR is used anywhere.
|
|
"""
|
|
|
|
@classmethod
|
|
def _latent_upscaler_options(cls) -> list:
|
|
models = list(folder_paths.get_filename_list("latent_upscale_models"))
|
|
if SLOW_UPSCALE_MODEL not in models:
|
|
# Keep the bundled checkpoint selectable even before it is
|
|
# downloaded; the combo default must always be a valid option.
|
|
models.append(SLOW_UPSCALE_MODEL)
|
|
return ["None"] + models
|
|
|
|
@classmethod
|
|
def _component_inputs(cls) -> list:
|
|
return [
|
|
io.Combo.Input(
|
|
"upscale_model",
|
|
options=cls._latent_upscaler_options(),
|
|
default=SLOW_UPSCALE_MODEL,
|
|
tooltip=(
|
|
"Latent upscaler checkpoint that brings the hidden "
|
|
"half-resolution first pass to the final size before "
|
|
"the 2-step refine. Files live under "
|
|
"ComfyUI/models/latent_upscale_models/; None is "
|
|
"rejected because this node always upscales in latent "
|
|
"space instead of the RTX restore."
|
|
),
|
|
)
|
|
]
|
|
|
|
@classmethod
|
|
def _baked_project_settings(cls) -> dict:
|
|
settings = dict(BAKED_PROJECT_SETTINGS)
|
|
# The upscaler checkpoint comes from the upscale_model widget.
|
|
settings.pop("upscale_model", None)
|
|
settings.update(SLOW_PROJECT_SETTINGS_DELTA)
|
|
return settings
|
|
|
|
@classmethod
|
|
def _h3_first_pass_resolution_scale(cls, sampling_mode: str) -> float:
|
|
# Dual mode would sample the first pass at the editor size; the Slow
|
|
# node keeps MoxieProject's hidden half-resolution speed trick and
|
|
# lets the latent upscaler bridge the gap instead of RTX VSR.
|
|
return 0.5
|
|
|
|
@classmethod
|
|
def define_schema(cls) -> io.Schema:
|
|
return io.Schema(
|
|
node_id="MoxieProjectSlow",
|
|
display_name="Moxie MultiTrack Project Slow",
|
|
category="EasyUse/MultiTrackEditor",
|
|
description=(
|
|
"Build and execute a multi-track Moxie project with a "
|
|
"latent-upscale refine pass. Takes model, clip, video_vae and "
|
|
"audio_vae directly from the Moxie Multimedia Loader and an "
|
|
"upscale_model checkpoint from latent_upscale_models. The "
|
|
"first pass samples euler + beta sigmas from steps, the "
|
|
"half-resolution latent is upscaled to the final size with "
|
|
"the chosen latent upscaler, and a 2-step euler pass at "
|
|
"0.33 denoise refines it through automatic spatial tiling "
|
|
"(scales to the available VRAM, enabling up to 1920x1080 "
|
|
"output on 12 GB and AMD/Intel GPUs); set only steps and seed."
|
|
),
|
|
is_input_list=True,
|
|
enable_expand=True,
|
|
not_idempotent=True,
|
|
inputs=cls._project_inputs(),
|
|
hidden=[io.Hidden.prompt, io.Hidden.unique_id],
|
|
outputs=[
|
|
io.String.Output("PROJECT_NAME"),
|
|
io.Audio.Output("LOCKED_AUDIO"),
|
|
],
|
|
)
|
|
|
|
@classmethod
|
|
def execute(cls, **kwargs) -> io.NodeOutput:
|
|
model = _first_input(kwargs.get("model"))
|
|
clip = _first_input(kwargs.get("clip"))
|
|
video_vae = _first_input(kwargs.get("video_vae"))
|
|
audio_vae = _first_input(kwargs.get("audio_vae"))
|
|
_require_moxie_components(model, clip, video_vae, audio_vae)
|
|
|
|
upscale_model = _first_input(kwargs.get("upscale_model"))
|
|
if upscale_model is None:
|
|
upscale_model = SLOW_UPSCALE_MODEL
|
|
upscale_model = str(upscale_model).strip()
|
|
if not upscale_model or upscale_model == "None":
|
|
raise ValueError(
|
|
"Moxie MultiTrack Project Slow always upscales the "
|
|
"half-resolution latent in latent space, so it needs a "
|
|
"model: pick a checkpoint in the upscale_model dropdown "
|
|
"(files under ComfyUI/models/latent_upscale_models/)."
|
|
)
|
|
|
|
sigmas_2nd = _denoise_truncated_sigmas(
|
|
model.get_model_object("model_sampling"),
|
|
BAKED_SCHEDULER,
|
|
SLOW_SECOND_PASS_STEPS,
|
|
SLOW_SECOND_PASS_DENOISE,
|
|
)
|
|
injected = dict(kwargs)
|
|
injected["sampler_2nd"] = comfy.samplers.sampler_object(BAKED_SAMPLER_NAME)
|
|
injected["sigmas_2nd"] = sigmas_2nd
|
|
injected["upscale_model"] = upscale_model
|
|
return super().execute(**injected)
|