Upload 23 files

load_image_from_url.py

@@ -0,0 +1,63 @@
+"""
+Improved LoadImageFromURL node for ComfyUI
+Place this file in ComfyUI/custom_nodes/load_image_from_url.py
+"""
+import torch
+import requests
+from PIL import Image
+import numpy as np
+import io
+
+class LoadImageFromURL:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "url": ("STRING", {"default": "https://example.com/image.jpg"}),
+            }
+        }
+    
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "load_image"
+    CATEGORY = "image"
+    
+    def load_image(self, url):
+        try:
+            # Download the image
+            response = requests.get(url, timeout=30, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            })
+            response.raise_for_status()
+            
+            # Open the image
+            image = Image.open(io.BytesIO(response.content))
+            
+            # Convert to RGB if needed
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Convert to tensor
+            image_array = np.array(image).astype(np.float32) / 255.0
+            image_tensor = torch.from_numpy(image_array)[None,]
+            
+            # Create mask with same dimensions as image (height, width)
+            h, w = image_array.shape[:2]
+            mask = torch.zeros((h, w), dtype=torch.float32, device="cpu")
+            
+            return (image_tensor, mask)
+            
+        except Exception as e:
+            print(f"Error loading image from URL: {e}")
+            # Return a blank 512x512 image if loading fails
+            blank_image = torch.zeros((1, 512, 512, 3), dtype=torch.float32, device="cpu")
+            mask = torch.zeros((512, 512), dtype=torch.float32, device="cpu")
+            return (blank_image, mask)
+
+# Node class mappings
+NODE_CLASS_MAPPINGS = {
+    "LoadImageFromURL": LoadImageFromURL,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LoadImageFromURL": "Load Image From URL",
+}

standalone_video_combine/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(xcopy:*)",
+      "Bash(dir \"C:\\Users\\newec\\Documents\\ComfyUI\\custom_nodes\\standalone_video_combine_backup_20250113\")",
+      "Read(//c/Users/newec/Downloads/**)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

standalone_video_combine/__init__.py

@@ -0,0 +1,8 @@
+"""
+Standalone Video Combine Node for ComfyUI
+Extracted from ComfyUI-VideoHelperSuite
+"""
+
+from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

standalone_video_combine/logger.py

