abstract ¶

def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

def draa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    original_field = int(self.field)

    self.field = 0
    aa0 = super()._do_aa(clip, y, x, **kwargs)

    self.field = 1
    aa1 = super()._do_aa(clip, y, x, **kwargs)

    self.field = original_field

    return self.merge_func(aa0, aa1)

def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for anti-aliasing processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

def get_ss_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for super sampling processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

@abstractmethod
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    """
    Performs field interpolation.

    :param clip:        Clip to interpolate.
    :param double_y:    If True, doubles the height of the input by copying each line to every other line of the output,
                        with the missing lines interpolated.
                        If field is 0, the input is copied to the odd lines (bottom field).
                        if field is 1, the input is copied to the even lines (top field).
    :param **kwargs:    Additional keyword arguments to pass to the interpolation plugin.
    :return:            Interpolated clip.
    """

@inject_self.cached
def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    """
    Scale the given clip using super sampling method.

    :param clip:        The input clip to be scaled.
    :param width:       The target width for scaling. If None, the width of the input clip will be used.
    :param height:      The target height for scaling. If None, the height of the input clip will be used.
    :param shift:       A tuple representing the shift values for the y and x axes.
    :param **kwargs:    Additional arguments to be passed to the `interpolate` or `full_interpolate` methods.

    :return:            The scaled clip.
    """
    assert check_progressive(clip, self.scale)

    clip = self._preprocess_clip(clip)
    width, height = self._wh_norm(clip, width, height)

    if (clip.width, clip.height) == (width, height):
        return clip

    kwargs = self.get_aa_args(clip, **kwargs) | self.get_ss_args(clip, **kwargs) | kwargs

    divw, divh = (ceil(size) for size in (width / clip.width, height / clip.height))

    mult_x, mult_y = (int(log2(divs)) for divs in (divw, divh))

    cdivw, cdivh = 1 << clip.format.subsampling_w, 1 << clip.format.subsampling_h

    upscaled = clip

    def _transpose(before: bool, is_width: int, y: int, x: int) -> None:
        nonlocal upscaled

        before = self.transpose_first if before else not self.transpose_first

        if ((before or not y) if is_width else (before and x)):
            upscaled = upscaled.std.Transpose()

    for (y, x) in zip_longest([True] * mult_y, [True] * mult_x, fillvalue=False):
        if isinstance(self, _FullInterpolate) and self.is_full_interpolate_enabled(x, y):
            upscaled = self.full_interpolate(upscaled, y, x, **kwargs)
        else:
            for isx, val in enumerate([y, x]):
                if val:
                    _transpose(True, isx, y, x)

                    upscaled = self.interpolate(upscaled, True, **kwargs)

                    _transpose(False, isx, y, x)

        topshift = leftshift = cleftshift = ctopshift = 0.0

        if y and self._shift:
            topshift = ctopshift = self._shift

            if cdivw == 2 and cdivh == 2:
                ctopshift -= 0.125
            elif cdivw == 1 and cdivh == 2:
                ctopshift += 0.125

        cresshift = 0.0

        if x and self._shift:
            leftshift = cleftshift = self._shift

            if cdivw in {4, 2} and cdivh in {4, 2, 1}:
                cleftshift = self._shift + 0.5

                if cdivw == 4 and cdivh == 1:
                    cresshift = 0.125 * 1
                elif cdivw == 2 and cdivh == 2:
                    cresshift = 0.125 * 2
                elif cdivw == 2 and cdivh == 1:
                    cresshift = 0.125 * 3

                cleftshift -= cresshift

        if isinstance(self._shifter, NoShift):
            if upscaled.format.subsampling_h or upscaled.format.subsampling_w:
                upscaled = Catrom.shift(upscaled, 0, [0, cleftshift + cresshift])
        else:
            upscaled = self._shifter.shift(
                upscaled, [topshift, ctopshift], [leftshift, cleftshift]
            )

    return self._scaler.scale(upscaled, width, height, shift)

def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

def draa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    original_field = int(self.field)

    self.field = 0
    aa0 = super()._do_aa(clip, y, x, **kwargs)

    self.field = 1
    aa1 = super()._do_aa(clip, y, x, **kwargs)

    self.field = original_field

    return self.merge_func(aa0, aa1)

def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for anti-aliasing processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

@abstractmethod
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    """
    Performs field interpolation.

    :param clip:        Clip to interpolate.
    :param double_y:    If True, doubles the height of the input by copying each line to every other line of the output,
                        with the missing lines interpolated.
                        If field is 0, the input is copied to the odd lines (bottom field).
                        if field is 1, the input is copied to the even lines (top field).
    :param **kwargs:    Additional keyword arguments to pass to the interpolation plugin.
    :return:            Interpolated clip.
    """

