The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Save Image advanced node (CORE-32) (#13850)
comfyanonymous0077d78cbfb4
diff --git a/comfy_extras/nodes_images.py b/comfy_extras/nodes_images.pyindex 4856346d7..33933229d 100644--- a/comfy_extras/nodes_images.py+++ b/comfy_extras/nodes_images.py@@ -3,15 +3,23 @@ from __future__ import annotationsimport nodesimport folder_paths+import avimport json+import osimport reimport math+import numpy as np+import structimport torch++import zlibimport comfy.utils+from fractions import Fractionfrom server import PromptServerfrom comfy_api.latest import ComfyExtension, IO, UI+from comfy.cli_args import argsfrom typing_extensions import overrideSVG = IO.SVG.Type # TODO: temporary solution for backward compatibility, will be removed later.@@ -835,6 +843,405 @@ class ImageMergeTileList(IO.ComfyNode):return IO.NodeOutput(merged_image)+# ---------------------------------------------------------------------------+# Format specifications+# ---------------------------------------------------------------------------++# Maps (file_format, bit_depth, has_alpha) -> (numpy dtype scale, av pixel format,+# stream pix_fmt). Keeps the encode path declarative instead of branchy.+_FORMAT_SPECS = {+ ("png", "8-bit", False): {"scale": 255.0, "dtype": np.uint8, "frame_fmt": "rgb24", "stream_fmt": "rgb24"},+ ("png", "8-bit", True): {"scale": 255.0, "dtype": np.uint8, "frame_fmt": "rgba", "stream_fmt": "rgba"},+ ("png", "16-bit", False): {"scale": 65535.0, "dtype": np.uint16, "frame_fmt": "rgb48le", "stream_fmt": "rgb48be"},+ ("png", "16-bit", True): {"scale": 65535.0, "dtype": np.uint16, "frame_fmt": "rgba64le", "stream_fmt": "rgba64be"},+ ("exr", "32-bit float", False): {"scale": 1.0, "dtype": np.float32, "frame_fmt": "gbrpf32le", "stream_fmt": "gbrpf32le"},+ ("exr", "32-bit float", True): {"scale": 1.0, "dtype": np.float32, "frame_fmt": "gbrapf32le", "stream_fmt": "gbrapf32le"},+}+++# ---------------------------------------------------------------------------+# Color transforms+# ---------------------------------------------------------------------------++def srgb_to_linear(t: torch.Tensor) -> torch.Tensor:+ """Inverse sRGB EOTF (IEC 61966-2-1). Operates on RGB channels only;+ alpha (if present as the 4th channel) is passed through unchanged."""+ if t.shape[-1] == 4:+ rgb, alpha = t[..., :3], t[..., 3:]+ return torch.cat([srgb_to_linear(rgb), alpha], dim=-1)++ # Piecewise: linear toe below 0.04045, gamma curve above.+ low = t / 12.92+ high = ((t.clamp(min=0.0) + 0.055) / 1.055) ** 2.4+ return torch.where(t <= 0.04045, low, high)+++# HLG OETF constants from BT.2100 Table 5.+_HLG_A = 0.17883277+_HLG_B = 0.28466892+_HLG_C = 0.55991072928 # = 0.5 - a*ln(4*a)+++def hlg_to_linear(t: torch.Tensor) -> torch.Tensor:+ """Inverse HLG OETF (BT.2100). Maps a non-linear HLG signal in [0, 1] to+ *scene*-linear light in [0, 1]. Per BT.2100 Note 5a, this is the correct+ transform when converting HLG to a linear scene-light representation+ (rather than display-light, which would also involve the HLG OOTF).++ Operates on RGB channels only; alpha is passed through unchanged."""+ if t.shape[-1] == 4:+ rgb, alpha = t[..., :3], t[..., 3:]+ return torch.cat([hlg_to_linear(rgb), alpha], dim=-1)++ # Piecewise: sqrt branch below 0.5, log branch above.+ # Clamp inside the log branch so negative / out-of-range values don't blow up;+ # values above 1.0 are allowed and extrapolate naturally.+ low = (t ** 2) / 3.0+ high = (torch.exp((t.clamp(min=_HLG_C) - _HLG_C) / _HLG_A) + _HLG_B) / 12.0+ return torch.where(t <= 0.5, low, high)+++# ---------------------------------------------------------------------------+# Metadata injection+# ---------------------------------------------------------------------------++_PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"+++def _png_chunk(chunk_type: bytes, data: bytes) -> bytes:+ """Build a single PNG chunk: length | type | data | CRC32(type+data)."""+ crc = zlib.crc32(chunk_type + data) & 0xFFFFFFFF+ return struct.pack(">I", len(data)) + chunk_type + data + struct.pack(">I", crc)+++def _png_text_chunk(keyword: str, text: str) -> bytes:+ """tEXt chunk: latin-1 keyword + NUL + latin-1 text."""+ payload = keyword.encode("latin-1") + b"\x00" + text.encode("latin-1", errors="replace")+ return _png_chunk(b"tEXt", payload)+++def inject_png_metadata(png_bytes: bytes, prompt: dict | None, extra_pnginfo: dict | None) -> bytes:+ """Insert ComfyUI prompt/workflow as tEXt chunks right after IHDR."""+ if not png_bytes.startswith(_PNG_SIGNATURE):+ return png_bytes++ chunks: list[bytes] = []+ if prompt is not None:+ chunks.append(_png_text_chunk("prompt", json.dumps(prompt)))+ if extra_pnginfo:+ for key, value in extra_pnginfo.items():+ chunks.append(_png_text_chunk(key, json.dumps(value)))+ if not chunks:+ return png_bytes++ # IHDR is always the first chunk; insert ours immediately after it.+ ihdr_length = struct.unpack(">I", png_bytes[8:12])[0]+ ihdr_end = 8 + 8 + ihdr_length + 4 # signature + (len+type) + data + crc+ return png_bytes[:ihdr_end] + b"".join(chunks) + png_bytes[ihdr_end:]+++# Standard chromaticities (CIE 1931 xy) for the colorspaces this node writes.+# Each tuple is (Rx, Ry, Gx, Gy, Bx, By, Wx, Wy). All share D65 white point.+_CHROMATICITIES = {+ # ITU-R BT.709 / sRGB primaries+ "Rec.709": (0.6400, 0.3300, 0.3000, 0.6000, 0.1500, 0.0600, 0.3127, 0.3290),+ # ITU-R BT.2020 (UHDTV / wide-gamut HDR) primaries+ "Rec.2020": (0.7080, 0.2920, 0.1700, 0.7970, 0.1310, 0.0460, 0.3127, 0.3290),+}+++def _pack_chromaticities(primaries: tuple) -> bytes:+ """Serialize 8 chromaticity floats into the EXR `chromaticities` payload."""+ return struct.pack("<8f", *primaries)+++def _exr_attribute(name: str, attr_type: str, value: bytes) -> bytes:+ """Serialize one EXR header attribute: name\\0 type\\0 size:int32 value."""+ return (+ name.encode("utf-8") + b"\x00"+ + attr_type.encode("utf-8") + b"\x00"+ + struct.pack("<i", len(value))+ + value+ )+++def inject_exr_metadata(+ exr_bytes: bytes,+ prompt: dict | None,+ extra_pnginfo: dict | None,+ colorspace: str | None = None,+) -> bytes:+ """Insert ComfyUI metadata and color-space info into an EXR header.++ Color: EXR pixels are linear by convention. The standard way to describe+ their RGB→XYZ relationship is the `chromaticities` attribute. We pick the+ primaries that match what the user told us their input was:++ colorspace="sRGB" → Rec. 709 / sRGB primaries (D65)+ colorspace="HDR" → Rec. 2020 / BT.2100 primaries (D65)++ Pixels are always converted to linear scene light upstream (sRGB EOTF+ inverse for sRGB; HLG OETF inverse for HDR), so the file content is+ scene-linear in the indicated gamut. OpenEXR has no standard transfer-+ function attribute (the OpenEXR TSC has discussed adding one but it+ doesn't exist), so we don't invent one — `chromaticities` plus the EXR+ linear-by-convention rule fully specifies the color.++ Prompt/workflow: written as plain `string` attributes using the same keys+ (`prompt`, `workflow`, ...) that Comfy uses for PNG tEXt chunks, so the+ same readers can pull them out symmetrically.++ Implementation note: the chunk-offset table that follows the header stores+ *absolute* byte offsets into the file. Inserting N bytes into the header+ means every offset must be incremented by N or the file becomes unreadable.+ """+ if len(exr_bytes) < 8 or exr_bytes[:4] != b"\x76\x2f\x31\x01":+ return exr_bytes++ new_blob = b""+ if prompt is not None:+ new_blob += _exr_attribute("prompt", "string", json.dumps(prompt).encode("utf-8"))+ if extra_pnginfo:+ for key, value in extra_pnginfo.items():+ new_blob += _exr_attribute(key, "string", json.dumps(value).encode("utf-8"))+ if colorspace is not None:+ # Map each colorspace option to the RGB primaries the linear pixels+ # are now in. "sRGB" and "linear" both produce Rec. 709 linear; "HDR"+ # (HLG-encoded Rec. 2020 input) produces Rec. 2020 linear.+ primaries_name = {+ "sRGB": "Rec.709",+ "linear": "Rec.709",+ "HDR": "Rec.2020",+ }.get(colorspace, "Rec.709")+ new_blob += _exr_attribute(+ "chromaticities",+ "chromaticities",+ _pack_chromaticities(_CHROMATICITIES[primaries_name]),+ )+ if not new_blob:+ return exr_bytes++ # Walk header attributes to find the terminating null byte, and pick up+ # dataWindow + compression so we know how many chunks the offset table has.+ pos = 8 # past magic (4) + version (4)+ data_window = None+ compression = 0+ while pos < len(exr_bytes) and exr_bytes[pos] != 0:+ name_end = exr_bytes.index(b"\x00", pos)+ attr_name = exr_bytes[pos:name_end].decode("latin-1", errors="replace")+ type_end = exr_bytes.index(b"\x00", name_end + 1)+ attr_type = exr_bytes[name_end + 1:type_end].decode("latin-1", errors="replace")+ size = struct.unpack("<i", exr_bytes[type_end + 1:type_end + 5])[0]+ value_start = type_end + 5+ value = exr_bytes[value_start:value_start + size]++ if attr_name == "dataWindow" and attr_type == "box2i":+ data_window = struct.unpack("<iiii", value) # xMin, yMin, xMax, yMax+ elif attr_name == "compression" and attr_type == "compression":+ compression = value[0]++ pos = value_start + size++ if data_window is None:+ return exr_bytes # required attribute missing — don't risk corrupting++ # Scanlines per chunk by compression, from the OpenEXR spec.+ scanlines_per_block = {+ 0: 1, # NO_COMPRESSION+ 1: 1, # RLE+ 2: 1, # ZIPS+ 3: 16, # ZIP+ 4: 32, # PIZ+ 5: 16, # PXR24+ 6: 32, # B44+ 7: 32, # B44A+ 8: 256, # DWAA+ 9: 256, # DWAB+ }.get(compression, 1)++ _, y_min, _, y_max = data_window+ height = y_max - y_min + 1+ num_chunks = (height + scanlines_per_block - 1) // scanlines_per_block++ header_end = pos # position of the terminating null byte+ table_start = header_end + 1+ pixel_start = table_start + num_chunks * 8+ delta = len(new_blob)++ old_offsets = struct.unpack(f"<{num_chunks}Q", exr_bytes[table_start:pixel_start])+ new_table = struct.pack(f"<{num_chunks}Q", *(o + delta for o in old_offsets))++ return (+ exr_bytes[:header_end] # header attributes+ + new_blob # our new attributes+ + exr_bytes[header_end:table_start] # terminating null byte+ + new_table # shifted offset table+ + exr_bytes[pixel_start:] # pixel data, untouched+ )+++# ---------------------------------------------------------------------------+# Encoding+# ---------------------------------------------------------------------------++def _encode_image(+ img_tensor: torch.Tensor,+ file_format: str,+ bit_depth: str,+ colorspace: str,+) -> bytes:+ """Encode a single HxWxC tensor to PNG or EXR bytes in memory.++ For EXR the input is interpreted according to `colorspace` and converted+ to scene-linear (EXR's convention) before writing:++ "sRGB" → input is sRGB-encoded Rec. 709; apply inverse sRGB EOTF.+ "HDR" → input is HLG-encoded Rec. 2020 (BT.2100); apply inverse HLG+ OETF to get scene-linear, per BT.2100 Note 5a.+ "linear" → input is already scene-linear (Rec. 709 primaries); write+ through unchanged. Use this for renderer/compositor output.++ For PNG, colorspace selection does not modify pixels — PNG is delivered+ sRGB-encoded and there is no PNG path for wide-gamut HDR in this node.+ """+ height, width, num_channels = img_tensor.shape+ has_alpha = num_channels == 4++ spec = _FORMAT_SPECS[(file_format, bit_depth, has_alpha)]++ if spec["dtype"] == np.float32:+ # EXR path: preserve full range, no clamp.+ if colorspace == "sRGB":+ img_tensor = srgb_to_linear(img_tensor)+ elif colorspace == "HDR":+ img_tensor = hlg_to_linear(img_tensor)+ img_np = img_tensor.cpu().numpy().astype(np.float32)+ else:+ # PNG path: quantize to integer range.+ scaled = (img_tensor * spec["scale"]).clamp(0, spec["scale"])+ img_np = scaled.to(torch.int32).cpu().numpy().astype(spec["dtype"])++ # Encode directly via CodecContext. PyAV's `image2` muxer does NOT write to+ # BytesIO (it expects a real file path), so we bypass the container entirely.+ # For single-frame PNG/EXR the raw codec output IS the file.+ codec = av.CodecContext.create(file_format, "w")+ codec.width = width+ codec.height = height+ codec.pix_fmt = spec["stream_fmt"]+ codec.time_base = Fraction(1, 1)++ frame = av.VideoFrame.from_ndarray(img_np, format=spec["frame_fmt"])+ if spec["frame_fmt"] != spec["stream_fmt"]:+ frame = frame.reformat(format=spec["stream_fmt"])+ frame.pts = 0+ frame.time_base = codec.time_base++ packets = list(codec.encode(frame)) + list(codec.encode(None)) # flush with None+ return b"".join(bytes(p) for p in packets)+++# ---------------------------------------------------------------------------+# Node+# ---------------------------------------------------------------------------++class SaveImageAdvanced(IO.ComfyNode):+ @classmethod+ def define_schema(cls):+ return IO.Schema(+ node_id="SaveImageAdvanced",+ search_aliases=["save", "save image", "export image", "output image", "write image"],+ display_name="Save Image (Advanced)",+ description="Saves the input images to your ComfyUI output directory.",+ category="image",+ essentials_category="Basics",+ inputs=[+ IO.Image.Input("images", tooltip="The images to save."),+ IO.String.Input(+ "filename_prefix",+ default="ComfyUI",+ tooltip=(+ "The prefix for the file to save. May include formatting tokens "+ "such as %date:yyyy-MM-dd% or %Empty Latent Image.width%."+ ),+ ),+ IO.DynamicCombo.Input(+ "format",+ options=[+ IO.DynamicCombo.Option("png", [+ IO.Combo.Input("bit_depth", options=["8-bit", "16-bit"],+ default="8-bit", advanced=True),+ IO.Combo.Input("input_color_space", options=["sRGB"],+ default="sRGB", advanced=True),+ ]),+ IO.DynamicCombo.Option("exr", [+ IO.Combo.Input("bit_depth", options=["32-bit float"],+ default="32-bit float", advanced=True),+ IO.Combo.Input(+ "input_color_space",+ options=["sRGB", "HDR", "linear"],+ default="sRGB",+ advanced=True,+ tooltip=(+ "Colorspace of the input tensor. The EXR is "+ "always written as scene-linear in the matching "+ "gamut.\n"+ " 'sRGB' — input is sRGB-encoded Rec.709; "+ "the inverse sRGB EOTF is applied.\n"+ " 'HDR' — input is HLG-encoded Rec.2020 "+ "(BT.2100); the inverse HLG OETF is applied "+ "to get scene-linear light.\n"+ " 'linear' — input is already scene-linear "+ "(Rec.709 primaries); written through unchanged. "+ "Use this for renderer/compositor output."+ ),+ ),+ ]),+ ],+ tooltip="The file format in which to save the image.",+ ),+ ],+ hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo],+ is_output_node=True,+ )++ @classmethod+ def execute(cls, images, filename_prefix: str, format: dict) -> IO.NodeOutput:+ file_format = format["format"]+ bit_depth = format["bit_depth"]+ colorspace = format.get("input_color_space", "sRGB")++ output_dir = folder_paths.get_output_directory()+ full_output_folder, filename, counter, subfolder, filename_prefix = (+ folder_paths.get_save_image_path(+ filename_prefix, output_dir, images[0].shape[1], images[0].shape[0]+ )+ )++ prompt = cls.hidden.prompt+ extra_pnginfo = cls.hidden.extra_pnginfo+ write_metadata = not args.disable_metadata++ results = []+ for batch_number, image in enumerate(images):+ encoded = _encode_image(image, file_format, bit_depth, colorspace)++ if write_metadata:+ if file_format == "png":+ encoded = inject_png_metadata(encoded, prompt, extra_pnginfo)+ elif file_format == "exr":+ encoded = inject_exr_metadata(encoded, prompt, extra_pnginfo, colorspace)++ name = filename.replace("%batch_num%", str(batch_number))+ file = f"{name}_{counter:05}.{file_format}"+ with open(os.path.join(full_output_folder, file), "wb") as f:+ f.write(encoded)++ results.append({"filename": file, "subfolder": subfolder, "type": "output"})+ counter += 1++ return IO.NodeOutput(ui={"images": results})++class ImagesExtension(ComfyExtension):@overrideasync def get_node_list(self) -> list[type[IO.ComfyNode]]:@@ -847,6 +1254,7 @@ class ImagesExtension(ComfyExtension):ImageAddNoise,SaveAnimatedWEBP,SaveAnimatedPNG,+ SaveImageAdvanced,SaveSVGNode,ImageStitch,ResizeAndPadImage,