@@ -0,0 +1,36 @@
+import sys
+import copy
+import logging
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[0;36m",  # CYAN
+        "INFO": "\033[0;32m",  # GREEN
+        "WARNING": "\033[0;33m",  # YELLOW
+        "ERROR": "\033[0;31m",  # RED
+        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
+        "RESET": "\033[0m",  # RESET COLOR
+    }
+
+    def format(self, record):
+        colored_record = copy.copy(record)
+        levelname = colored_record.levelname
+        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
+        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
+        return super().format(colored_record)
+
+
+# Create a new logger
+logger = logging.getLogger("VideoHelperSuite")
+logger.propagate = False
+
+# Add handler if we don't have one.
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(ColoredFormatter("[%(name)s] - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+# Configure logger
+loglevel = logging.INFO
+logger.setLevel(loglevel)

standalone_video_combine/nodes.py

@@ -0,0 +1,693 @@
+import os
+import sys
+import json
+import subprocess
+import numpy as np
+import re
+import datetime
+from typing import List
+import torch
+from PIL import Image, ExifTags
+from PIL.PngImagePlugin import PngInfo
+from pathlib import Path
+from string import Template
+import itertools
+import functools
+
+import folder_paths
+from .logger import logger
+from .utils import ffmpeg_path, requeue_workflow, \
+        gifski_path, imageOrLatent, BIGMAX, merge_filter_args, ENCODE_ARGS, floatOrInt, cached, \
+        ContainsAll
+from comfy.utils import ProgressBar
+
+if 'VHS_video_formats' not in folder_paths.folder_names_and_paths:
+    folder_paths.folder_names_and_paths["VHS_video_formats"] = ((),{".json"})
+if len(folder_paths.folder_names_and_paths['VHS_video_formats'][1]) == 0:
+    folder_paths.folder_names_and_paths["VHS_video_formats"][1].add(".json")
+
+def flatten_list(l):
+    ret = []
+    for e in l:
+        if isinstance(e, list):
+            ret.extend(e)
+        else:
+            ret.append(e)
+    return ret
+
+def iterate_format(video_format, for_widgets=True):
+    """Provides an iterator over widgets, or arguments"""
+    def indirector(cont, index):
+        if isinstance(cont[index], list) and (not for_widgets
+          or len(cont[index])> 1 and not isinstance(cont[index][1], dict)):
+            inp = yield cont[index]
+            if inp is not None:
+                cont[index] = inp
+                yield
+    for k in video_format:
+        if k == "extra_widgets":
+            if for_widgets:
+                yield from video_format["extra_widgets"]
+        elif k.endswith("_pass"):
+            for i in range(len(video_format[k])):
+                yield from indirector(video_format[k], i)
+            if not for_widgets:
+                video_format[k] = flatten_list(video_format[k])
+        else:
+            yield from indirector(video_format, k)
+
+base_formats_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "video_formats")
+@cached(5)
+def get_video_formats():
+    format_files = {}
+    for format_name in folder_paths.get_filename_list("VHS_video_formats"):
+        format_files[format_name] = folder_paths.get_full_path("VHS_video_formats", format_name)
+    for item in os.scandir(base_formats_dir):
+        if not item.is_file() or not item.name.endswith('.json'):
+            continue
+        format_files[item.name[:-5]] = item.path
+    formats = []
+    format_widgets = {}
+    for format_name, path in format_files.items():
+        with open(path, 'r') as stream:
+            video_format = json.load(stream)
+        if "gifski_pass" in video_format and gifski_path is None:
+            #Skip format
+            continue
+        widgets = list(iterate_format(video_format))
+        formats.append("video/" + format_name)
+        if (len(widgets) > 0):
+            format_widgets["video/"+ format_name] = widgets
+    return formats, format_widgets
+
+def apply_format_widgets(format_name, kwargs):
+    if os.path.exists(os.path.join(base_formats_dir, format_name + ".json")):
+        video_format_path = os.path.join(base_formats_dir, format_name + ".json")
+    else:
+        video_format_path = folder_paths.get_full_path("VHS_video_formats", format_name)
+    with open(video_format_path, 'r') as stream:
+        video_format = json.load(stream)
+    for w in iterate_format(video_format):
+        if w[0] not in kwargs:
+            if len(w) > 2 and 'default' in w[2]:
+                default = w[2]['default']
+            else:
+                if type(w[1]) is list:
+                    default = w[1][0]
+                else:
+                    #NOTE: This doesn't respect max/min, but should be good enough as a fallback to a fallback to a fallback
+                    default = {"BOOLEAN": False, "INT": 0, "FLOAT": 0, "STRING": ""}[w[1]]
+            kwargs[w[0]] = default
+            logger.warn(f"Missing input for {w[0]} has been set to {default}")
+    wit = iterate_format(video_format, False)
+    for w in wit:
+        while isinstance(w, list):
+            if len(w) == 1:
+                #TODO: mapping=kwargs should be safer, but results in key errors, investigate why
+                w = [Template(x).substitute(**kwargs) for x in w[0]]
+                break
+            elif isinstance(w[1], dict):
+                w = w[1][str(kwargs[w[0]])]
+            elif len(w) > 3:
+                w = Template(w[3]).substitute(val=kwargs[w[0]])
+            else:
+                w = str(kwargs[w[0]])
+        wit.send(w)
+    return video_format
+
+def tensor_to_int(tensor, bits):
+    tensor = tensor.cpu().numpy() * (2**bits-1) + 0.5
+    return np.clip(tensor, 0, (2**bits-1))
+def tensor_to_shorts(tensor):
+    return tensor_to_int(tensor, 16).astype(np.uint16)
+def tensor_to_bytes(tensor):
+    return tensor_to_int(tensor, 8).astype(np.uint8)
+
+def ffmpeg_process(args, video_format, video_metadata, file_path, env):
+
+    res = None
+    frame_data = yield
+    total_frames_output = 0
+    if video_format.get('save_metadata', 'False') != 'False':
+        os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+        metadata = json.dumps(video_metadata)
+        metadata_path = os.path.join(folder_paths.get_temp_directory(), "metadata.txt")
+        #metadata from file should  escape = ; # \ and newline
+        metadata = metadata.replace("\\","\\\\")
+        metadata = metadata.replace(";","\\;")
+        metadata = metadata.replace("#","\\#")
+        metadata = metadata.replace("=","\\=")
+        metadata = metadata.replace("\n","\\\n")
+        metadata = "comment=" + metadata
+        with open(metadata_path, "w") as f:
+            f.write(";FFMETADATA1\n")
+            f.write(metadata)
+        m_args = args[:1] + ["-i", metadata_path] + args[1:] + ["-metadata", "creation_time=now"]
+        with subprocess.Popen(m_args + [file_path], stderr=subprocess.PIPE,
+                              stdin=subprocess.PIPE, env=env) as proc:
+            try:
+                while frame_data is not None:
+                    proc.stdin.write(frame_data)
+                    #TODO: skip flush for increased speed
+                    frame_data = yield
+                    total_frames_output+=1
+                proc.stdin.flush()
+                proc.stdin.close()
+                res = proc.stderr.read()
+            except BrokenPipeError as e:
+                err = proc.stderr.read()
+                #Check if output file exists. If it does, the re-execution
+                #will also fail. This obscures the cause of the error
+                #and seems to never occur concurrent to the metadata issue
+                if os.path.exists(file_path):
+                    raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                            + err.decode(*ENCODE_ARGS))
+                #Res was not set
+                print(err.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+                logger.warn("An error occurred when saving with metadata")
+    if res != b'':
+        with subprocess.Popen(args + [file_path], stderr=subprocess.PIPE,
+                              stdin=subprocess.PIPE, env=env) as proc:
+            try:
+                while frame_data is not None:
+                    proc.stdin.write(frame_data)
+                    frame_data = yield
+                    total_frames_output+=1
+                proc.stdin.flush()
+                proc.stdin.close()
+                res = proc.stderr.read()
+            except BrokenPipeError as e:
+                res = proc.stderr.read()
+                raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                        + res.decode(*ENCODE_ARGS))
+    yield total_frames_output
+    if len(res) > 0:
+        print(res.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+
+def gifski_process(args, dimensions, video_format, file_path, env):
+    frame_data = yield
+    with subprocess.Popen(args + video_format['main_pass'] + ['-f', 'yuv4mpegpipe', '-'],
+                          stderr=subprocess.PIPE, stdin=subprocess.PIPE,
+                          stdout=subprocess.PIPE, env=env) as procff:
+        with subprocess.Popen([gifski_path] + video_format['gifski_pass']
+                              + ['-W', f'{dimensions[0]}', '-H', f'{dimensions[1]}']
+                              + ['-q', '-o', file_path, '-'], stderr=subprocess.PIPE,
+                              stdin=procff.stdout, stdout=subprocess.PIPE,
+                              env=env) as procgs:
+            try:
+                while frame_data is not None:
+                    procff.stdin.write(frame_data)
+                    frame_data = yield
+                procff.stdin.flush()
+                procff.stdin.close()
+                resff = procff.stderr.read()
+                resgs = procgs.stderr.read()
+                outgs = procgs.stdout.read()
+            except BrokenPipeError as e:
+                procff.stdin.close()
+                resff = procff.stderr.read()
+                resgs = procgs.stderr.read()
+                raise Exception("An error occurred while creating gifski output\n" \
+                        + "Make sure you are using gifski --version >=1.32.0\nffmpeg: " \
+                        + resff.decode(*ENCODE_ARGS) + '\ngifski: ' + resgs.decode(*ENCODE_ARGS))
+    if len(resff) > 0:
+        print(resff.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+    if len(resgs) > 0:
+        print(resgs.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+    #should always be empty as the quiet flag is passed
+    if len(outgs) > 0:
+        print(outgs.decode(*ENCODE_ARGS))
+
+def to_pingpong(inp):
+    if not hasattr(inp, "__getitem__"):
+        inp = list(inp)
+    yield from inp
+    for i in range(len(inp)-2,0,-1):
+        yield inp[i]
+
+class VideoCombine:
+    @classmethod
+    def INPUT_TYPES(s):
+        ffmpeg_formats, format_widgets = get_video_formats()
+        format_widgets["image/webp"] = [['lossless', "BOOLEAN", {'default': True}]]
+        return {
+            "required": {
+                "images": (imageOrLatent,),
+                "frame_rate": (
+                    floatOrInt,
+                    {"default": 8, "min": 1, "step": 1},
+                ),
+                "loop_count": ("INT", {"default": 0, "min": 0, "max": 100, "step": 1}),
+                "filename_prefix": ("STRING", {"default": "AnimateDiff"}),
+                "filename_suffix": ("STRING", {"default": ""}),
+                "save_path": ("STRING", {"default": "", "multiline": False}),
+                "format": (["image/gif", "image/webp"] + ffmpeg_formats, {'formats': format_widgets}),
+                "pingpong": ("BOOLEAN", {"default": False}),
+                "save_output": ("BOOLEAN", {"default": True}),
+            },
+            "optional": {
+                "audio": ("AUDIO",),
+                "meta_batch": ("VHS_BatchManager",),
+                "vae": ("VAE",),
+            },
+            "hidden": ContainsAll({
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+                "unique_id": "UNIQUE_ID"
+            }),
+        }
+
+    RETURN_TYPES = ("VHS_FILENAMES",)
+    RETURN_NAMES = ("Filenames",)
+    OUTPUT_NODE = True
+    CATEGORY = "EQX/Video"
+    FUNCTION = "combine_video"
+
+    def combine_video(
+        self,
+        frame_rate: int,
+        loop_count: int,
+        images=None,
+        latents=None,
+        filename_prefix="AnimateDiff",
+        filename_suffix="",
+        save_path="",
+        format="image/gif",
+        pingpong=False,
+        save_output=True,
+        prompt=None,
+        extra_pnginfo=None,
+        audio=None,
+        unique_id=None,
+        manual_format_widgets=None,
+        meta_batch=None,
+        vae=None,
+        **kwargs
+    ):
+        if latents is not None:
+            images = latents
+        if images is None:
+            return ((save_output, []),)
+        if vae is not None:
+            if isinstance(images, dict):
+                images = images['samples']
+            else:
+                vae = None
+
+        if isinstance(images, torch.Tensor) and images.size(0) == 0:
+            return ((save_output, []),)
+        num_frames = len(images)
+        pbar = ProgressBar(num_frames)
+        if vae is not None:
+            downscale_ratio = getattr(vae, "downscale_ratio", 8)
+            width = images.size(-1)*downscale_ratio
+            height = images.size(-2)*downscale_ratio
+            frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
+            #Python 3.12 adds an itertools.batched, but it's easily replicated for legacy support
+            def batched(it, n):
+                while batch := tuple(itertools.islice(it, n)):
+                    yield batch
+            def batched_encode(images, vae, frames_per_batch):
+                for batch in batched(iter(images), frames_per_batch):
+                    image_batch = torch.from_numpy(np.array(batch))
+                    yield from vae.decode(image_batch)
+            images = batched_encode(images, vae, frames_per_batch)
+            first_image = next(images)
+            #repush first_image
+            images = itertools.chain([first_image], images)
+            #A single image has 3 dimensions. Discard higher dimensions
+            while len(first_image.shape) > 3:
+                first_image = first_image[0]
+        else:
+            first_image = images[0]
+            images = iter(images)
+        # get output information
+        logger.info("💾 Saving video...")
+        if save_path and save_path.strip():
+            # Use custom save path if provided
+            save_path_clean = save_path.strip()
+            logger.info(f"📁 Path: {save_path_clean}")
+            # Expand user path and environment variables
+            save_path_clean = os.path.expanduser(save_path_clean)
+            save_path_clean = os.path.expandvars(save_path_clean)
+            # Make absolute path if relative
+            if not os.path.isabs(save_path_clean):
+                save_path_clean = os.path.abspath(save_path_clean)
+            # Create directory if it doesn't exist
+            os.makedirs(save_path_clean, exist_ok=True)
+            output_dir = save_path_clean
+            full_output_folder = output_dir
+            # For custom path, we'll handle the suffix differently
+            # Just use prefix and timestamp in the base filename
+            filename = filename_prefix
+            subfolder = ""
+            # Add timestamp to filename to avoid overwriting
+            import time
+            timestamp = int(time.time())
+            filename = f"{filename}_{timestamp:08d}"
+            # Note: suffix will be added later when creating the actual file
+        else:
+            # Use default ComfyUI output directory
+            output_dir = (
+                folder_paths.get_output_directory()
+                if save_output
+                else folder_paths.get_temp_directory()
+            )
+            logger.info(f"📁 Path: {output_dir}")
+            (
+                full_output_folder,
+                filename,
+                _,
+                subfolder,
+                _,
+            ) = folder_paths.get_save_image_path(filename_prefix, output_dir)
+        output_files = []
+
+        metadata = PngInfo()
+        video_metadata = {}
+        if prompt is not None:
+            metadata.add_text("prompt", json.dumps(prompt))
+            video_metadata["prompt"] = json.dumps(prompt)
+        if extra_pnginfo is not None:
+            for x in extra_pnginfo:
+                metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+                video_metadata[x] = extra_pnginfo[x]
+            extra_options = extra_pnginfo.get('workflow', {}).get('extra', {})
+        else:
+            extra_options = {}
+        metadata.add_text("CreationTime", datetime.datetime.now().isoformat(" ")[:19])
+
+        if meta_batch is not None and unique_id in meta_batch.outputs:
+            (counter, output_process) = meta_batch.outputs[unique_id]
+        else:
+            # comfy counter workaround
+            max_counter = 0
+
+            # Loop through the existing files
+            # For custom path: {prefix}_{timestamp}_{counter}_{suffix}.ext or {prefix}_{timestamp}_{counter}.ext
+            # For default path: {filename}_{counter}.ext
+            if save_path and save_path.strip():
+                # Custom path pattern - look for counter after timestamp
+                if filename_suffix:
+                    # Pattern: prefix_timestamp_COUNTER_suffix.ext
+                    matcher = re.compile(f"{re.escape(filename_prefix)}_\\d{{8,10}}_(\\d{{5}})_{re.escape(filename_suffix)}\\..+", re.IGNORECASE)
+                else:
+                    # Pattern: prefix_timestamp_COUNTER.ext
+                    matcher = re.compile(f"{re.escape(filename_prefix)}_\\d{{8,10}}_(\\d{{5}})\\..+", re.IGNORECASE)
+            else:
+                # Default ComfyUI path pattern
+                matcher = re.compile(f"{re.escape(filename)}_(\\d+)\\D*\\..+", re.IGNORECASE)
+
+            for existing_file in os.listdir(full_output_folder):
+                # Check if the file matches the expected format
+                match = matcher.fullmatch(existing_file)
+                if match:
+                    # Extract the numeric portion of the filename
+                    file_counter = int(match.group(1))
+                    # Update the maximum counter value if necessary
+                    if file_counter > max_counter:
+                        max_counter = file_counter
+
+            # Increment the counter by 1 to get the next available value
+            counter = max_counter + 1
+            output_process = None
+
+        # Skip saving first frame as png - only save video
+
+        format_type, format_ext = format.split("/")
+        if format_type == "image":
+            if meta_batch is not None:
+                raise Exception("Pillow('image/') formats are not compatible with batched output")
+            image_kwargs = {}
+            if format_ext == "gif":
+                image_kwargs['disposal'] = 2
+            if format_ext == "webp":
+                #Save timestamp information
+                exif = Image.Exif()
+                exif[ExifTags.IFD.Exif] = {36867: datetime.datetime.now().isoformat(" ")[:19]}
+                image_kwargs['exif'] = exif
+                image_kwargs['lossless'] = kwargs.get("lossless", True)
+            if filename_suffix:
+                file = f"{filename}_{counter:05}_{filename_suffix}.{format_ext}"
+            else:
+                file = f"{filename}_{counter:05}.{format_ext}"
+            file_path = os.path.join(full_output_folder, file)
+            if pingpong:
+                images = to_pingpong(images)
+            def frames_gen(images):
+                for i in images:
+                    pbar.update(1)
+                    yield Image.fromarray(tensor_to_bytes(i))
+            frames = frames_gen(images)
+            # Use pillow directly to save an animated image
+            next(frames).save(
+                file_path,
+                format=format_ext.upper(),
+                save_all=True,
+                append_images=frames,
+                duration=round(1000 / frame_rate),
+                loop=loop_count,
+                compress_level=4,
+                **image_kwargs
+            )
+            output_files.append(file_path)
+            logger.info(f"📝 File: {file}")
+            logger.info("✅ Video saved successfully!")
+        else:
+            # Use ffmpeg to save a video
+            if ffmpeg_path is None:
+                raise ProcessLookupError(f"ffmpeg is required for video outputs and could not be found.\nIn order to use video outputs, you must either:\n- Install imageio-ffmpeg with pip,\n- Place a ffmpeg executable in {os.path.abspath('')}, or\n- Install ffmpeg and add it to the system path.")
+
+            if manual_format_widgets is not None:
+                logger.warn("Format args can now be passed directly. The manual_format_widgets argument is now deprecated")
+                kwargs.update(manual_format_widgets)
+
+            has_alpha = first_image.shape[-1] == 4
+            kwargs["has_alpha"] = has_alpha
+            video_format = apply_format_widgets(format_ext, kwargs)
+            dim_alignment = video_format.get("dim_alignment", 2)
+            if (first_image.shape[1] % dim_alignment) or (first_image.shape[0] % dim_alignment):
+                #output frames must be padded
+                to_pad = (-first_image.shape[1] % dim_alignment,
+                          -first_image.shape[0] % dim_alignment)
+                padding = (to_pad[0]//2, to_pad[0] - to_pad[0]//2,
+                           to_pad[1]//2, to_pad[1] - to_pad[1]//2)
+                padfunc = torch.nn.ReplicationPad2d(padding)
+                def pad(image):
+                    image = image.permute((2,0,1))#HWC to CHW
+                    padded = padfunc(image.to(dtype=torch.float32))
+                    return padded.permute((1,2,0))
+                images = map(pad, images)
+                dimensions = (-first_image.shape[1] % dim_alignment + first_image.shape[1],
+                              -first_image.shape[0] % dim_alignment + first_image.shape[0])
+                logger.warn("Output images were not of valid resolution and have had padding applied")
+            else:
+                dimensions = (first_image.shape[1], first_image.shape[0])
+            if pingpong:
+                if meta_batch is not None:
+                    logger.error("pingpong is incompatible with batched output")
+                images = to_pingpong(images)
+                if num_frames > 2:
+                    num_frames += num_frames -2
+                    pbar.total = num_frames
+            if loop_count > 0:
+                loop_args = ["-vf", "loop=loop=" + str(loop_count)+":size=" + str(num_frames)]
+            else:
+                loop_args = []
+            if video_format.get('input_color_depth', '8bit') == '16bit':
+                images = map(tensor_to_shorts, images)
+                if has_alpha:
+                    i_pix_fmt = 'rgba64'
+                else:
+                    i_pix_fmt = 'rgb48'
+            else:
+                images = map(tensor_to_bytes, images)
+                if has_alpha:
+                    i_pix_fmt = 'rgba'
+                else:
+                    i_pix_fmt = 'rgb24'
+            # Check if audio will be added to determine filename
+            has_audio = False
+            if audio is not None:
+                try:
+                    if audio.get('waveform') is not None:
+                        has_audio = True
+                except:
+                    pass
+
+            # If we have audio, create a temp name for the video-only file
+            if has_audio:
+                file = f"{filename}_{counter:05}_temp.{video_format['extension']}"
+            else:
+                if filename_suffix:
+                    file = f"{filename}_{counter:05}_{filename_suffix}.{video_format['extension']}"
+                else:
+                    file = f"{filename}_{counter:05}.{video_format['extension']}"
+            file_path = os.path.join(full_output_folder, file)
+            bitrate_arg = []
+            bitrate = video_format.get('bitrate')
+            if bitrate is not None:
+                bitrate_arg = ["-b:v", str(bitrate) + "M" if video_format.get('megabit') == 'True' else str(bitrate) + "K"]
+            args = [ffmpeg_path, "-v", "error", "-f", "rawvideo", "-pix_fmt", i_pix_fmt,
+                    # The image data is in an undefined generic RGB color space, which in practice means sRGB.
+                    # sRGB has the same primaries and matrix as BT.709, but a different transfer function (gamma),
+                    # called by the sRGB standard name IEC 61966-2-1. However, video hosting platforms like YouTube
+                    # standardize on full BT.709 and will convert the colors accordingly. This last minute change
+                    # in colors can be confusing to users. We can counter it by lying about the transfer function
+                    # on a per format basis, i.e. for video we will lie to FFmpeg that it is already BT.709. Also,
+                    # because the input data is in RGB (not YUV) it is more efficient (fewer scale filter invocations)
+                    # to specify the input color space as RGB and then later, if the format actually wants YUV,
+                    # to convert it to BT.709 YUV via FFmpeg's -vf "scale=out_color_matrix=bt709".
+                    "-color_range", "pc", "-colorspace", "rgb", "-color_primaries", "bt709",
+                    "-color_trc", video_format.get("fake_trc", "iec61966-2-1"),
+                    "-s", f"{dimensions[0]}x{dimensions[1]}", "-r", str(frame_rate), "-i", "-"] \
+                    + loop_args
+
+            images = map(lambda x: x.tobytes(), images)
+            env=os.environ.copy()
+            if  "environment" in video_format:
+                env.update(video_format["environment"])
+
+            if "pre_pass" in video_format:
+                if meta_batch is not None:
+                    #Performing a prepass requires keeping access to all frames.
+                    #Potential solutions include keeping just output frames in
+                    #memory or using 3 passes with intermediate file, but
+                    #very long gifs probably shouldn't be encouraged
+                    raise Exception("Formats which require a pre_pass are incompatible with Batch Manager.")
+                images = [b''.join(images)]
+                os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+                in_args_len = args.index("-i") + 2 # The index after ["-i", "-"]
+                pre_pass_args = args[:in_args_len] + video_format['pre_pass']
+                merge_filter_args(pre_pass_args)
+                try:
+                    subprocess.run(pre_pass_args, input=images[0], env=env,
+                                   capture_output=True, check=True)
+                except subprocess.CalledProcessError as e:
+                    raise Exception("An error occurred in the ffmpeg prepass:\n" \
+                            + e.stderr.decode(*ENCODE_ARGS))
+            if "inputs_main_pass" in video_format:
+                in_args_len = args.index("-i") + 2 # The index after ["-i", "-"]
+                args = args[:in_args_len] + video_format['inputs_main_pass'] + args[in_args_len:]
+
+            if output_process is None:
+                if 'gifski_pass' in video_format:
+                    format = 'image/gif'
+                    output_process = gifski_process(args, dimensions, video_format, file_path, env)
+                    audio = None
+                else:
+                    args += video_format['main_pass'] + bitrate_arg
+                    merge_filter_args(args)
+                    output_process = ffmpeg_process(args, video_format, video_metadata, file_path, env)
+                #Proceed to first yield
+                output_process.send(None)
+                if meta_batch is not None:
+                    meta_batch.outputs[unique_id] = (counter, output_process)
+
+            for image in images:
+                pbar.update(1)
+                output_process.send(image)
+            if meta_batch is not None:
+                requeue_workflow((meta_batch.unique_id, not meta_batch.has_closed_inputs))
+            if meta_batch is None or meta_batch.has_closed_inputs:
+                #Close pipe and wait for termination.
+                try:
+                    total_frames_output = output_process.send(None)
+                    output_process.send(None)
+                except StopIteration:
+                    pass
+                if meta_batch is not None:
+                    meta_batch.outputs.pop(unique_id)
+                    if len(meta_batch.outputs) == 0:
+                        meta_batch.reset()
+            else:
+                #batch is unfinished
+                #TODO: Check if empty output breaks other custom nodes
+                return {"ui": {"unfinished_batch": [True]}, "result": ((save_output, []),)}
+
+            # Re-check audio (we already checked above for filename)
+            a_waveform = None
+            if audio is not None:
+                try:
+                    #safely check if audio produced by VHS_LoadVideo actually exists
+                    a_waveform = audio['waveform']
+                except:
+                    pass
+
+            if a_waveform is not None:
+                # Create audio file if input was provided
+                if filename_suffix:
+                    output_file_with_audio = f"{filename}_{counter:05}_{filename_suffix}.{video_format['extension']}"
+                else:
+                    output_file_with_audio = f"{filename}_{counter:05}.{video_format['extension']}"
+                output_file_with_audio_path = os.path.join(full_output_folder, output_file_with_audio)
+                if "audio_pass" not in video_format:
+                    logger.warn("Selected video format does not have explicit audio support")
+                    video_format["audio_pass"] = ["-c:a", "libopus"]
+
+
+                # FFmpeg command with audio re-encoding
+                #TODO: expose audio quality options if format widgets makes it in
+                #Reconsider forcing apad/shortest
+                channels = audio['waveform'].size(1)
+                min_audio_dur = total_frames_output / frame_rate + 1
+                if video_format.get('trim_to_audio', 'False') != 'False':
+                    apad = []
+                else:
+                    apad = ["-af", "apad=whole_dur="+str(min_audio_dur)]
+                mux_args = [ffmpeg_path, "-v", "error", "-y", "-i", file_path,
+                            "-ar", str(audio['sample_rate']), "-ac", str(channels),
+                            "-f", "f32le", "-i", "-", "-c:v", "copy"] \
+                            + video_format["audio_pass"] \
+                            + apad + ["-shortest", output_file_with_audio_path]
+
+                audio_data = audio['waveform'].squeeze(0).transpose(0,1) \
+                        .numpy().tobytes()
+                merge_filter_args(mux_args, '-af')
+                try:
+                    res = subprocess.run(mux_args, input=audio_data,
+                                         env=env, capture_output=True, check=True)
+                except subprocess.CalledProcessError as e:
+                    raise Exception("An error occured in the ffmpeg subprocess:\n" \
+                            + e.stderr.decode(*ENCODE_ARGS))
+                if res.stderr:
+                    print(res.stderr.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+                output_files.append(output_file_with_audio_path)
+                #Return this file with audio to the webui.
+                #It will be muted unless opened or saved with right click
+                file = output_file_with_audio
+                logger.info(f"📝 File: {output_file_with_audio}")
+                logger.info("✅ Video saved successfully!")
+                # Delete the intermediate video without audio
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+            else:
+                # Only add video without audio if no audio was provided
+                output_files.append(file_path)
+                logger.info(f"📝 File: {file}")
+                logger.info("✅ Video saved successfully!")
+        if extra_options.get('VHS_KeepIntermediate', True) == False:
+            for intermediate in output_files[1:-1]:
+                if os.path.exists(intermediate):
+                    os.remove(intermediate)
+        preview = {
+                "filename": file,
+                "subfolder": subfolder,
+                "type": "output" if save_output else "temp",
+                "format": format,
+                "frame_rate": frame_rate,
+                "fullpath": output_files[-1] if output_files else "",
+            }
+        if num_frames == 1 and 'png' in format and '%03d' in file:
+            preview['format'] = 'image/png'
+            preview['filename'] = file.replace('%03d', '001')
+        return {"ui": {"gifs": [preview]}, "result": ((save_output, output_files),)}
+
+
+NODE_CLASS_MAPPINGS = {
+    "SaveVideoEQX": VideoCombine,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SaveVideoEQX": "Save Video EQX",
+}

standalone_video_combine/utils.py

@@ -0,0 +1,136 @@
+import hashlib
+import os
+from typing import Iterable
+import shutil
+import subprocess
+import re
+import time
+from collections.abc import Mapping
+from typing import Union
+import functools
+import torch
+from torch import Tensor
+
+import server
+from .logger import logger
+import folder_paths
+
+BIGMIN = -(2**53-1)
+BIGMAX = (2**53-1)
+
+DIMMAX = 8192
+
+ENCODE_ARGS = ("utf-8", 'backslashreplace')
+
+def ffmpeg_suitability(path):
+    try:
+        version = subprocess.run([path, "-version"], check=True,
+                                 capture_output=True).stdout.decode(*ENCODE_ARGS)
+    except:
+        return 0
+    score = 0
+    #rough layout of the importance of various features
+    simple_criterion = [("libvpx", 20),("264",10), ("265",3),
+                        ("svtav1",5),("libopus", 1)]
+    for criterion in simple_criterion:
+        if version.find(criterion[0]) >= 0:
+            score += criterion[1]
+    #obtain rough compile year from copyright information
+    copyright_index = version.find('2000-2')
+    if copyright_index >= 0:
+        copyright_year = version[copyright_index+6:copyright_index+9]
+        if copyright_year.isnumeric():
+            score += int(copyright_year)
+    return score
+
+class MultiInput(str):
+    def __new__(cls, string, allowed_types="*"):
+        res = super().__new__(cls, string)
+        res.allowed_types=allowed_types
+        return res
+    def __ne__(self, other):
+        if self.allowed_types == "*" or other == "*":
+            return False
+        return other not in self.allowed_types
+imageOrLatent = MultiInput("IMAGE", ["IMAGE", "LATENT"])
+floatOrInt = MultiInput("FLOAT", ["FLOAT", "INT"])
+
+class ContainsAll(dict):
+    def __contains__(self, other):
+        return True
+    def __getitem__(self, key):
+        return super().get(key, (None, {}))
+
+if "VHS_FORCE_FFMPEG_PATH" in os.environ:
+    ffmpeg_path = os.environ.get("VHS_FORCE_FFMPEG_PATH")
+else:
+    ffmpeg_paths = []
+    try:
+        from imageio_ffmpeg import get_ffmpeg_exe
+        imageio_ffmpeg_path = get_ffmpeg_exe()
+        ffmpeg_paths.append(imageio_ffmpeg_path)
+    except:
+        if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+            raise
+        logger.warn("Failed to import imageio_ffmpeg")
+    if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+        ffmpeg_path = imageio_ffmpeg_path
+    else:
+        system_ffmpeg = shutil.which("ffmpeg")
+        if system_ffmpeg is not None:
+            ffmpeg_paths.append(system_ffmpeg)
+        if os.path.isfile("ffmpeg"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg"))
+        if os.path.isfile("ffmpeg.exe"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg.exe"))
+        if len(ffmpeg_paths) == 0:
+            logger.error("No valid ffmpeg found.")
+            ffmpeg_path = None
+        elif len(ffmpeg_paths) == 1:
+            #Evaluation of suitability isn't required, can take sole option
+            #to reduce startup time
+            ffmpeg_path = ffmpeg_paths[0]
+        else:
+            ffmpeg_path = max(ffmpeg_paths, key=ffmpeg_suitability)
+gifski_path = os.environ.get("VHS_GIFSKI", None)
+if gifski_path is None:
+    gifski_path = os.environ.get("JOV_GIFSKI", None)
+    if gifski_path is None:
+        gifski_path = shutil.which("gifski")
+
+def merge_filter_args(args, ftype="-vf"):
+    #TODO This doesn't account for filter_complex
+    #Will likely need to convert all filters to filter complex in the future
+    #But that requires source/output deduplication
+    try:
+        start_index = args.index(ftype)+1
+        index = start_index
+        while True:
+            index = args.index(ftype, index)
+            args[start_index] += ',' + args[index+1]
+            args.pop(index)
+            args.pop(index)
+    except ValueError:
+        pass
+
+def cached(duration):
+    def dec(f):
+        cached_ret = None
+        cache_time = 0
+        def cached_func():
+            nonlocal cache_time, cached_ret
+            if time.time() > cache_time + duration or cached_ret is None:
+                cache_time = time.time()
+                cached_ret = f()
+            return cached_ret
+        return cached_func
+    return dec
+
+# Stub for requeue_workflow - not needed in standalone
+prompt_queue = server.PromptServer.instance.prompt_queue
+requeue_guard = [None, 0, 0, {}]
+
+def requeue_workflow(requeue_required=(-1,True)):
+    """Minimal implementation for standalone - just returns without doing anything"""
+    # In standalone mode, we don't need batch manager support
+    return

standalone_video_combine/video_formats/16bit-png.json

@@ -0,0 +1,9 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-pix_fmt", "rgba64"
+    ],
+    "input_color_depth": "16bit",
+    "extension": "%03d.png"
+}

standalone_video_combine/video_formats/8bit-png.json

@@ -0,0 +1,7 @@
+{
+    "main_pass":
+    [
+        "-n"
+    ],
+    "extension": "%03d.png"
+}

standalone_video_combine/video_formats/ProRes.json

@@ -0,0 +1,22 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "prores_ks",
+        "-profile:v", [["$profile"]],
+        ["profile", {
+            "lt": [[]], "1": [[]], "standard": [[]], "2": [[]], "hq": [[]], "3": [[]],
+            "4": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}],
+            "4444": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}],
+            "4444xq": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}]
+        }],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "pcm_s16le"],
+    "extension": "mov",
+    "extra_widgets": [["profile", ["lt", "standard", "hq", "4444", "4444xq"], {"default": "hq"}]]
+}

standalone_video_combine/video_formats/av1-webm.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libsvtav1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p10le", "yuv420p"]],
+        "-crf", ["crf","INT", {"default": 23, "min": 0, "max": 100, "step": 1}],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "libopus"],
+    "input_color_depth": ["input_color_depth", ["8bit", "16bit"]],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "webm",
+    "environment": {"SVT_LOG": "1"}
+}

standalone_video_combine/video_formats/ffmpeg-gif.json

@@ -0,0 +1,8 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-filter_complex", ["dither", ["bayer", "heckbert", "floyd_steinberg", "sierra2", "sierra2_4a", "sierra3", "burkes", "atkinson", "none"], {"default": "sierra2_4a"}, "[0:v] split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse=dither=$val"]
+    ],
+    "extension": "gif"
+}

standalone_video_combine/video_formats/ffv1-mkv.json

@@ -0,0 +1,17 @@
+{
+    "main_pass": [
+        "-n",
+        "-c:v", "ffv1",
+        "-level", ["level", ["0", "1", "3"], {"default": "3"}],
+        "-coder", ["coder", ["0", "1", "2"], {"default": "1"}],
+        "-context", ["context", ["0", "1"], {"default": "1"}],
+        "-g", ["gop_size", "INT", {"default": 1, "min": 1, "max": 300, "step": 1}],
+        "-slices", ["slices", ["4", "6", "9", "12", "16", "20", "24", "30"], {"default": "16"}],
+        "-slicecrc", ["slicecrc", ["0", "1"], {"default": "1"}],
+        "-pix_fmt", ["pix_fmt", ["bgra", "rgba64le", "yuv420p", "yuv422p", "yuv444p", "yuva420p", "yuva422p", "yuva444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuv420p12le", "yuv422p12le", "yuv444p12le", "yuv420p14le", "yuv422p14le", "yuv444p14le", "yuv420p16le", "yuv422p16le", "yuv444p16le", "gray", "gray10le", "gray12le", "gray16le"], {"default": "bgra"}]
+    ],
+    "audio_pass": ["-c:a", "flac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "mkv"
+}

standalone_video_combine/video_formats/gifski.json

@@ -0,0 +1,12 @@
+{
+    "main_pass":
+    [
+        "-pix_fmt", "yuv444p",
+        "-vf", "scale=out_color_matrix=bt709:out_range=pc",
+        "-color_range", "pc"
+    ],
+    "extension": "gif",
+    "gifski_pass": [
+        "-Q", ["quality","INT", {"default": 90, "min": 1, "max": 100, "step": 1}]
+    ]
+}

standalone_video_combine/video_formats/h264-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libx264",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "yuv420p10le"]],
+        "-crf", ["crf","INT", {"default": 19, "min": 0, "max": 100, "step": 1}],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "mp4"
+}

standalone_video_combine/video_formats/h265-mp4.json

@@ -0,0 +1,17 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libx265",
+        "-vtag", "hvc1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p10le", "yuv420p"]],
+        "-crf", ["crf","INT", {"default": 22, "min": 0, "max": 100, "step": 1}],
+        "-preset", "medium",
+        "-x265-params", "log-level=quiet",
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

standalone_video_combine/video_formats/nvenc_av1-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "av1_nvenc",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

standalone_video_combine/video_formats/nvenc_h264-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "h264_nvenc",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

standalone_video_combine/video_formats/nvenc_hevc-mp4.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "hevc_nvenc",
+        "-vtag", "hvc1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

standalone_video_combine/video_formats/webm.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-pix_fmt", ["pix_fmt",["yuv420p","yuva420p"]],
+        "-crf", ["crf","INT", {"default": 20, "min": 0, "max": 100, "step": 1}],
+        "-b:v", "0",
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "libvorbis"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "webm"
+}