Tiling stops being a baked setting and becomes a widget: the new Boolean
tiling switch next to upscale_model (default on) turns the memory-adaptive
spatial tiles of the 2-step refine pass off, so the pass can be sampled in
one piece on machines that prefer the pre-tiling behaviour.
- OFF injects {enabled_tiling: "false", tile_count: 0}; the engine then
builds the plain SamplerCustomAdvanced second pass instead of the tiled
preview sampler
- ON keeps tile_count 0 (automatic): the engine picks the tile count from
the available accelerator memory and skips tiling when the full
evaluation fits, keeping 1920x1080 within reach of 12 GB and AMD/Intel
GPUs
- workflows saved before the switch existed keep tiling on
- tests: schema slot order + defaults, switch ON/OFF passthrough, legacy
fallback; docs: CHANGELOG + multitrack-schema reference
372 lines
15 KiB
Python
372 lines
15 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}
|
|
# The tiling toggle OFF: the engine skips tiling and samples the refine pass
|
|
# in one piece (plain SamplerCustomAdvanced, the pre-tiling behaviour).
|
|
SLOW_TILING_DISABLED = {"enabled_tiling": "false", "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 and neither is tiling: the Slow node exposes the
|
|
# upscale_model widget and the tiling toggle instead.
|
|
"upscale_by": 1.0,
|
|
}
|
|
|
|
|
|
_TILING_ON_VALUES = frozenset({"true", "enable", "enabled", "on", "1"})
|
|
|
|
|
|
def _tiling_switch(value, default: bool = True) -> bool:
|
|
"""Resolve the tiling toggle; tolerates booleans and legacy strings."""
|
|
enabled = _first_input(value, default)
|
|
if isinstance(enabled, str):
|
|
return enabled.strip().lower() in _TILING_ON_VALUES
|
|
return bool(enabled)
|
|
|
|
|
|
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. The `tiling` switch
|
|
turns the tiles off for machines that prefer the refine pass sampled in
|
|
one piece. 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."
|
|
),
|
|
),
|
|
io.Boolean.Input(
|
|
"tiling",
|
|
default=True,
|
|
tooltip=(
|
|
"Tile the 2-step refine pass so large projects (up to "
|
|
"1920x1080) also fit on 12 GB cards and on AMD or Intel "
|
|
"GPUs; the tile count adapts to the available memory and "
|
|
"tiling is skipped entirely when the whole pass fits "
|
|
"anyway. Disable to sample the refine pass in one piece."
|
|
),
|
|
),
|
|
]
|
|
|
|
@classmethod
|
|
def _baked_project_settings(cls) -> dict:
|
|
settings = dict(BAKED_PROJECT_SETTINGS)
|
|
# The upscaler checkpoint and the tiling switch come from widgets.
|
|
settings.pop("upscale_model", None)
|
|
settings.pop("enabled_tiling", 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); the tiling switch "
|
|
"turns the tiles off; 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,
|
|
)
|
|
# The tiling toggle: ON (default, also for old workflows without the
|
|
# widget) keeps the memory-adaptive automatic tile count; OFF hands
|
|
# the engine an explicit disabled config so the refine pass is
|
|
# sampled in one piece.
|
|
tiling_on = _tiling_switch(kwargs.get("tiling"))
|
|
injected = dict(kwargs)
|
|
injected["sampler_2nd"] = comfy.samplers.sampler_object(BAKED_SAMPLER_NAME)
|
|
injected["sigmas_2nd"] = sigmas_2nd
|
|
injected["upscale_model"] = upscale_model
|
|
injected["enabled_tiling"] = (
|
|
SLOW_TILING_SETTINGS if tiling_on else SLOW_TILING_DISABLED
|
|
)
|
|
return super().execute(**injected)
|