soifunc 0.12.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

soifunc/deband.py

@@ -2,7 +2,13 @@ from __future__ import annotations
 
 from vsdeband import f3k_deband
 from vsmasktools import dre_edgemask
-from vstools import InvalidVideoFormatError, check_variable, core, vs
+from vstools import (
+    UnsupportedVideoFormatError,
+    VariableFormatError,
+    check_variable,
+    core,
+    vs,
+)
 
 __all__ = [
     "retinex_deband",
@@ -14,33 +20,45 @@ def retinex_deband(
     threshold: int,
     showmask: bool = False,
 ) -> vs.VideoNode:
+    """Debanding using contrast-adaptive edge masking.
+
+    Args:
+        clip: Input video (8-16bit YUV required).
+        threshold: Debanding strength (0-255). Default ~16-48 recommended.
+        showmask: If True, return edge mask instead of debanded clip.
+
+    Returns:
+        Debanded video clip or edge mask.
+
+    Note:
+        Does not add grain. Use vsdeband.AddNoise for post-denoising.
     """
-    Debanding using a contrast-adaptive edge mask to preserve details
-    even in dark areas.
-    
-    "medium" `threshold` in f3kdb is 48. I think that's a bit strong.
-    16 might be a more sane starting point. Increase as needed.
-
-    This function does not add grain on its own. Use another function like
-    `vsdeband.AddNoise` to do that.
-    """
-    assert check_variable(clip, retinex_deband)
+    if threshold < 0 or threshold > 255:
+        raise ValueError(f"threshold must be between 0-255, got {threshold}")
+
+    if not check_variable(clip, retinex_deband):
+        raise VariableFormatError("clip must have constant format and fps")
 
     if (
         clip.format.color_family != vs.YUV
         or clip.format.sample_type != vs.INTEGER
         or clip.format.bits_per_sample > 16
     ):
-        raise InvalidVideoFormatError(
+        raise UnsupportedVideoFormatError(
             retinex_deband,
             clip.format,
             "The format {format.name} is not supported! It must be an 8-16bit integer YUV bit format!",
         )
 
-    mask = dre_edgemask.CLAHE(clip)
+    mask: vs.VideoNode = dre_edgemask.CLAHE(clip)
 
     if showmask:
         return mask
 
+    # The threshold value that `retinex_deband` takes is relative
+    # to 8-bit videos, but `f3kdb` changed their threshold
+    # values to be relative to 10-bit videos some time after this
+    # function was created. To keep this function compatible,
+    # we shift our threshold from 8-bit to 10-bit.
     deband = f3k_deband(clip, thr=(threshold << 2))
     return core.std.MaskedMerge(deband, clip, mask)

soifunc/denoise.py

@@ -3,17 +3,18 @@ from __future__ import annotations
 from typing import Callable, Optional
 
 import vsdenoise
-from vsdenoise import DFTTest, bm3d, mc_degrain
-from vstools import core, vs
+from vsdenoise import DFTTest, bm3d, mc_degrain, nl_means
+from vstools import check_variable, core, join, split, vs
 
-__all__ = ["MCDenoise", "magic_denoise", "hqbm3d", "mc_dfttest"]
+__all__ = ["MCDenoise", "magic_denoise", "hqbm3d", "mc_dfttest", "Stab"]
 
 
 def hqbm3d(
     clip: vs.VideoNode,
-    luma_str: float = 0.45,
+    luma_str: float = 0.5,
     chroma_str: float = 0.4,
     profile: bm3d.Profile = bm3d.Profile.FAST,
+    tr: int = 1,
 ) -> vs.VideoNode:
     """
     High-quality presets for motion compensated denoising.
@@ -39,12 +40,24 @@ def hqbm3d(
         ),
         planes=None,
     )
