helpers ¶

def pre_ss(
    clip: vs.VideoNode,
    function: VSFunctionNoArgs[vs.VideoNode, vs.VideoNode],
    rfactor: float = 2.0,
    supersampler: ScalerLike = Bilinear,
    downscaler: ScalerLike = Point,
    mod: int = 4,
    planes: PlanesT = None,
    func: FuncExceptT | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Supersamples the input clip, applies a given function to the higher-resolution version,
    and then downscales it back to the original resolution.

    Example usage:
        ```py
        from vsdehalo import fine_dehalo
        from vsaa import NNEDI3

        # Point downscale will undo the intrinsic shift of NNEDI3 on the luma plane.
        processed = pre_ss(clip, lambda clip: fine_dehalo(clip, ...), supersampler=NNEDI3(noshift=(True, False)))
        ```

    Args:
        clip: Source clip.
        function: A function to apply on the supersampled clip. Must accept a `planes` argument.
        rfactor: Scaling factor for supersampling. Defaults to 2.
        supersampler: Scaler used to downscale the processed clip back to its original resolution.
            Defaults to `Bilinear`.
        downscaler: Downscaler used for undoing the upscaling done by the supersampler. Defaults to `Point`.
        mod: Ensures the supersampled resolution is a multiple of this value. Defaults to 4.
        planes: Which planes to process.
        func: An optional function to use for error handling.
        **kwargs: Additional keyword arguments passed to the provided `function`.

    Returns:
        A clip with the given function applied at higher resolution, then downscaled back.
    """
    if rfactor == 1.0:
        return function(clip, **kwargs)

    func_util = FunctionUtil(clip, func or pre_ss, planes)

    ss = Scaler.ensure_obj(supersampler, func_util.func).scale(
        clip, mod_x(func_util.work_clip.width * rfactor, mod), mod_x(func_util.work_clip.height * rfactor, mod)
    )

    processed = function(ss, **kwargs)

    down = Scaler.ensure_obj(downscaler, func_util.func).scale(processed, clip.width, clip.height)

    return func_util.return_clip(down)

def scale_var_clip(
    clip: vs.VideoNode,
    scaler: Scaler | Callable[[Resolution], Scaler] | Callable[[tuple[int, int]], Scaler],
    width: int | Callable[[Resolution], int] | Callable[[tuple[int, int]], int] | None,
    height: int | Callable[[Resolution], int] | Callable[[tuple[int, int]], int],
    shift: tuple[float, float] | Callable[[tuple[int, int]], tuple[float, float]] = (0, 0),
    debug: bool = False,
) -> vs.VideoNode:
    """
    Scale a variable clip to constant or variable resolution.

    Args:
        clip: Source clip.
        scaler: A scaler instance or a callable that returns a scaler instance.
        width: A width integer or a callable that returns the width. If None, it will be calculated from the height and
            the aspect ratio of the clip.
        height: A height integer or a callable that returns the height.
        shift: Optional top shift, left shift tuple or a callable that returns the shifts. Defaults to no shift.
        debug: If True, the `var_width` and `var_height` props will be added to the clip.

    Returns:
        Scaled clip.
    """
    _cached_clips = dict[str, vs.VideoNode]()

    no_accepts_var = list[Scaler]()

    def _eval_scale(f: vs.VideoFrame, n: int) -> vs.VideoNode:
        key = f"{f.width}_{f.height}"

        if key not in _cached_clips:
            res = Resolution(f.width, f.height)

            norm_scaler = scaler(res) if callable(scaler) else scaler
            norm_shift = shift(res) if callable(shift) else shift
            norm_height = height(res) if callable(height) else height

            if width is None:
                norm_width = get_w(norm_height, res.width / res.height)
            else:
                norm_width = width(res) if callable(width) else width

            part_scaler = partial(norm_scaler.scale, width=norm_width, height=norm_height, shift=norm_shift)

            scaled = clip
            if (scaled.width, scaled.height) != (norm_width, norm_height):
                if norm_scaler not in no_accepts_var:
                    try:
                        scaled = part_scaler(clip)
                    except BaseException:
                        no_accepts_var.append(norm_scaler)

                if norm_scaler in no_accepts_var:
                    const_clip = clip.resize.Point(res.width, res.height)

                    scaled = part_scaler(const_clip)

            if debug:
                scaled = scaled.std.SetFrameProps(var_width=res.width, var_height=res.height)

            _cached_clips[key] = scaled

        return _cached_clips[key]

    out_clip = clip if callable(width) or callable(height) else clip.std.BlankClip(width, height)

    return out_clip.std.FrameEval(_eval_scale, clip, clip)