def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for anti-aliasing processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

@abstractmethod
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    """
    Performs field interpolation.

    :param clip:        Clip to interpolate.
    :param double_y:    If True, doubles the height of the input by copying each line to every other line of the output,
                        with the missing lines interpolated.
                        If field is 0, the input is copied to the odd lines (bottom field).
                        if field is 1, the input is copied to the even lines (top field).
    :param **kwargs:    Additional keyword arguments to pass to the interpolation plugin.
    :return:            Interpolated clip.
    """

def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for anti-aliasing processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

@abstractmethod
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    """
    Performs field interpolation.

    :param clip:        Clip to interpolate.
    :param double_y:    If True, doubles the height of the input by copying each line to every other line of the output,
                        with the missing lines interpolated.
                        If field is 0, the input is copied to the odd lines (bottom field).
                        if field is 1, the input is copied to the even lines (top field).
    :param **kwargs:    Additional keyword arguments to pass to the interpolation plugin.
    :return:            Interpolated clip.
    """

def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for anti-aliasing processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

def get_ss_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for super sampling processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

@abstractmethod
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    """
    Performs field interpolation.

    :param clip:        Clip to interpolate.
    :param double_y:    If True, doubles the height of the input by copying each line to every other line of the output,
                        with the missing lines interpolated.
                        If field is 0, the input is copied to the odd lines (bottom field).
                        if field is 1, the input is copied to the even lines (top field).
    :param **kwargs:    Additional keyword arguments to pass to the interpolation plugin.
    :return:            Interpolated clip.
    """

@inject_self.cached
def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    """
    Scale the given clip using super sampling method.

    :param clip:        The input clip to be scaled.
    :param width:       The target width for scaling. If None, the width of the input clip will be used.
    :param height:      The target height for scaling. If None, the height of the input clip will be used.
    :param shift:       A tuple representing the shift values for the y and x axes.
    :param **kwargs:    Additional arguments to be passed to the `interpolate` or `full_interpolate` methods.

    :return:            The scaled clip.
    """
    assert check_progressive(clip, self.scale)

    clip = self._preprocess_clip(clip)
    width, height = self._wh_norm(clip, width, height)

    if (clip.width, clip.height) == (width, height):
        return clip

    kwargs = self.get_aa_args(clip, **kwargs) | self.get_ss_args(clip, **kwargs) | kwargs

    divw, divh = (ceil(size) for size in (width / clip.width, height / clip.height))

    mult_x, mult_y = (int(log2(divs)) for divs in (divw, divh))

    cdivw, cdivh = 1 << clip.format.subsampling_w, 1 << clip.format.subsampling_h

    upscaled = clip

    def _transpose(before: bool, is_width: int, y: int, x: int) -> None:
        nonlocal upscaled

        before = self.transpose_first if before else not self.transpose_first

        if ((before or not y) if is_width else (before and x)):
            upscaled = upscaled.std.Transpose()

    for (y, x) in zip_longest([True] * mult_y, [True] * mult_x, fillvalue=False):
        if isinstance(self, _FullInterpolate) and self.is_full_interpolate_enabled(x, y):
            upscaled = self.full_interpolate(upscaled, y, x, **kwargs)
        else:
            for isx, val in enumerate([y, x]):
                if val:
                    _transpose(True, isx, y, x)

                    upscaled = self.interpolate(upscaled, True, **kwargs)

                    _transpose(False, isx, y, x)

        topshift = leftshift = cleftshift = ctopshift = 0.0

        if y and self._shift:
            topshift = ctopshift = self._shift

            if cdivw == 2 and cdivh == 2:
                ctopshift -= 0.125
            elif cdivw == 1 and cdivh == 2:
                ctopshift += 0.125

        cresshift = 0.0

        if x and self._shift:
            leftshift = cleftshift = self._shift

            if cdivw in {4, 2} and cdivh in {4, 2, 1}:
                cleftshift = self._shift + 0.5

                if cdivw == 4 and cdivh == 1:
                    cresshift = 0.125 * 1
                elif cdivw == 2 and cdivh == 2:
                    cresshift = 0.125 * 2
                elif cdivw == 2 and cdivh == 1:
                    cresshift = 0.125 * 3

                cleftshift -= cresshift

        if isinstance(self._shifter, NoShift):
            if upscaled.format.subsampling_h or upscaled.format.subsampling_w:
                upscaled = Catrom.shift(upscaled, 0, [0, cleftshift + cresshift])
        else:
            upscaled = self._shifter.shift(
                upscaled, [topshift, ctopshift], [leftshift, cleftshift]
            )

    return self._scaler.scale(upscaled, width, height, shift)

def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter