vs-colorfix 2.1.0__py3-none-any.whl

vs_colorfix/__init__.py

@@ -0,0 +1,2 @@
+from .wavelet_color_fix import wavelet_color_fix as wavelet
+from .average_color_fix import average_color_fix as average

vs_colorfix/average_color_fix.py

@@ -0,0 +1,146 @@
+
+# Script by pifroggi https://github.com/pifroggi/vs_colorfix
+# or tepete and pifroggi on Discord
+
+# Average Color Fix idea from chaiNNer https://github.com/chaiNNer-org/chaiNNer
+
+import vapoursynth as vs
+import warnings
+
+core = vs.core
+
+
+def _expression(clips, expr, format=None):
+    # optional plugin for slight speed boost
+    if hasattr(core, "akarin"):
+        return core.akarin.Expr(clips, expr, format=format)
+    else:
+        return core.std.Expr(clips, expr, format=format)
+
+
+def _box_blur(clip, planes=None, hradius=1, hpasses=1, vradius=1, vpasses=1):
+    # optional plugin for slight speed boost
+    if hasattr(core, "vszip"):
+        return core.vszip.BoxBlur(clip, planes=planes, hradius=hradius, hpasses=hpasses, vradius=vradius, vpasses=vpasses)
+    else:
+        return core.std.BoxBlur(clip, planes=planes, hradius=hradius, hpasses=hpasses, vradius=vradius, vpasses=vpasses)
+
+
+def _make_diff(clipa, clipb, planes=None):
+    # makes makediff work on 16-bit float
+    if clipa.format.sample_type == vs.FLOAT and clipa.format.bits_per_sample == 16 and vs.__version__.release_major < 78:
+        return _expression([clipa, clipb], expr=["x y -" if i in planes else "" for i in range(clipa.format.num_planes)])
+    else:
+        return core.std.MakeDiff(clipa, clipb, planes=planes)
+
+
+def _merge_diff(clipa, clipb, planes=None):
+    # makes mergediff work on 16-bit float
+    if clipa.format.sample_type == vs.FLOAT and clipa.format.bits_per_sample == 16 and vs.__version__.release_major < 78:
+        return _expression([clipa, clipb], expr=["x y +" if i in planes else "" for i in range(clipa.format.num_planes)])
+    else:
+        return core.std.MergeDiff(clipa, clipb, planes=planes)
+
+
+def average_color_fix(clip, ref, radius=10, planes=None, fast=False):
+    """Fixes color shift based on a reference clip. A very fast way to transfer the colors from one clip to another. For large color differences, `wavelet()` is more accurate.
+
+    Args:
+        clip: Clip where the color fix will be applied to.
+        ref: Reference clip where the colors are taken from. Should match the base clip somewhat. Compression, grain, or lower resolution are all okay.
+        radius: Higher means a more global color match and wider bloom/bleed. Lower means a more local color match and smaller bloom/bleed. 
+            Too low and the reference clip will become visible. Test values 5 and 30 and this will become more clear.
+        planes: Which planes to color fix. Any unmentioned planes will simply be copied. None means all planes will be color fixed.
+        fast: Does the averaging via a downscale instead of a blur, which is much faster, but will produce faint blocky artifacts. 
+            I found it useful for radius > 60 where artifacts are often no longer noticable, or to fix something like a prefilter clip.
+    """
+    
+    if not isinstance(clip, vs.VideoNode):
+        raise TypeError("vs_colorfix.average: Clip must be a vapoursynth clip.")
+    if not isinstance(ref, vs.VideoNode):
+        raise TypeError("vs_colorfix.average: Ref must be a vapoursynth clip.")
+    if clip.format.id == vs.PresetVideoFormat.NONE or clip.width == 0 or clip.height == 0:
+        raise TypeError("vs_colorfix.average: Clip must have constant format and dimensions.")
+    if ref.format.id  == vs.PresetVideoFormat.NONE or  ref.width == 0 or  ref.height == 0:
+        raise TypeError("vs_colorfix.average: Ref must have constant format and dimensions.")
+    if clip.format.sample_type == vs.FLOAT and clip.format.bits_per_sample == 16 and vs.__version__.release_major < 78 and not hasattr(core, "vszip"):
+        raise ValueError("vs_colorfix.average: 16-bit float formats require vapoursynth version 78 or newer, or the plugin 'vszip' version 15.0.0 or newer.")
+    if clip.format.id != ref.format.id:
+        raise ValueError("vs_colorfix.average: Clip and ref must have the same format. 16-bit input is recommended to avoid banding.")
+    if not isinstance(fast, bool):
+        raise TypeError("vs_colorfix.average: Fast must be either True or False.")
+    if not isinstance(radius, int) or isinstance(radius, bool):
+        raise TypeError("vs_colorfix.average: Radius must be an integer.")
+    if not fast and not (1 <= radius <= 10000):
+        raise ValueError("vs_colorfix.average: Radius must be in the range 1-10000.")
+    fast_max_radius = (min(clip.width, clip.height) - 1) // 2
+    if fast and not (1 <= radius <= fast_max_radius):
+        raise ValueError(f"vs_colorfix.average: Radius must be between 1 and {fast_max_radius} for the current input dimensions when fast=True.")
+    if clip.format.bits_per_sample <= 8 or ref.format.bits_per_sample <= 8:
+        warnings.warn("vs_colorfix.average: Input clips have a low bit depth, which will cause banding. 16-bit input is recommended.", UserWarning, stacklevel=2)
+    
+    num_planes = clip.format.num_planes
+    if planes is None:
+        planes = list(range(num_planes))
+    if isinstance(planes, int):
+        planes = [planes]
+    if num_planes == 1:
+        planes = [0]
+    planes = set(planes)
+    if not planes <= set(range(num_planes)):
+        raise ValueError("vs_colorfix.average: Invalid plane index specified.")
+
+    # downscale both clips, calculate difference (faster but faint blocky artifacts)
+    if fast:
+        radius = radius * 2 + 1
+        processed_clips = [None] * num_planes
+        if 0 in planes:
+            clip_plane = core.std.ShufflePlanes(clip, planes=0, colorfamily=vs.GRAY)
+            ref_plane = core.std.ShufflePlanes(ref, planes=0, colorfamily=vs.GRAY)
+            downscaled_clip_plane = core.resize.Bilinear(clip_plane, width=clip.width // radius, height=clip.height // radius)
+            downscaled_ref_plane = core.resize.Bilinear(ref_plane, width=clip.width // radius, height=clip.height // radius)
+            diff_plane = _make_diff(downscaled_ref_plane, downscaled_clip_plane, planes=[0])
+            processed_clips[0] = core.resize.Bilinear(diff_plane, width=clip.width, height=clip.height)
+        else:
+            processed_clips[0] = core.std.ShufflePlanes(clip, planes=0, colorfamily=vs.GRAY)
+        if 1 in planes:
+            clip_plane = core.std.ShufflePlanes(clip, planes=1, colorfamily=vs.GRAY)
+            ref_plane = core.std.ShufflePlanes(ref, planes=1, colorfamily=vs.GRAY)
+            downscaled_clip_plane = core.resize.Bilinear(clip_plane, width=clip.width // radius, height=clip.height // radius)
+            downscaled_ref_plane = core.resize.Bilinear(ref_plane, width=clip.width // radius, height=clip.height // radius)
+            diff_plane = _make_diff(downscaled_ref_plane, downscaled_clip_plane, planes=[0])
+            processed_clips[1] = core.resize.Bilinear(diff_plane, width=clip_plane.width, height=clip_plane.height)
+        elif num_planes > 1:
+            processed_clips[1] = core.std.ShufflePlanes(clip, planes=1, colorfamily=vs.GRAY)
+        if 2 in planes:
+            clip_plane = core.std.ShufflePlanes(clip, planes=2, colorfamily=vs.GRAY)
+            ref_plane = core.std.ShufflePlanes(ref, planes=2, colorfamily=vs.GRAY)
+            downscaled_clip_plane = core.resize.Bilinear(clip_plane, width=clip.width // radius, height=clip.height // radius)
+            downscaled_ref_plane = core.resize.Bilinear(ref_plane, width=clip.width // radius, height=clip.height // radius)
+            diff_plane = _make_diff(downscaled_ref_plane, downscaled_clip_plane, planes=[0])
+            processed_clips[2] = core.resize.Bilinear(diff_plane, width=clip_plane.width, height=clip_plane.height)
+        elif num_planes > 2:
+            processed_clips[2] = core.std.ShufflePlanes(clip, planes=2, colorfamily=vs.GRAY)
+        diff_clip = core.std.ShufflePlanes(clips=processed_clips, planes=[0] * num_planes, colorfamily=clip.format.color_family)
+
+    # blur both clips, calculate difference (better quality but slower)
+    else:
+        if ref.width != clip.width or ref.height != clip.height:
+            ref = core.resize.Bilinear(ref, width=clip.width, height=clip.height)
+        chroma_hradius = radius // (1 << clip.format.subsampling_w) if clip.format.subsampling_w else radius
+        chroma_vradius = radius // (1 << clip.format.subsampling_h) if clip.format.subsampling_h else radius
+        blurred_clip = clip
+        blurred_ref = ref
+        if 0 in planes:
+            blurred_clip = _box_blur(blurred_clip, hradius=radius, hpasses=4, vradius=radius, vpasses=4, planes=[0])
+            blurred_ref = _box_blur(blurred_ref, hradius=radius, hpasses=4, vradius=radius, vpasses=4, planes=[0])
+        if 1 in planes:
+            blurred_clip = _box_blur(blurred_clip, hradius=chroma_hradius, hpasses=4, vradius=chroma_vradius, vpasses=4, planes=[1])
+            blurred_ref = _box_blur(blurred_ref, hradius=chroma_hradius, hpasses=4, vradius=chroma_vradius, vpasses=4, planes=[1])
+        if 2 in planes:
+            blurred_clip = _box_blur(blurred_clip, hradius=chroma_hradius, hpasses=4, vradius=chroma_vradius, vpasses=4, planes=[2])
+            blurred_ref = _box_blur(blurred_ref, hradius=chroma_hradius, hpasses=4, vradius=chroma_vradius, vpasses=4, planes=[2])
+        diff_clip = _make_diff(blurred_ref, blurred_clip, planes=planes)
+
+    # add difference to the original
+    return _merge_diff(clip, diff_clip, planes=planes)

vs_colorfix/wavelet_color_fix.py

@@ -0,0 +1,466 @@
+
+# Script by pifroggi https://github.com/pifroggi/vs_colorfix
+# or tepete and pifroggi on Discord
+
+# Wavelet Color Fix idea from sd-webui-stablesr https://github.com/pkuliyi2015/sd-webui-stablesr/blob/master/srmodule/colorfix.py
+
+import os
+import re
+import sys
+import shutil
+import logging
+import warnings
+import subprocess
+import vapoursynth as vs
+from pathlib import Path
+from .average_color_fix import _expression
+
+core = vs.core
+
+
+def _plane_wavelets(clip_format, wavelets):
+    # compensate wavelet count for subsampled planes
+    plane_wavelets = [wavelets] * clip_format.num_planes
+    
+    if clip_format.color_family == vs.YUV and clip_format.num_planes > 1:
+        subsampling_shift = max(clip_format.subsampling_w, clip_format.subsampling_h)
+        if subsampling_shift > 0:
+            chroma_wavelets = max(1, wavelets - subsampling_shift)
+            for p in range(1, clip_format.num_planes):
+                plane_wavelets[p] = chroma_wavelets
+    
+    return plane_wavelets
+
+
+def _inference_groups(clips, planes, plane_wavelets):
+    # group planes by wavelet count and size so interleaved inference only combines compatible planes
+    groups = {}
+    for p in sorted(planes):
+        plane_clip = clips[p]
+        key = (plane_wavelets[p], plane_clip.width, plane_clip.height)
+        if key not in groups:
+            groups[key] = []
+        groups[key].append(p)
+    
+    return [(key[0], grouped_planes) for key, grouped_planes in groups.items()]
+
+
+def _get_builder(plugin_path, trt_version, cuda_major):
+    # finds compatible tensorrt engine builders
+    exe_name = "trtexec.exe" if os.name == "nt" else "trtexec"
+    builders = []
+    errors   = []
+    
+    # check for python tensorrt
+    try:
+        import tensorrt
+        package_version = list(map(int, tensorrt.__version__.split(".")[:3]))
+        if package_version == trt_version:
+            builders.append(["python", tensorrt])
+        else:
+            errors.append(f"Python TensorRT: Wrong version {'.'.join(map(str, package_version))}")
+    except ImportError:
+        errors.append("Python TensorRT: Not found.")
+    except Exception:
+        errors.append("Python TensorRT: Found but failed to check version.")
+    
+    # check for bundled trtexec
+    bundled_trtexec = Path(plugin_path) / "vsmlrt-cuda" / exe_name
+    if bundled_trtexec.is_file() and os.access(str(bundled_trtexec), os.X_OK):
+        builders.append(["trtexec", bundled_trtexec])
+    else:
+        errors.append(f"Bundled trtexec: Not found.")
+
+    # check for system trtexec
+    system_trtexec = shutil.which("trtexec")
+    if system_trtexec is not None:
+        try:
+            trtexec_path = Path(system_trtexec)
+            help_output  = subprocess.run([str(trtexec_path), "--help"], check=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="locale", errors="replace")
+            help_output  = f"{help_output.stdout}\n{help_output.stderr}"
+            
+            trtexec_version = None
+            trtexec_version = re.search(r"\[TensorRT v(\d+)\]", help_output)
+            if trtexec_version is None:
+                raise RuntimeError("vs_colorfix.wavelet: Internal Error: Regex failed to find the version.")
+
+            trtexec_version = int(trtexec_version.group(1))
+            trtexec_version = [trtexec_version // 10000, (trtexec_version % 10000) // 100, trtexec_version % 100]
+            if trtexec_version == trt_version:
+                builders.append(["trtexec", trtexec_path])
+            else:
+                errors.append(f"System trtexec: Wrong version {'.'.join(map(str, trtexec_version))}")
+        except Exception:
+            errors.append("System trtexec: Found but failed to check version.")
+    else:
+        errors.append("System trtexec: Not found.")
+    
+    # return first compatible builder
+    if builders:
+        return builders[0]
+    
+    errors = "\n".join(f"{builder}" for builder in errors)
+    raise FileNotFoundError(f"vs_colorfix.wavelet: No compatible TensorRT engine builder found. Please install the python packages 'tensorrt', or install trtexec. The required TensorRT version is {'.'.join(map(str, trt_version))}. The required CUDA version is {cuda_major}.\n{errors}")
+
+
+def _build_engine_trtexec(onnx_path, engine_path, engine_w, engine_h, num_planes, gpu_id, precision, trt_version, trtexec_path):
+    # build engine using trtexec, supports trt 10 and 11
+
+    # settings
+    opt_shapes = f"input:1x{num_planes*2}x{engine_h}x{engine_w}"
+    io_formats = f"fp{precision}:chw" if trt_version[0] < 11 else "chw"
+    cmd = [
+        str(trtexec_path),
+        *(["--stronglyTyped"] if trt_version[0] < 11 else []),
+        "--skipInference",
+        "--memPoolSize=workspace:4096",
+        "--builderOptimizationLevel=5",
+        "--tilingOptimizationLevel=3",
+        f"--inputIOFormats={io_formats}",
+        f"--outputIOFormats={io_formats}",
+        f"--onnx={onnx_path}",
+        f"--saveEngine={engine_path}",
+        f"--optShapes={opt_shapes}",
+        f"--device={gpu_id}",
+    ]
+
+    # build
+    try:
+        result = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="locale", errors="replace")
+    except subprocess.CalledProcessError as e:
+        msg = (
+            "vs_colorfix.wavelet: Internal Error: trtexec failed while building the TensorRT engine.\n"
+            f"  Command: {' '.join(cmd)}\n"
+            f"  Return code: {e.returncode}\n"
+        )
+        if e.stdout:
+            msg += f"\n=== trtexec stdout ===\n{e.stdout}"
+        if e.stderr:
+            msg += f"\n=== trtexec stderr ===\n{e.stderr}"
+        raise RuntimeError(msg) from e
+
+
+def _build_engine_python(onnx_path, engine_path, engine_w, engine_h, num_planes, gpu_id, trt_package):
+    # build engine using tensorrt python package, supports only trt 11 because of vapoursynth-mlrt-trt
+    from cuda.core import Device
+    trt = trt_package
+
+    # custom logger for errors
+    class _TrtLogger(trt.ILogger):
+        def __init__(self):
+            trt.ILogger.__init__(self)
+            self.messages = []
+            self.fatal    = False
+        def log(self, severity, msg):
+            if severity <= trt.Logger.WARNING:
+                self.messages.append((severity, msg))
+                if self.fatal:
+                    logging.critical(f"  [{severity}] {msg}")
+                elif severity == trt.Logger.INTERNAL_ERROR:  # print fatal errors immediately because python may not get control back
+                    self.fatal = True
+                    log = "\n".join(f"  [{log_severity}] {log_msg}" for log_severity, log_msg in self.messages)
+                    logging.critical(f"vs_colorfix.wavelet: Internal Error: TensorRT failed while building the TensorRT engine.\n=== TensorRT log ===\n{log}")
+        def get_log(self):
+            return "\n".join(f"  [{severity}] {msg}" for severity, msg in self.messages)
+
+    # initialize trt and load model
+    cur_id = Device().device_id
+    try:
+        Device(gpu_id).set_current()
+        logger  = _TrtLogger()
+        builder = trt.Builder(logger)
+        network = builder.create_network()
+        config  = builder.create_builder_config()
+        parser  = trt.OnnxParser(network, logger)
+        if not parser.parse_from_file(str(onnx_path)):
+            errors = "\n".join(f"  {parser.get_error(i)}" for i in range(parser.num_errors))
+            raise RuntimeError(f"vs_colorfix.wavelet: Internal Error: TensorRT failed while parsing the ONNX model.\n{errors}")
+
+        # settings
+        opt_shapes = (1, num_planes * 2, engine_h, engine_w)                                                              # optShapes
+        network.get_input(0).allowed_formats = network.get_output(0).allowed_formats = 1 << int(trt.TensorFormat.LINEAR)  # IOFormats:chw
+        config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 4096 << 20)                                            # workspace
+        config.builder_optimization_level = 5                                                                             # builderOptimizationLevel=5
+        config.tiling_optimization_level  = trt.TilingOptimizationLevel.FULL                                              # tilingOptimizationLevel=3
+
+        # build
+        profile = builder.create_optimization_profile()
+        profile.set_shape(network.get_input(0).name, opt_shapes, opt_shapes, opt_shapes)
+        config.add_optimization_profile(profile)
+        engine  = builder.build_serialized_network(network, config)
+    finally:
+        Device(cur_id).set_current()
+        
+    if engine is None:
+        log = logger.get_log()
+        msg = "vs_colorfix.wavelet: Internal Error: TensorRT failed while building the TensorRT engine."
+        if log:
+            msg += f"\n=== TensorRT log ===\n{log}"
+        raise RuntimeError(msg)
+    
+    # save engine
+    with open(engine_path, "wb") as f:
+        f.write(engine)
+
+
+def _get_engine(onnx_path, engine_dir, engine_w, engine_h, num_planes, precision, gpu_id=0, force_rebuild=False) -> str:
+    # get path to tensorrt engine
+    os.makedirs(engine_dir, exist_ok=True)  # create engine folder if needed
+    model_name  = Path(onnx_path).stem
+    engine_name = f"{model_name}_h{engine_h}_w{engine_w}_gpu{gpu_id}.engine"
+    engine_path = os.path.join(engine_dir, engine_name)
+    
+    # check plugin version
+    try:
+        info = core.trt.Version()
+    except Exception as e:
+        raise RuntimeError("vs_colorfix.wavelet: TensorRT backend not installed. Please install the TensorRT dependencies with:\n'pip install -U vs_colorfix[tensorrt] --extra-index-url https://pypi.nvidia.com/'\nOr choose a different backend.") from e
+    
+    # if engine file exist, return it
+    if not force_rebuild and os.path.isfile(engine_path) and os.path.getsize(engine_path) >= 512:
+        return engine_path
+    
+    # get plugin info
+    plugin_path = os.path.dirname(info["path"].decode(errors="ignore"))
+    trt_version = int(info["tensorrt_version"].decode(errors="ignore"))
+    trt_version = [trt_version // 10000, (trt_version % 10000) // 100, trt_version % 100]
+    cuda_major  = int(info["cuda_runtime_version"].decode(errors="ignore")) // 1000
+    
+    # build new engine
+    logging.warning("vs_colorfix.wavelet: Building new TensorRT engine for width=%d, height=%d and precision=fp%d. This may take a few minutes.", engine_w, engine_h, precision)    
+    builder_info = _get_builder(plugin_path=plugin_path, trt_version=trt_version, cuda_major=cuda_major)
+    if builder_info[0] == "python":
+        _build_engine_python(onnx_path=onnx_path, engine_path=engine_path, engine_w=engine_w, engine_h=engine_h, num_planes=num_planes, gpu_id=gpu_id, trt_package=builder_info[1])
+    elif builder_info[0] == "trtexec":
+        _build_engine_trtexec(onnx_path=onnx_path, engine_path=engine_path, engine_w=engine_w, engine_h=engine_h, num_planes=num_planes, gpu_id=gpu_id, precision=precision, trt_version=trt_version, trtexec_path=builder_info[1])
+    else:
+        raise RuntimeError(f"vs_colorfix.wavelet: Internal Error: Unknown TensorRT engine builder: {builder_info[0]}")
+    logging.warning("vs_colorfix.wavelet: Engine building complete.")
+    return engine_path
+
+
+def _tensorrt_inference(input_clips, onnx_path, engine_dir, clip_w, clip_h, num_planes, precision, num_streams=1, gpu_id=0, force_rebuild=False):
+    engine_path = _get_engine(onnx_path=onnx_path, engine_dir=engine_dir, engine_w=clip_w, engine_h=clip_h, num_planes=num_planes, precision=precision, gpu_id=gpu_id, force_rebuild=force_rebuild)
+    model_args  = dict(engine_path=engine_path, num_streams=num_streams, device_id=gpu_id)
+    
+    # try inference, rebuild engine if it fails
+    try:
+        out = core.trt.Model(input_clips, **model_args)
+    except vs.Error as e:
+        err_msg = str(e).lower()
+        serialization_keywords = ("serialize", "serialization", "deserialize", "deserialization")
+        if any(k in err_msg for k in serialization_keywords) and not force_rebuild:
+            logging.warning("vs_colorfix.wavelet: Engine loading failed. This may be due to a TensorRT or driver update. Rebuilding...")
+            model_args["engine_path"] = _get_engine(onnx_path=onnx_path, engine_dir=engine_dir, engine_w=clip_w, engine_h=clip_h, num_planes=num_planes, precision=precision, gpu_id=gpu_id, force_rebuild=True)
+            out = core.trt.Model(input_clips, **model_args)
+        else:
+            raise
+    return out
+
+
+def _vsmlrt_inference(clips, refs, wavelets, backend="ncnn", num_streams=1, gpu_id=0, engine_folder=None):
+    # choose model and vsmlrt backend, then inference
+    
+    base_clip     = clips[0]
+    clip_w        = base_clip.width
+    clip_h        = base_clip.height
+    num_planes    = base_clip.format.num_planes
+    precision     = 32 if backend in ["ncnn"] else base_clip.format.bits_per_sample  # ncnn backend needs fp32 onnx, will be converted to fp16 internally
+    force_rebuild = False
+    current_dir   = os.path.dirname(os.path.abspath(__file__))
+    model_file    = f"waveletcolorfix_w{wavelets}_c{num_planes}_fp{precision}.onnx"
+    onnx_path     = os.path.join(current_dir, "models", model_file)
+    engine_dir    = os.path.join(current_dir, "engines") if engine_folder is None else os.path.abspath(engine_folder)
+
+    # interleave all input clips
+    input_clips = [core.std.Interleave(clips), core.std.Interleave(refs)] if len(clips) > 1 else [clips[0], refs[0]]
+    
+    # inference
+    if backend in ["tensorrt", "trt"]:
+        out = _tensorrt_inference(input_clips, onnx_path=onnx_path, engine_dir=engine_dir, clip_w=clip_w, clip_h=clip_h, num_planes=num_planes, precision=precision, num_streams=num_streams, gpu_id=gpu_id, force_rebuild=force_rebuild)
+    elif backend in ["directml", "dml"]:
+        out = core.ort.Model(input_clips, network_path=onnx_path, provider="DML", device_id=gpu_id, num_streams=num_streams)
+    elif backend in ["ncnn"]:
+        out = core.ncnn.Model(input_clips, network_path=onnx_path, fp16=base_clip.format.bits_per_sample == 16, output_format=1 if base_clip.format.bits_per_sample == 16 else 0, device_id=gpu_id, num_streams=num_streams)  # fp16=true/output_format=1 to allow fp16 input/output
+    else:
+        raise ValueError("vs_colorfix.wavelet: Backend must be CPU, NCNN, DirectML, or TensorRT.")
+    
+    # vsmlrt outputs yuv as rgb, recombine as yuv if input was yuv
+    if base_clip.format.color_family == vs.YUV and out.format.color_family != vs.YUV:
+        out = core.std.ShufflePlanes(out, planes=[0, 1, 2], colorfamily=base_clip.format.color_family, prop_src=base_clip)
+    
+    # separate clips and return
+    return [core.std.SelectEvery(out, cycle=len(clips), offsets=i) for i in range(len(clips))] if len(clips) > 1 else [out]
+
+
+def _wavelet_color_fix_vsmlrt(clip, ref, wavelets, planes, backend="ncnn", num_streams=1, gpu_id=0, engine_folder=None):
+    # gpu backends using vsmlrt
+    
+    if not isinstance(num_streams, int) or isinstance(num_streams, bool):
+        raise TypeError("vs_colorfix.wavelet: Number of parallel GPU streams (num_streams) must be an integer.")
+    if num_streams < 1:
+        raise ValueError("vs_colorfix.wavelet: Number of parallel GPU streams (num_streams) must be at least 1.")
+    if clip.format.sample_type != vs.FLOAT:
+        raise ValueError("vs_colorfix.wavelet: Input clips must be in float format when using a GPU backend. Use 16-bit float for best performance, if supported by your GPU. Most modern GPUs do.")
+    
+    clip_format    = clip.format
+    num_planes     = clip.format.num_planes
+    plane_wavelets = _plane_wavelets(clip_format, wavelets)
+    
+    # if all planes can use the same model and size, inference as one
+    if planes == set(range(num_planes)) and clip_format.subsampling_w == 0 and clip_format.subsampling_h == 0 and len(set(plane_wavelets)) == 1:
+        return _vsmlrt_inference([clip], [ref], wavelets=plane_wavelets[0], backend=backend, num_streams=num_streams, gpu_id=gpu_id, engine_folder=engine_folder)[0]
+    
+    # else inference selected planes separately, interleaved when possible
+    clips = list(core.std.SplitPlanes(clip))
+    refs  = list(core.std.SplitPlanes(ref))
+    
+    for effective_wavelets, selected_planes in _inference_groups(clips, planes, plane_wavelets):
+        selected_out = _vsmlrt_inference([clips[p] for p in selected_planes], [refs[p] for p in selected_planes], wavelets=effective_wavelets, backend=backend, num_streams=num_streams, gpu_id=gpu_id, engine_folder=engine_folder)
+        for p, processed in zip(selected_planes, selected_out):
+            clips[p] = processed
+    
+    return core.std.ShufflePlanes(clips, [0] * num_planes, clip_format.color_family)
+
+
+def _wavelet_color_fix_atwt(clip, ref, wavelets, planes):
+    # cpu backend using the vapoursynth-atwt plugin
+    
+    if clip.format.sample_type == vs.FLOAT and clip.format.bits_per_sample == 16:
+        raise ValueError("vs_colorfix.wavelet: The CPU backend does not support 16-bit float formats. Consider using a GPU backend, or change formats.")
+    
+    clip_format    = clip.format
+    num_planes     = clip.format.num_planes
+    plane_wavelets = _plane_wavelets(clip_format, wavelets)
+    
+    def _decompose(base, wavelet_count):
+        details = []
+        for radius in range(1, wavelet_count + 1):
+            detail = core.atwt.ExtractFrequency(base, radius=radius)
+            base = core.std.MakeDiff(base, detail)
+            details.append(detail)
+        return details + [base]
+    
+    def _recombine(layers):
+        out = layers[-1]
+        for detail in reversed(layers[:-1]):
+            out = core.atwt.ReplaceFrequency(base=out, detail=detail)
+        return out
+    
+    def _fix_clip(clip, ref, wavelet_count):
+        c_layers = _decompose(clip, wavelet_count)
+        r_layers = _decompose(ref, wavelet_count)
+        return _recombine(c_layers[:-1] + [r_layers[-1]])
+    
+    # process the whole clip at once if possible
+    if planes == set(range(num_planes)) and clip_format.subsampling_w == 0 and clip_format.subsampling_h == 0 and len(set(plane_wavelets)) == 1:
+        return _fix_clip(clip, ref, plane_wavelets[0])
+    
+    # else each plane separately
+    clips = list(core.std.SplitPlanes(clip))
+    refs  = list(core.std.SplitPlanes(ref))
+    
+    for p in sorted(planes):
+        clips[p] = _fix_clip(clips[p], refs[p], plane_wavelets[p])
+    
+    return core.std.ShufflePlanes(clips, [0] * num_planes, clip_format.color_family)
+
+
+def wavelet_color_fix(clip, ref, wavelets=4, planes=None, backend="ncnn", num_streams=2, gpu_id=0, engine_folder=None):
+    """Fixes color shift based on a reference clip. Works similarly to `average()`, but more accurate when color differences are large, at the cost of more computation.
+
+    Args:
+        clip: Clip where the color fix will be applied to.
+        ref: Reference clip where the colors are taken from. Should match the base clip somewhat. Compression, grain, or lower resolution are all okay.
+        wavelets: Number of wavelets, around 4 seems to work best in most cases. Higher means a more global color match and wider bloom/bleed. Lower means a more 
+            local color match and smaller bloom/bleed. Lower is also faster. Too low and the reference clip will become visible. Test values 3 and 8 and this will become more clear.
+        planes: Which planes to color fix. Any unmentioned planes will simply be copied. None means all planes will be color fixed.
+        backend: The backend used to run the color fix. **16-bit float input is always much faster on GPU, but not supported by older GPUs.**
+            - `cpu` = CPU mode using the Vapoursynth-ATWT plugin (slow).
+            - `ncnn` = GPU mode using vs-mlrt with NCNN support. Works on almost any GPU, even MAC (fast).
+            - `directml` = GPU mode using vs-mlrt with DirectML support. Works on most GPUs, but Windows only (fast).
+            - `tensorrt` = GPU mode using vs-mlrt with TensorRT support. Requires an Nvidia RTX GPU (very fast).
+        num_streams: Number of parallel GPU streams. Higher can be faster, but requires more VRAM. Does not affect the CPU backend.
+        gpu_id: GPU index ID starting from 0 for the first compatible GPU. For example to switch between iGPU/dGPU. Does not affect the CPU backend.
+        engine_folder: Optional path to the TensorRT engine storage location. By default engines are stored in `vs_colorfix/engines`. Only affects the TensorRT backend.
+    """
+    
+    # checks
+    if not isinstance(clip, vs.VideoNode):
+        raise TypeError("vs_colorfix.wavelet: Clip must be a vapoursynth clip.")
+    if not isinstance(ref, vs.VideoNode):
+        raise TypeError("vs_colorfix.wavelet: Ref must be a vapoursynth clip.")
+    if clip.format.id == vs.PresetVideoFormat.NONE or clip.width == 0 or clip.height == 0:
+        raise TypeError("vs_colorfix.wavelet: Clip must have constant format and dimensions.")
+    if ref.format.id == vs.PresetVideoFormat.NONE or ref.width == 0 or ref.height == 0:
+        raise TypeError("vs_colorfix.wavelet: Ref must have constant format and dimensions.")
+    if clip.num_frames != ref.num_frames:
+        raise ValueError("vs_colorfix.wavelet: Clip and ref must have the same number of frames.")
+    if not isinstance(wavelets, int) or isinstance(wavelets, bool):
+        raise TypeError("vs_colorfix.wavelet: Number of wavelets must be an integer.")
+    if not 1 <= wavelets <= 10:
+        raise ValueError("vs_colorfix.wavelet: Number of wavelets must be in the range 1-10.")
+    if not isinstance(gpu_id, int) or isinstance(gpu_id, bool):
+        raise TypeError("vs_colorfix.wavelet: GPU ID must be an integer.")
+    if gpu_id < 0:
+        raise ValueError("vs_colorfix.wavelet: GPU ID can not be negative.")
+    if not isinstance(num_streams, int) or isinstance(num_streams, bool):
+        raise TypeError("vs_colorfix.wavelet: Number of parallel GPU streams (num_streams) must be an integer.")
+    if num_streams < 1:
+        raise ValueError("vs_colorfix.wavelet: Number of parallel GPU streams (num_streams) must be at least 1.")
+    if clip.format.bits_per_sample <= 8 or ref.format.bits_per_sample <= 8:
+        warnings.warn("vs_colorfix.wavelet: Input clips have a low bit depth, which will cause banding. 16-bit input is recommended.", UserWarning, stacklevel=2)
+    
+    clip_format = clip.format
+    num_planes  = clip.format.num_planes
+    backend     = backend.lower()
+    
+    if backend in ["directml", "dml"] and sys.platform != "win32":
+        raise RuntimeError("vs_colorfix.wavelet: The DirectML backend is only available on Windows.")
+    if backend in ["tensorrt", "trt"] and sys.platform not in ("win32", "linux"):
+        raise RuntimeError("vs_colorfix.wavelet: The TensorRT backend is only available on Windows and Linux.")
+    if backend in ["cpu"] and not hasattr(core, "atwt"):
+        raise RuntimeError("vs_colorfix.wavelet: Please install the plugin 'Vapoursynth-ATWT' to use the CPU backend.")
+    
+    if clip_format.id != ref.format.id:
+        raise ValueError("vs_colorfix.wavelet: Clip and ref must have the same format.")
+    if planes is None:
+        planes = list(range(num_planes))
+    if isinstance(planes, int):
+        planes = [planes]
+    if num_planes == 1:
+        planes = [0]
+    planes = set(planes)
+    if not planes <= set(range(num_planes)):
+        raise ValueError("vs_colorfix.wavelet: Invalid plane index specified.")
+    
+    # resize ref if needed
+    if ref.width != clip.width or ref.height != clip.height:
+        ref = core.resize.Bilinear(ref, width=clip.width, height=clip.height)
+    
+    # clamp and shift uv if needed
+    shift_uv = False
+    if clip_format.sample_type == vs.FLOAT:
+        clamp_expr = "x 0 max 1 min"
+        if clip_format.color_family == vs.YUV:
+            clamp_uv_expr = "x -0.5 max 0.5 min"
+            if backend != "cpu":
+                shift_uv = any(p in planes for p in (1, 2))
+                clamp_uv_expr += " 0.5 +"  # shift uv to be within 0-1 for model input
+            expr = [clamp_expr if 0 in planes else "", clamp_uv_expr if 1 in planes else "", clamp_uv_expr if 2 in planes else "",]
+        else:
+            expr = [clamp_expr if p in planes else "" for p in range(num_planes)]
+
+        clip = _expression(clip, expr=expr)
+        ref  = _expression(ref,  expr=expr)
+    
+    # color fix
+    if backend == "cpu":
+        clip = _wavelet_color_fix_atwt(clip, ref, wavelets=wavelets, planes=planes)
+    else:
+        clip = _wavelet_color_fix_vsmlrt(clip, ref, wavelets=wavelets, planes=planes, backend=backend, num_streams=num_streams, gpu_id=gpu_id, engine_folder=engine_folder)
+    
+    # undo uv shift if needed and return
+    if shift_uv:
+        return _expression(clip, expr=["", "x 0.5 -" if 1 in planes else "", "x 0.5 -" if 2 in planes else ""])
+    return clip

vs_colorfix-2.1.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: vs_colorfix
+Version: 2.1.0
+Summary: Color Fix, Color Transfer, or Color Match for VapourSynth.
+Project-URL: Homepage, https://github.com/pifroggi/vs_colorfix
+Project-URL: Repository, https://github.com/pifroggi/vs_colorfix
+Project-URL: Issues, https://github.com/pifroggi/vs_colorfix/issues
+Author: pifroggi
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: color fix,color matching,color transfer,filtering,vapoursynth,video
+Classifier: Environment :: GPU
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.12
+Requires-Dist: vapoursynth-mlrt-ncnn
+Requires-Dist: vapoursynth-mlrt-ort; sys_platform == 'win32'
+Requires-Dist: vapoursynth-vszip
+Requires-Dist: vapoursynth>=74
+Provides-Extra: tensorrt
+Requires-Dist: cuda-python; (sys_platform == 'win32' or sys_platform == 'linux') and extra == 'tensorrt'
+Requires-Dist: tensorrt-cu13>=11.1.0.106; (sys_platform == 'win32' or sys_platform == 'linux') and extra == 'tensorrt'
+Requires-Dist: vapoursynth-mlrt-trt>=16.0; (sys_platform == 'win32' or sys_platform == 'linux') and extra == 'tensorrt'
+Description-Content-Type: text/markdown
+
+# Color Fix for VapourSynth
+
+For example for fixing color shift from AI upscaling/restoration models, or transfering color grading from an old release to a remaster. Also known as Color Transfer or Color Matching. See this collection of [Comparisons](https://slow.pics/c/abXjnKn3).
+
+<br />
+
+<p align="center">
+  <a href="https://slow.pics/c/abXjnKn3">
+    <img src="https://raw.githubusercontent.com/pifroggi/vs_colorfix/refs/heads/main/README_img.png" width="600" />
+  </a>
+</p>
+
+## Installation
+
+### Nvidia
+```
+pip install -U vs_colorfix[tensorrt] --extra-index-url https://pypi.nvidia.com/
+```
+To enable the Wavelet Color Fix CPU backend, install the plugin [Vapoursynth-ATWT](https://github.com/yuygfgg/Vapoursynth-ATWT). *(optional)*  
+### Others
+```
+pip install -U vs_colorfix
+```
+To enable the Wavelet Color Fix CPU backend, install the plugin [Vapoursynth-ATWT](https://github.com/yuygfgg/Vapoursynth-ATWT). *(optional)*  
+
+<br />
+
+> [!TIP]
+> For VapourSynth R73 and older, follow the [manual installation steps](https://github.com/pifroggi/vs_colorfix/wiki/Manual-Installation).
+
+<br />
+
+
+## Average Color Fix
+Fixes color shift by matching the average color of a clip to a reference clip. A very fast way to transfer colors from one clip to another. For large color differences, the Wavelet Color Fix is more accurate. 
+
+```python
+import vs_colorfix
+clip = vs_colorfix.average(clip, ref, radius=10, planes=[0, 1, 2], fast=False)
+```
+
+__*`clip`*__  
+Base clip where the colors will be applied to.  
+Recommended higher than 8-bit to avoid banding.
+
+__*`ref`*__  
+Reference clip where the colors are taken from.  
+Check the [comparisons](https://slow.pics/c/abXjnKn3) to get an idea how close it should match the base clip.
+
+__*`radius`*__  
+Higher means a more global color match and wider bloom/bleed.  
+Lower means a more local color match and smaller bloom/bleed. Too low and the reference clip will become visible.  
+Test values 5 and 30 and this will become more clear.
+
+__*`planes`* (optional)__  
+Which planes to color fix. Any unmentioned planes will simply be copied.  
+If not set, all planes will be color-fixed.
+
+ __*`fast`* (optional)__  
+Does the averaging via a downscale instead of a blur, which is much faster, but will produce faint blocky artifacts.  
+I found it useful for radius > 60 where artifacts are no longer noticable, or to fix something like a prefilter clip.
+
+> [!TIP]
+> * If your clips are not sufficiently aligned or synchronized, use [vs_align](https://github.com/pifroggi/vs_align) to align them first.
+> * To replicate chaiNNers Average Color Fix, you can convert % to radius: `radius = (100/percentage-1)/2`  
+>   ChaiNNer works like fast=True does here, but it is recommended to leave it off for better results.
+
+<br />
+
+## Wavelet Color Fix
+Fixes color shift by first converting into wavelets, then matching the average color of a clip to a reference clip. Works similarly to the Average Color Fix, but more accurate when the color differences are large, at the cost of more computation.
+
+```python
+import vs_colorfix
+clip = vs_colorfix.wavelet(clip, ref, wavelets=4, planes=[0, 1, 2], backend="ncnn", num_streams=2, gpu_id=0, engine_folder=None)
+```
+
+__*`clip`*__  
+Base clip where the colors will be applied to.  
+Recommended higher than 8-bit to avoid banding.
+
+__*`ref`*__  
+Reference clip where the colors are taken from.  
+Check the [comparisons](https://slow.pics/c/abXjnKn3) to get an idea how close it should match the base clip.
+
+__*`wavelets`*__  
+Number of wavelets in the 1-10 range. Around 4 seems to work best in most cases.  
+Higher means a more global color match and wider bloom/bleed.  
+Lower means a more local color match and smaller bloom/bleed. Too low and the reference clip will become visible.  
+Test values 3 and 8 and this will become more clear.
+
+__*`planes`* (optional)__  
+Which planes to color fix. Any unmentioned planes will simply be copied.  
+If not set, all planes will be color-fixed.
+
+__*`backend`* (optional)__  
+The used backend. **16-bit float input is always much faster on GPU, but not supported by older GPUs.**
+* `cpu` CPU mode using the vapoursynth-ATWT plugin *(slow)*.
+* `ncnn` GPU mode using vs-mlrt with NCNN support. Works on almost any GPU, even Mac *(fast)*.
+* `directml` GPU mode using vs-mlrt with DirectML support. Works on most GPUs, Windows only *(fast)*.
+* `tensorrt` GPU mode using vs-mlrt with TensorRT support. Requires an Nvidia RTX GPU. On the first run, this mode will automatically build an engine, which may take a few minutes. Changing wavelets or input dimensions will trigger rebuilding, but build engines are stored *(very fast)*.
+
+__*`num_streams`* (optional)__  
+Number of parallel GPU streams. Higher can be faster, but requires more VRAM. Does not affect the CPU backend.
+
+__*`gpu_id`* (optional)__  
+Which GPU to use starting from 0. Can be used to switch between iGPU/dGPU. Does not affect the CPU backend.
+
+__*`engine_folder`* (optional)__  
+Optional path to the TensorRT engine storage location. By default engines are stored in `vs_colorfix/engines`. Only affects the TensorRT backend.
+
+> [!TIP]
+> * On low end GPUs, the NCNN backend can be faster than TensorRT and DirectML.
+> * If your clips are not sufficiently aligned or synchronized, use [vs_align](https://github.com/pifroggi/vs_align) to align them first.
+
+<br />
+
+## Benchmarks
+Benchmarks were done on a RTX 4090 GPU and a Ryzen 5900X CPU with 16-bit input clips.
+
+<table>
+  <tr>
+    <td valign="top">
+
+<table>
+  <thead>
+    <tr align="center">
+      <th colspan="5">Wavelet Color Fix</th>
+    </tr>
+    <tr align="center">
+      <th>Resolution</th>
+      <th>TensorRT</th>
+      <th>DirectML</th>
+      <th>NCNN</th>
+      <th>CPU</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr align="center">
+      <td>1440x1080</td>
+      <td>~360 fps</td>
+      <td>~250 fps</td>
+      <td>~250 fps</td>
+      <td>~20 fps</td>
+    </tr>
+    <tr align="center">
+      <td>2880x2160</td>
+      <td>~80 fps</td>
+      <td>~60 fps</td>
+      <td>~60 fps</td>
+      <td>~5 fps</td>
+    </tr>
+  </tbody>
+</table>
+
+</td>
+<td valign="top">
+
+<table>
+  <thead>
+    <tr align="center">
+      <th colspan="3">Average Color Fix</th>
+    </tr>
+    <tr align="center">
+      <th>Resolution</th>
+      <th>fast=False</th>
+      <th>fast=True</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr align="center">
+      <td>1440x1080</td>
+      <td>~250 fps</td>
+      <td>~850 fps</td>
+    </tr>
+    <tr align="center">
+      <td>2880x2160</td>
+      <td>~60 fps</td>
+      <td>~150 fps</td>
+    </tr>
+  </tbody>
+</table>
+
+</td>
+  </tr>
+</table>
+
+<br />
+
+## Acknowledgements
+Average Color Fix idea from [chaiNNer](https://github.com/chaiNNer-org/chaiNNer).  
+Wavelet Color Fix idea from [sd-webui-stablesr](https://github.com/pkuliyi2015/sd-webui-stablesr/blob/master/srmodule/colorfix.py).

vs_colorfix-2.1.0.dist-info/RECORD

@@ -0,0 +1,47 @@
+vs_colorfix/__init__.py,sha256=Ovm8i0xiUG_snc7dji22ZG6UtExBoo48xfgKweeMU5A,120
+vs_colorfix/average_color_fix.py,sha256=pxWIw0begMAaTQuENg9mmGf790nXNXdQt8EEdn5Dl64,9305
+vs_colorfix/wavelet_color_fix.py,sha256=ANDQ4bZKqOquasGS5Lp9Q1w3OrNApz0N6swT-yRQq0Y,24852
+vs_colorfix/models/waveletcolorfix_w10_c1_fp16.onnx,sha256=EyYq3Vlso8Cl5Z7cYUSA3RHoymbJefBTvrd-YCgJzxg,11934
+vs_colorfix/models/waveletcolorfix_w10_c1_fp32.onnx,sha256=K9_a26HLpOrHQzV5G2og0uLSknnlrYvolJ7HpmFLR20,11962
+vs_colorfix/models/waveletcolorfix_w10_c3_fp16.onnx,sha256=Ez2mhB0RpEgcQfz9jPA51fG_Ddhix3crrUgoTrM1MdY,12038
+vs_colorfix/models/waveletcolorfix_w10_c3_fp32.onnx,sha256=JMwGhIQse_8l_hzEu-in2FnDiOIB_xrqdoRqZg5pMOs,12170
+vs_colorfix/models/waveletcolorfix_w1_c1_fp16.onnx,sha256=4_W9-ySSE91faIl3WMQUIAsP6w1YJ53LRdV7B-In-v0,1809
+vs_colorfix/models/waveletcolorfix_w1_c1_fp32.onnx,sha256=PxP_YAca1m-XwlGacwwzc-ehDmDZ668aY_4wJ7DeToA,1837
+vs_colorfix/models/waveletcolorfix_w1_c3_fp16.onnx,sha256=5x3l3z74AQ2A2q16TKGc3pcA9QUoLfvzyLUTQ1Xsb3Q,1913
+vs_colorfix/models/waveletcolorfix_w1_c3_fp32.onnx,sha256=WVfWij9P7e_Fwao7OCWQPHbBqIlx0zEBlDbpL1e1rWc,2045
+vs_colorfix/models/waveletcolorfix_w2_c1_fp16.onnx,sha256=_SDLo_e6zCcnxSuwmezksf6vgKpntu5eTdqsHzEKxvE,2929
+vs_colorfix/models/waveletcolorfix_w2_c1_fp32.onnx,sha256=SysdCD16HDRONa7jfeziiIWdNZmC9hi2ef6KeS8brJE,2957
+vs_colorfix/models/waveletcolorfix_w2_c3_fp16.onnx,sha256=yBhS9rMR7Y3mM9Z9D0OWeQLUcgAn_soiqI3KQCm3nGg,3033
+vs_colorfix/models/waveletcolorfix_w2_c3_fp32.onnx,sha256=mTtzEScLSc3KcajcWJs-Y4P__SSDDqdh4YZ7cS6BhvI,3165
+vs_colorfix/models/waveletcolorfix_w3_c1_fp16.onnx,sha256=YWgActbHvKT3otwOv8k0wTFHM4fF7uyG2NVQzeArxlk,4049
+vs_colorfix/models/waveletcolorfix_w3_c1_fp32.onnx,sha256=ebRndA_xFb9Pv9PhKtlW2tgrfYlmev8WDDE0fdXeC1o,4077
+vs_colorfix/models/waveletcolorfix_w3_c3_fp16.onnx,sha256=g8PVaaQG7Lz4VhHDCdbw0_strgDw3QAOvjJjTEe8qmo,4153
+vs_colorfix/models/waveletcolorfix_w3_c3_fp32.onnx,sha256=RZQGR17Tdeb0-PcCeWXFa81BftHPNX5uIItvaSC9B9M,4285
+vs_colorfix/models/waveletcolorfix_w4_c1_fp16.onnx,sha256=IMsySRFvf22-BoMwDNCJQ46lmD3TaGGsRQfNaXlOnPc,5169
+vs_colorfix/models/waveletcolorfix_w4_c1_fp32.onnx,sha256=pMdi4XkS5bvcB_MwVk2Ie9rkdVgHNVoYnvr-gdOa1vg,5197
+vs_colorfix/models/waveletcolorfix_w4_c3_fp16.onnx,sha256=9WbAG1-X1rW8-j8q4E-9aY8NTRi-YDpr_r6Uw4p3k-U,5273
+vs_colorfix/models/waveletcolorfix_w4_c3_fp32.onnx,sha256=nTiJ3HwlFLuJIKtUscASTiwPOSTfw2aFMkKCSaDu4Hc,5405
+vs_colorfix/models/waveletcolorfix_w5_c1_fp16.onnx,sha256=CJ7DrjLJ1J6KSYRruKTU_KB1brd8XGYd6m4kbebSjWA,6289
+vs_colorfix/models/waveletcolorfix_w5_c1_fp32.onnx,sha256=jVgXS57AnyVfqJhvKeB8vFjeappJFBTrOmGphx6bI3A,6317
+vs_colorfix/models/waveletcolorfix_w5_c3_fp16.onnx,sha256=1mDo_8_Zka4DWVPSiYIdKj0PyjbDF0KPgKnL-b6wWJs,6393
+vs_colorfix/models/waveletcolorfix_w5_c3_fp32.onnx,sha256=Rl5LpwoZLcnpKJ6IfkA1OE17TxB_77vQzr_xBG5pX3k,6525
+vs_colorfix/models/waveletcolorfix_w6_c1_fp16.onnx,sha256=nuWxjZ7sWytTXqtpmlDENudlN_e0eS8zaLgcIuMd2Ic,7409
+vs_colorfix/models/waveletcolorfix_w6_c1_fp32.onnx,sha256=SX1VQriGtjGjLF7WUrkf6OShy5a4Sz-zgVxQMiOGVRw,7437
+vs_colorfix/models/waveletcolorfix_w6_c3_fp16.onnx,sha256=lPIJ24oFDOqtoJ7-MCjunlLreLLAsaC40kb5dMn-jVw,7513
+vs_colorfix/models/waveletcolorfix_w6_c3_fp32.onnx,sha256=B3uD2RnxCWHomtS9HnGBWgUtyTa_mEMKfP1H-mbni_4,7645
+vs_colorfix/models/waveletcolorfix_w7_c1_fp16.onnx,sha256=Okb6N8BLziqBeSp8YVbZhJQ_g5--MypL_rCqENT-KHU,8537
+vs_colorfix/models/waveletcolorfix_w7_c1_fp32.onnx,sha256=9sKKKL4xQLhzq7jzSrwrH7DtZGLi0W-bKCXosPgybYU,8565
+vs_colorfix/models/waveletcolorfix_w7_c3_fp16.onnx,sha256=g56ZJQzNMX8-DLG3t4FzPpC8cN1p3suwNJna7xuQudo,8641
+vs_colorfix/models/waveletcolorfix_w7_c3_fp32.onnx,sha256=GP1UPQj66NbE9qoMxVHT1zz16LYCfFzb07gfdCwspc8,8773
+vs_colorfix/models/waveletcolorfix_w8_c1_fp16.onnx,sha256=mpuc3Vnis9UNv3tkFx34XptL3FaWGimQm6K9gxbnpAo,9669
+vs_colorfix/models/waveletcolorfix_w8_c1_fp32.onnx,sha256=bmDeluMJiK9EL88ufM_WnSEqpzKedSEFh42VBrQ0ACk,9697
+vs_colorfix/models/waveletcolorfix_w8_c3_fp16.onnx,sha256=Tba4zYZW6uq4QV2fbT1xyxg-JLeeQ_fCBlzVxzeAi1Y,9773
+vs_colorfix/models/waveletcolorfix_w8_c3_fp32.onnx,sha256=WwH__Q8ebk_l_TjS5yl2tL5VINj_dkaxlSBDKk2Zr9o,9905
+vs_colorfix/models/waveletcolorfix_w9_c1_fp16.onnx,sha256=NcYSw1vTC537HQJFUbu1VsSihxIg1o9Kdiof-H03Sgs,10801
+vs_colorfix/models/waveletcolorfix_w9_c1_fp32.onnx,sha256=iAiQ9HQ_qoozyiD1JubAQ_PduML2Gf9l4bZyjfycerw,10829
+vs_colorfix/models/waveletcolorfix_w9_c3_fp16.onnx,sha256=0G6PsfW9RdjaRE9sWEdBnKUeis9zGlB8UBIN--F26vc,10905
+vs_colorfix/models/waveletcolorfix_w9_c3_fp32.onnx,sha256=VkTJSpasoTdyFof2hr_NW7ZV3th86sfNWl30LMJFW1I,11037
+vs_colorfix-2.1.0.dist-info/METADATA,sha256=RF3WN_YsJasRvTU8GNpS1-AhXNiX_abq-uWw9JC7HVs,8016
+vs_colorfix-2.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+vs_colorfix-2.1.0.dist-info/licenses/LICENSE,sha256=rDnRnsVuJK-HA3kjcSyoTRoRJcBKkxIGnGch87i1KSE,11337
+vs_colorfix-2.1.0.dist-info/RECORD,,

vs_colorfix-2.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vs_colorfix-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 pifroggi
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.