various ¶

@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `border_handling`, `sample_grid_model` and `field_based` from Descaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    # `blur` and `ignore_mask` from CustomKernel
    blur: float = 1.0, ignore_mask: vs.VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    ...

def descale_function(
    self, clip: vs.VideoNode, width: int, height: int, *args: Any, **kwargs: Any
) -> ConstantFormatVideoNode:
    kernel, support = self._modify_kernel_func(kwargs)

    clean_kwargs = {
        k: v for k, v in kwargs.items()
        if k not in Signature.from_callable(self._modify_kernel_func).parameters.keys()
    }

    try:
        return core.descale.Decustom(clip, width, height, kernel, ceil(support), *args, **clean_kwargs)
    except vs.Error as e:
        if 'Output dimension must be' in str(e):
            raise CustomValueError(
                f'Output dimension ({width}x{height}) must be less than or equal to '
                f'input dimension ({clip.width}x{clip.height}).', self.__class__
            )

        raise CustomValueError(e, self.__class__)

@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(True, clip, width, height, **kwargs)
    )

def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    args = super().get_params_args(is_descale, clip, width, height, **kwargs)

    if not is_descale:
        for key in ('border_handling', 'ignore_mask'):
            args.pop(key, None)

    return args

@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

@inject_self.cached
def kernel(self, *, x: float) -> float:
    if x >= self.kernel_radius:
        return 0.0

    return sinc(x) * self._win_coef(x)

@inject_self.cached.property
def kernel_radius(self) -> int:
    return ceil(self.taps)

@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

def resample_function(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None, *args: Any, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.scale_function(clip, width, height, *args, **kwargs)  # type: ignore[return-value]

@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    # `border_handling`, `sample_grid_model`, `sar`, `dar`, `dar_in` and `keep_ar` from KeepArScaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    sar: Sar | float | bool | None = None, dar: Dar | float | bool | None = None,
    dar_in: Dar | bool | float | None = None, keep_ar: bool | None = None,
    # `linear` and `sigmoid` from LinearScaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> vs.VideoNode:
    width, height = Scaler._wh_norm(clip, width, height)
    return super().scale(
        clip, width, height, shift,
        border_handling=border_handling, sample_grid_model=sample_grid_model,
        sar=sar, dar=dar, dar_in=dar_in, keep_ar=keep_ar,
        linear=linear, sigmoid=sigmoid,
        **kwargs
    )

def scale_function(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None, *args: Any, **kwargs: Any
) -> vs.VideoNode:

    if not hasattr(core, 'resize2'):
        raise DependencyNotFoundError(
            self.__class__, 'resize2', 'Missing dependency \'resize2\'! '
            'You can find it here: https://github.com/Jaded-Encoding-Thaumaturgy/vapoursynth-resize2'
        )

    kernel, support = self._modify_kernel_func(kwargs)

    clean_kwargs = {
        k: v for k, v in kwargs.items()
        if k not in Signature.from_callable(self._modify_kernel_func).parameters.keys()
    }

    return core.resize2.Custom(clip, kernel, ceil(support), width, height, *args, **clean_kwargs)

@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)

@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `border_handling`, `sample_grid_model` and `field_based` from Descaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    # `blur` and `ignore_mask` from CustomKernel
    blur: float = 1.0, ignore_mask: vs.VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    ...

def descale_function(
    self, clip: vs.VideoNode, width: int, height: int, *args: Any, **kwargs: Any
) -> ConstantFormatVideoNode:
    kernel, support = self._modify_kernel_func(kwargs)

    clean_kwargs = {
        k: v for k, v in kwargs.items()
        if k not in Signature.from_callable(self._modify_kernel_func).parameters.keys()
    }

    try:
        return core.descale.Decustom(clip, width, height, kernel, ceil(support), *args, **clean_kwargs)
    except vs.Error as e:
        if 'Output dimension must be' in str(e):
            raise CustomValueError(
                f'Output dimension ({width}x{height}) must be less than or equal to '
                f'input dimension ({clip.width}x{clip.height}).', self.__class__
            )

        raise CustomValueError(e, self.__class__)

@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(True, clip, width, height, **kwargs)
    )

def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    args = super().get_params_args(is_descale, clip, width, height, **kwargs)

    if not is_descale:
        for key in ('border_handling', 'ignore_mask'):
            args.pop(key, None)

    return args

@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

@inject_self.cached
def kernel(self, *, x: float) -> float:
    if x >= self.kernel_radius:
        return 0.0

    return sinc(x) * self._win_coef(x)

@inject_self.cached.property
def kernel_radius(self) -> int:
    return ceil(self.taps)

@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

def resample_function(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None, *args: Any, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.scale_function(clip, width, height, *args, **kwargs)  # type: ignore[return-value]

@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    # `border_handling`, `sample_grid_model`, `sar`, `dar`, `dar_in` and `keep_ar` from KeepArScaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    sar: Sar | float | bool | None = None, dar: Dar | float | bool | None = None,
    dar_in: Dar | bool | float | None = None, keep_ar: bool | None = None,
    # `linear` and `sigmoid` from LinearScaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> vs.VideoNode:
    width, height = Scaler._wh_norm(clip, width, height)
    return super().scale(
        clip, width, height, shift,
        border_handling=border_handling, sample_grid_model=sample_grid_model,
        sar=sar, dar=dar, dar_in=dar_in, keep_ar=keep_ar,
        linear=linear, sigmoid=sigmoid,
        **kwargs
    )

def scale_function(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None, *args: Any, **kwargs: Any
) -> vs.VideoNode:

    if not hasattr(core, 'resize2'):
        raise DependencyNotFoundError(
            self.__class__, 'resize2', 'Missing dependency \'resize2\'! '
            'You can find it here: https://github.com/Jaded-Encoding-Thaumaturgy/vapoursynth-resize2'
        )

    kernel, support = self._modify_kernel_func(kwargs)

    clean_kwargs = {
        k: v for k, v in kwargs.items()
        if k not in Signature.from_callable(self._modify_kernel_func).parameters.keys()
    }

    return core.resize2.Custom(clip, kernel, ceil(support), width, height, *args, **clean_kwargs)

@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)