-    out = bm3d(clip, sigma=luma_str, tr=1, ref=mv, profile=profile, planes=0)
-    return vsdenoise.nl_means(out, h=chroma_str, tr=1, ref=mv, planes=[1, 2])
+    [y, u, v] = split(clip)
+    [y_mv, u_mv, v_mv] = split(mv)
+    out_y = bm3d(y, sigma=luma_str, tr=tr, ref=y_mv, profile=profile)
+    if not hasattr(core, "nlm_cuda") and hasattr(core, "knlm"):
+        # the KNLMeansCL would force extra depth conversions
+        # and re-processing of the luma plane, so avoid it.
+        nlm_backend = nl_means.Backend.ISPC
+    else:
+        nlm_backend = nl_means.Backend.AUTO
+    out_u = nl_means(u, h=chroma_str, tr=tr, ref=u_mv, backend=nlm_backend)
+    out_v = nl_means(v, h=chroma_str, tr=tr, ref=v_mv, backend=nlm_backend)
+    return join(out_y, out_u, out_v, prop_src=clip)
 
 
 def mc_dfttest(
-    clip: vs.VideoNode, thSAD: int = 75, noisy: bool = False
+    clip: vs.VideoNode,
+    thSAD: int = 75,
+    tr: int = 2,
 ) -> vs.VideoNode:
     """
     A motion-compensated denoiser using DFTTEST.
@@ -52,19 +65,14 @@ def mc_dfttest(
     Turn it up to 150 or more if you really need to nuke something.
     It does a decent job at preserving details, but not nearly as good
     as bm3d, so this is not recommended on clean, high-quality sources.
-
-    The `noisy` parameter did help preserve more detail on high-quality but grainy sources.
-    Currently it is deprecated, as the presets in `vsdenoise` changed,
-    but it may be un-deprecated in the future.
     """
-    # TODO: Do we need to tweak anything for the `noisy` param?
     blksize = select_block_size(clip)
     return mc_degrain(
         clip,
         prefilter=vsdenoise.Prefilter.DFTTEST,
         preset=vsdenoise.MVToolsPreset.HQ_SAD,
         thsad=thSAD,
-        tr=2,
+        tr=tr,
         refine=3 if blksize > 16 else 2,
         blksize=blksize,
     )
@@ -210,3 +218,47 @@ def magic_denoise(clip: vs.VideoNode) -> vs.VideoNode:
         tbsize=3,
         ssystem=1,
     )
+
+
+##############################################################################
+# Original script by g-force converted into a stand alone script by McCauley #
+# then copied from havsfunc when they deleted it                             #
+# latest version from December 10, 2008                                      #
+##############################################################################
+def Stab(clp, dxmax=4, dymax=4, mirror=0):
+    if not isinstance(clp, vs.VideoNode):
+        raise vs.Error("Stab: this is not a clip")
+
+    clp = scdetect(clp, 25 / 255)
+    temp = clp.misc.AverageFrames([1] * 15, scenechange=True)
+    inter = core.std.Interleave(
+        [
+            core.rgvs.Repair(
+                temp, clp.misc.AverageFrames([1] * 3, scenechange=True), mode=[1]
+            ),
+            clp,
+        ]
+    )
+    mdata = inter.mv.DepanEstimate(trust=0, dxmax=dxmax, dymax=dymax)
+    last = inter.mv.DepanCompensate(data=mdata, offset=-1, mirror=mirror)
+    return last[::2]
+
+
+def scdetect(clip: vs.VideoNode, threshold: float = 0.1) -> vs.VideoNode:
+    def _copy_property(n: int, f: list[vs.VideoFrame]) -> vs.VideoFrame:
+        fout = f[0].copy()
+        fout.props["_SceneChangePrev"] = f[1].props["_SceneChangePrev"]
+        fout.props["_SceneChangeNext"] = f[1].props["_SceneChangeNext"]
+        return fout
+
+    assert check_variable(clip, scdetect)
+
+    sc = clip
+    if clip.format.color_family == vs.RGB:
+        sc = clip.resize.Point(format=vs.GRAY8, matrix_s="709")
+
+    sc = sc.misc.SCDetect(threshold)
+    if clip.format.color_family == vs.RGB:
+        sc = clip.std.ModifyFrame([clip, sc], _copy_property)
+
+    return sc

soifunc/interpolate.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import platform
 from typing import TYPE_CHECKING
 
 import vstools
@@ -10,7 +9,7 @@ from vstools import vs
 if TYPE_CHECKING:
     from vsmlrt import backendT
 
