soifunc 0.14.0__tar.gz → 0.14.2__tar.gz

{soifunc-0.14.0 → soifunc-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soifunc
-Version: 0.14.0
+Version: 0.14.2
 Summary: Soichiro's VapourSynth Functions Collection
 License: MIT
 License-File: LICENSE

{soifunc-0.14.0 → soifunc-0.14.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "soifunc"
-version = "0.14.0"
+version = "0.14.2"
 description = "Soichiro's VapourSynth Functions Collection"
 authors = ["Josh Holmer <jholmer.in@gmail.com>"]
 license = "MIT"

{soifunc-0.14.0 → soifunc-0.14.2}/soifunc/__init__.py

@@ -2,3 +2,4 @@ from .deband import *  # noqa: F401, F403
 from .denoise import *  # noqa: F401, F403
 from .interpolate import *  # noqa: F401, F403
 from .resize import *  # noqa: F401, F403
+from .subtitle import *  # noqa: F401, F403

{soifunc-0.14.0 → soifunc-0.14.2}/soifunc/deband.py

@@ -17,14 +17,19 @@ __all__ = [
 
 def retinex_deband(
     clip: vs.VideoNode,
-    threshold: int,
+    threshold: int = 24,
     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.
+        threshold: Debanding strength (0-255). A reasonable range is around 16-64.
+            According to the original f3kdb documentation (https://f3kdb.readthedocs.io/en/stable/presets.html):
+            - Low = 32
+            - Medium = 48
+            - High = 64
+            - Very high = 80
         showmask: If True, return edge mask instead of debanded clip.
 
     Returns:
@@ -55,10 +60,8 @@ def retinex_deband(
     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.
+    # The bitshift here is to adjust threshold values from neo_f3kdb's
+    # `scale=False` behavior to match vs-jetpack's `scale=True` behavior.
+    # It is not related to bit depth. The threshold value is independent of bit depth.
     deband = f3k_deband(clip, thr=(threshold << 2))
     return core.std.MaskedMerge(deband, clip, mask)

{soifunc-0.14.0 → soifunc-0.14.2}/soifunc/denoise.py

@@ -4,9 +4,9 @@ from typing import Callable, Optional
 
 import vsdenoise
 from vsdenoise import DFTTest, bm3d, mc_degrain, nl_means
-from vstools import core, depth, get_u, get_y, join, split, vs
+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(
@@ -218,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-0.14.0 → soifunc-0.14.2}/soifunc/interpolate.py

@@ -59,7 +59,7 @@ def replace_dupes(
     clip: vs.VideoNode,
     max_length: int = 5,
     backend: backendT | None = None,
-    threshold: float = 0.001,
+    threshold: float = 0.0005,
 ) -> vs.VideoNode:
     """
     Detects strings of duplicate frames in a video and replaces them

soifunc-0.14.2/soifunc/subtitle.py

@@ -0,0 +1,57 @@
+from vsaa import NNEDI3, based_aa, pre_aa
+from vstools import ChromaLocation, ColorRange, Matrix, Primaries, Transfer, vs
+
+from soifunc.resize import good_resize
+
+__all__ = [
+    "based_imagesub",
+]
+
+
+def based_imagesub(clip: vs.VideoNode, sub_file: str) -> vs.VideoNode:
+    """
+    ImageSub that performs anti-aliasing on only the subtitles.
+
+    :param clip: Video to add subtitles to
+    :type clip: vs.VideoNode
+    :param sub_file: Path to the image-based subtitles file
+    :type sub_file: str
+    :return: Subtitled video
+    :rtype: vs.VideoNode
+    """
+    matrix = Matrix.from_video(clip)
+    primaries = Primaries.from_video(clip)
+    transfer = Transfer.from_video(clip)
+    range = ColorRange.from_video(clip)
+    sub = clip.sub.ImageFile(
+        file=sub_file,
+        blend=False,
+    )
+    sub = sub.resize.Spline36(
+        format=clip.format.id,
+        matrix=matrix,
+        primaries_in=primaries,
+        primaries=primaries,
+        transfer_in=transfer,
+        transfer=transfer,
+        range=range,
+    )
+    sub = good_resize(sub, clip.width, clip.height)
+    # Use NNEDI3 since ArtCNN isn't really designed for text
+    sub = based_aa(sub, prefilter=pre_aa, supersampler=NNEDI3)
+
+    mask = sub.std.PropToClip(prop="_Alpha")
+    mask_format = vs.core.query_video_format(
+        mask.format.color_family,
+        clip.format.sample_type,
+        clip.format.bits_per_sample,
+        mask.format.subsampling_w,
+        mask.format.subsampling_h,
+    )
+    mask = mask.resize.Spline36(
+        clip.width,
+        clip.height,
+        format=mask_format.id,
+    )
+
+    return vs.core.std.MaskedMerge(clipa=clip, clipb=sub, mask=mask)