Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

[Partner Nodes] fix (Seedance 2.0): prevent 1080p first/last-frame stretch jump (#14251)

Alexander Piskun4d360f9c9d33
diff --git a/comfy_api_nodes/nodes_bytedance.py b/comfy_api_nodes/nodes_bytedance.py
index d8885a7e5..c30ddc446 100644
--- a/comfy_api_nodes/nodes_bytedance.py
+++ b/comfy_api_nodes/nodes_bytedance.py
@@ -7,6 +7,7 @@ from io import BytesIO
import torch
from typing_extensions import override
+from comfy.utils import common_upscale
from comfy_api.latest import IO, ComfyExtension, Input, Types
from comfy_api_nodes.apis.bytedance import (
RECOMMENDED_PRESETS,
@@ -131,6 +132,44 @@ def _prepare_seedance_image(image: Input.Image) -> Input.Image:
return image
+# Supported output aspect ratios, used to pre-size FLF frames to matching pixel pair to avoid the 1080p stretch jump.
+SEEDANCE2_RATIO_WH = {
+ "16:9": (16, 9),
+ "4:3": (4, 3),
+ "1:1": (1, 1),
+ "3:4": (3, 4),
+ "9:16": (9, 16),
+ "21:9": (21, 9),
+}
+SEEDANCE2_RES_SHORT_SIDE = {"480p": 480, "720p": 720, "1080p": 1080}
+
+
+def _seedance2_target_dims(resolution: str, ratio: str, image: torch.Tensor) -> tuple[int, int]:
+ """Exact supported output (width, height) for (resolution, ratio).
+
+ The shorter side equals the resolution number (e.g. 1080p 16:9 -> 1920x1080). For ratio
+ "adaptive" (or any unexpected value) the ratio is derived from the image's own aspect, snapped
+ to the nearest supported ratio, so the output keeps the frame's orientation.
+ """
+ short = SEEDANCE2_RES_SHORT_SIDE[resolution]
+ if ratio not in SEEDANCE2_RATIO_WH:
+ aspect = image.shape[-2] / image.shape[-3] # W / H; tensor is (B, H, W, C)
+ ratio = min(SEEDANCE2_RATIO_WH, key=lambda k: abs(SEEDANCE2_RATIO_WH[k][0] / SEEDANCE2_RATIO_WH[k][1] - aspect))
+ rw, rh = SEEDANCE2_RATIO_WH[ratio]
+ if rw >= rh: # landscape or square: shorter side is the height
+ out_w, out_h = round(short * rw / rh), short
+ else: # portrait: shorter side is the width
+ out_w, out_h = short, round(short * rh / rw)
+ return out_w - out_w % 2, out_h - out_h % 2
+
+
+def _resize_to_exact(image: torch.Tensor, width: int, height: int) -> torch.Tensor:
+ """Center-crop to the target aspect and resize to exactly width x height (lanczos)."""
+ samples = image.movedim(-1, 1) # (B, H, W, C) -> (B, C, H, W)
+ resized = common_upscale(samples, width, height, "lanczos", "center")
+ return resized.movedim(1, -1)
+
+
async def _resolve_reference_assets(
cls: type[IO.ComfyNode],
asset_ids: list[str],
@@ -1790,10 +1829,28 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
if last_frame is not None and last_frame_asset_id:
raise ValueError("Provide only one of last_frame or last_frame_asset_id, not both.")
- if first_frame is not None:
- first_frame = _prepare_seedance_image(first_frame)
- if last_frame is not None:
- last_frame = _prepare_seedance_image(last_frame)
+ request_ratio = model["ratio"]
+ if first_frame_asset_id or last_frame_asset_id:
+ if first_frame is not None:
+ first_frame = _prepare_seedance_image(first_frame)
+ if last_frame is not None:
+ last_frame = _prepare_seedance_image(last_frame)
+ else:
+ # The 1080p FLF stretch fix (pre-size frames to a supported pixel pair + submit ratio="adaptive")
+ # only applies to local image inputs we can resize.
+ request_ratio = "adaptive"
+ target_dims: tuple[int, int] | None = None
+ if first_frame is not None:
+ validate_image_aspect_ratio(first_frame, (2, 5), (5, 2), strict=False) # 0.4 to 2.5
+ validate_image_dimensions(first_frame, min_width=300, min_height=300)
+ target_dims = _seedance2_target_dims(model["resolution"], model["ratio"], first_frame)
+ first_frame = _resize_to_exact(first_frame, *target_dims)
+ if last_frame is not None:
+ validate_image_aspect_ratio(last_frame, (2, 5), (5, 2), strict=False) # 0.4 to 2.5
+ validate_image_dimensions(last_frame, min_width=300, min_height=300)
+ if target_dims is None:
+ target_dims = _seedance2_target_dims(model["resolution"], model["ratio"], last_frame)
+ last_frame = _resize_to_exact(last_frame, *target_dims)
asset_ids_to_resolve = [a for a in (first_frame_asset_id, last_frame_asset_id) if a]
image_assets: dict[str, str] = {}
@@ -1844,7 +1901,7 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
content=content,
generate_audio=model["generate_audio"],
resolution=model["resolution"],
- ratio=model["ratio"],
+ ratio=request_ratio,
duration=model["duration"],
seed=seed,
watermark=watermark,