-__all__ = ["rate_doubler", "decimation_fixer"]
+__all__ = ["rate_doubler", "decimation_fixer", "replace_dupes"]
 
 
 def rate_doubler(
@@ -26,6 +25,7 @@ def rate_doubler(
 
     width = clip.width
     height = clip.height
+    format = clip.format
     matrix = vstools.Matrix.from_video(clip)
     transfer = vstools.Transfer.from_video(clip)
     primaries = vstools.Primaries.from_video(clip)
@@ -45,7 +45,7 @@ def rate_doubler(
     )
     # TODO: Handle other chroma samplings
     clip = clip.resize.Bicubic(
-        format=vs.YUV420P16,
+        format=format,
         width=width,
         height=height,
         matrix=matrix,
@@ -55,6 +55,117 @@ def rate_doubler(
     return clip
 
 
+def replace_dupes(
+    clip: vs.VideoNode,
+    max_length: int = 5,
+    backend: backendT | None = None,
+    threshold: float = 0.001,
+) -> vs.VideoNode:
+    """
+    Detects strings of duplicate frames in a video and replaces them
+    with interpolated frames from RIFE.
+
+    Max number of continuous duplicates to detect is determined by the `max_length` parameter.
+    `threshold` is the maximum average pixel difference (0-1 scale) to consider frames as duplicates.
+    Lower values are stricter (frames must be more similar to be considered duplicates).
+    """
+    import vsmlrt
+
+    # Store original properties
+    width = clip.width
+    height = clip.height
+    format = clip.format
+    matrix = vstools.Matrix.from_video(clip)
+    transfer = vstools.Transfer.from_video(clip)
+    primaries = vstools.Primaries.from_video(clip)
+
+    # Compute frame differences using PlaneStats
+    # This compares each frame with the previous one
+    diff_clip = clip.std.PlaneStats(clip[0] + clip)
+
+    # Prepare clip for RIFE (convert to RGBS and resize to multiple of 64)
+    rife_clip = clip.resize.Bicubic(
+        format=vs.RGBS,
+        width=next_multiple_of(64, width),
+        height=next_multiple_of(64, height),
+    )
+
+    # Create interpolated frames using RIFE (double the framerate)
+    interpolated = vsmlrt.RIFE(
+        rife_clip,
+        multi=2,
+        model=vsmlrt.RIFEModel.v4_25_heavy,
+        backend=(backend if backend else autoselect_backend()),
+    )
+
+    # Convert interpolated frames back to original format
+    interpolated = interpolated.resize.Bicubic(
+        format=format,
+        width=width,
+        height=height,
+        matrix=matrix,
+        transfer=transfer,
+        primaries=primaries,
+    )
+
+    # Track sequence state for lazy evaluation
+    state = {"prev_len": 0}
+
+    def select_frame(n):
+        """
+        Select interpolated frame if current frame is a duplicate,
+        otherwise use original. Copies PlaneStatsDiff property to output
+        to help users calibrate the threshold parameter.
+        """
+        if n == 0 or n == clip.num_frames - 1:
+            state["prev_len"] = 0
+            # Frame 0 and final frame are never duplicates
+            # (no previous frame for 0, no next frame for final)
+            output = clip[n : n + 1]
+            diff_val = (
+                0.0
+                if n == 0
+                else diff_clip.get_frame(n).props.get("PlaneStatsDiff", 1.0)
+            )
+            return output.std.SetFrameProp(prop="PlaneStatsDiff", floatval=diff_val)
+
+        # Get difference from PlaneStats (lazy evaluation)
+        f = diff_clip.get_frame(n)
+        diff = f.props.get("PlaneStatsDiff", 1.0)
+
+        # Determine if this is a duplicate
+        if diff < threshold:
+            new_len = state["prev_len"] + 1
+            if new_len <= max_length:
+                state["prev_len"] = new_len
+                is_dupe = True
+            else:
+                state["prev_len"] = 0
+                is_dupe = False
+        else:
+            state["prev_len"] = 0
+            is_dupe = False
+
+        if is_dupe:
+            # Use interpolated frame between previous and current
+            # If the original sequence is 0 1 2 where 0 and 1 are dupes,
+            # the interpolated sequence will have 0 1 2 3 4 5
+            # where 3 is the interpolated frame we want to fetch
+            # to replace frame 1..
+
+            output = interpolated[n * 2 + 1 : n * 2 + 2]
+        else:
+            output = clip[n : n + 1]
+
+        # Attach PlaneStatsDiff property to output frame for threshold calibration
+        return output.std.SetFrameProp(prop="PlaneStatsDiff", floatval=diff)
+
+    # Apply frame selection with lazy evaluation
+    result = clip.std.FrameEval(select_frame)
+
+    return result
+
+
 def decimation_fixer(
     clip: vs.VideoNode, cycle: int, offset: int = 0, backend: backendT | None = None
 ) -> vs.VideoNode:
@@ -78,6 +189,7 @@ def decimation_fixer(
     width = clip.width
     height = clip.height
     fps = clip.fps
+    format = clip.format
     input_cycle = cycle - 1
     matrix = vstools.Matrix.from_video(clip)
     transfer = vstools.Transfer.from_video(clip)
@@ -115,9 +227,8 @@ def decimation_fixer(
         fpsnum=fps.numerator * cycle // input_cycle, fpsden=fps.denominator
     )
 
-    # TODO: Handle other chroma samplings
     out_clip = out_clip.resize.Bicubic(
-        format=vs.YUV420P16,
+        format=format,
         width=width,
         height=height,
         matrix=matrix,

soifunc/resize.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from vsaa.deinterlacers import NNEDI3
-from vskernels import (
-    Hermite,
-    Spline36,
-)
+from vskernels import Hermite, LeftShift, Spline36, TopShift
 from vsscale import ArtCNN
-from vstools import check_variable_format, is_gpu_available, join, vs
+from vstools import (
+    VariableFormatError,
+    check_variable_format,
+    is_gpu_available,
+    join,
+    vs,
+)
 
 __all__ = [
     "good_resize",
@@ -17,7 +20,7 @@ def good_resize(
     clip: vs.VideoNode,
     width: int,
     height: int,
-    shift: tuple[float, float] = (0, 0),
+    shift: tuple[TopShift | list[TopShift], LeftShift | list[LeftShift]] = (0, 0),
     gpu: bool | None = None,
     anime: bool = False,
 ) -> vs.VideoNode:
@@ -55,10 +58,12 @@ def good_resize(
     else:
         luma_scaler = Hermite(sigmoid=True)
 
-    assert check_variable_format(clip, "good_resize")
+    if not check_variable_format(clip, "good_resize"):
+        raise VariableFormatError("Invalid clip format for good_resize")
 
     luma = luma_scaler.scale(clip, width, height, shift)
 
+    # Grayscale doesn't need chroma processing
     if clip.format.num_planes == 1:
         return luma
 

{soifunc-0.12.0.dist-info → soifunc-0.14.1.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: soifunc
-Version: 0.12.0
+Version: 0.14.1
 Summary: Soichiro's VapourSynth Functions Collection
 License: MIT
+License-File: LICENSE
 Author: Josh Holmer
 Author-email: jholmer.in@gmail.com
 Requires-Python: >=3.12,<4.0
@@ -10,8 +11,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: vapoursynth (>=68)
-Requires-Dist: vsjetpack (>=0.7.1,<0.8.0)
+Requires-Dist: vsjetpack (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 ## soifunc

soifunc-0.14.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+soifunc/__init__.py,sha256=H6BWoCLRW2ZD47wQtL72SIZvTpD6REH7cUqIYWvCn0k,174
+soifunc/deband.py,sha256=8mT1FqKAteUAs1XJYi8WvmlcJtyQN2OxM5mfiujTKX4,1887
+soifunc/denoise.py,sha256=pWmGbFU5IRU0AAPi56a57NNBq-zaNUd7IG-nfdCgTeA,8897
+soifunc/interpolate.py,sha256=2Agg1N4GG9h6lkl7soy7G--ahVk3msbDfKGuRbj2Syo,7878
+soifunc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+soifunc/resize.py,sha256=sOJpkovIEgaKvABEJTLfvYfKj6zvGf9pFRQMoWb7XdY,1998
+soifunc-0.14.1.dist-info/METADATA,sha256=xVcBWO_TJ36Fx2Mc60QwRH3XFeKMVYjhPM1NxWZZ1Gc,1287
+soifunc-0.14.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+soifunc-0.14.1.dist-info/licenses/LICENSE,sha256=vgEDSMEV1J2nMiCgXE5_sjNtw2VT7_lP7rkAnrFKOWI,1068
+soifunc-0.14.1.dist-info/RECORD,,

{soifunc-0.12.0.dist-info → soifunc-0.14.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

soifunc-0.12.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-soifunc/__init__.py,sha256=H6BWoCLRW2ZD47wQtL72SIZvTpD6REH7cUqIYWvCn0k,174
-soifunc/deband.py,sha256=MbI5OOG8JpWqM5B5ux6OU784-39PtCMQWrh9mk4k2xY,1273
-soifunc/denoise.py,sha256=ALTftqL9Q1cPLKtAU60mT3-RUkVHXBqgg2Pa9GwjGIY,6982
-soifunc/interpolate.py,sha256=dgYczCdn716afJ3sZgQgcF6KfAkaU2J_obJD-Kp7wP4,4091
-soifunc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-soifunc/resize.py,sha256=pSoQtrsxfWr44Wg4M9GRyMJnOsgnjsWEr6ZyoJW7Qkk,1781
-soifunc-0.12.0.dist-info/LICENSE,sha256=vgEDSMEV1J2nMiCgXE5_sjNtw2VT7_lP7rkAnrFKOWI,1068
-soifunc-0.12.0.dist-info/METADATA,sha256=cIZ9ZFeGwNCWcyiyKTStP51OvnaG7pLWRX3fTcv0vzo,1214
-soifunc-0.12.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-soifunc-0.12.0.dist-info/RECORD,,