deinterlacers ¶

def antialias(self, clip: vs.VideoNode, direction: AADirection = AADirection.BOTH, **kwargs: Any) -> vs.VideoNode:
    """
    Apply anti-aliasing to the given clip.

    Args:
        clip: The input clip.
        direction: Direction in which to apply anti-aliasing. Defaults to AADirection.BOTH.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Anti-aliased clip.
    """
    tff = fallback(kwargs.pop("tff", self.tff), True)

    for y in sorted(self.AADirection, key=lambda x: x.value, reverse=self.transpose_first):
        if direction in (y, self.AADirection.BOTH):
            if y == self.AADirection.HORIZONTAL:
                clip, tclips = self.transpose(clip, **kwargs)
                kwargs |= tclips

            clip = self._interpolate(clip, tff, self.double_rate, False, **kwargs)

            if self.double_rate:
                clip = core.std.Merge(clip[::2], clip[1::2])

            if y == self.AADirection.HORIZONTAL:
                clip, tclips = self.transpose(clip, **kwargs)
                kwargs |= tclips

    return clip

def bob(self, clip: vs.VideoNode, *, tff: FieldBasedLike | bool | None = None, **kwargs: Any) -> vs.VideoNode:
    """
    Apply bob deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, True, False, **kwargs)

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

def deinterlace(
    self,
    clip: vs.VideoNode,
    *,
    tff: FieldBasedLike | bool | None = None,
    double_rate: bool | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        double_rate: Whether to double the frame rate (True) or retain the original rate (False).
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, fallback(double_rate, self.double_rate), False, **kwargs)

@abstractmethod
def get_deint_args(self, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for deinterlacing processing.

    Args:
        **kwargs: Additional arguments.

    Returns:
        Passed keyword arguments.
    """
    return kwargs

def transpose(self, clip: vs.VideoNode, **kwargs: Any) -> tuple[vs.VideoNode, Mapping[str, vs.VideoNode | None]]:
    """
    Transpose the input clip by swapping its horizontal and vertical axes.

    Args:
        clip: The input clip.

    Returns:
        The transposed clip.
    """
    return clip.std.Transpose(), {}

def bob(self, clip: vs.VideoNode, *, tff: FieldBasedLike | bool | None = None, **kwargs: Any) -> vs.VideoNode:
    """
    Apply bob deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, True, False, **kwargs)

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

def deinterlace(
    self,
    clip: vs.VideoNode,
    *,
    tff: FieldBasedLike | bool | None = None,
    double_rate: bool | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        double_rate: Whether to double the frame rate (True) or retain the original rate (False).
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, fallback(double_rate, self.double_rate), False, **kwargs)

def get_deint_args(self, **kwargs: Any) -> dict[str, Any]:
    return {"edeint": self.edeint} | kwargs

def bob(self, clip: vs.VideoNode, *, tff: FieldBasedLike | bool | None = None, **kwargs: Any) -> vs.VideoNode:
    """
    Apply bob deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, True, False, **kwargs)

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

def deinterlace(
    self,
    clip: vs.VideoNode,
    *,
    tff: FieldBasedLike | bool | None = None,
    double_rate: bool | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        double_rate: Whether to double the frame rate (True) or retain the original rate (False).
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, fallback(double_rate, self.double_rate), False, **kwargs)

@abstractmethod
def get_deint_args(self, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for deinterlacing processing.

    Args:
        **kwargs: Additional arguments.

    Returns:
        Passed keyword arguments.
    """
    return kwargs

def antialias(
    self, clip: vs.VideoNode, direction: AntiAliaser.AADirection = AntiAliaser.AADirection.BOTH, **kwargs: Any
) -> vs.VideoNode:
    kwargs = self.get_deint_args(**kwargs)

    sclip, mclip = kwargs.pop("sclip"), kwargs.pop("mclip")

    if isinstance(sclip, Deinterlacer):
        raise CustomValueError("sclip must be a callable or VideoNode", self.antialias)

    if sclip and self.double_rate:
        if isinstance(sclip, VSFunctionNoArgs):
            sclip = sclip(clip)

        sclip = core.std.Interleave([sclip, sclip])

    if isinstance(mclip, VSFunctionNoArgs):
        mclip = mclip(clip)

    return super().antialias(clip, direction, sclip=sclip, mclip=mclip, **kwargs)

def bob(self, clip: vs.VideoNode, *, tff: FieldBasedLike | bool | None = None, **kwargs: Any) -> vs.VideoNode:
    kwargs = self.get_deint_args(**kwargs)

    sclip, mclip = kwargs.pop("sclip"), kwargs.pop("mclip")

    if isinstance(sclip, Deinterlacer):
        sclip = sclip.bob(clip, tff=tff)

    if callable(sclip):
        sclip = sclip(clip)

    if callable(mclip):
        mclip = mclip(clip)

    return super().bob(clip, tff=tff, sclip=sclip, mclip=mclip, **kwargs)

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

def deinterlace(
    self,
    clip: vs.VideoNode,
    *,
    tff: FieldBasedLike | bool | None = None,
    double_rate: bool | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    kwargs = self.get_deint_args(**kwargs)

    sclip, mclip = kwargs.pop("sclip"), kwargs.pop("mclip")

    if isinstance(sclip, Deinterlacer):
        sclip = sclip.deinterlace(clip, tff=tff, double_rate=double_rate)

    if callable(sclip):
        sclip = sclip(clip)

    if callable(mclip):
        mclip = mclip(clip)

    return super().deinterlace(clip, tff=tff, double_rate=double_rate, sclip=sclip, mclip=mclip, **kwargs)

def get_deint_args(self, **kwargs: Any) -> dict[str, Any]:
    vthresh = (None, None, None) if self.vthresh is None else self.vthresh

    return {
        "alpha": self.alpha,
        "beta": self.beta,
        "gamma": self.gamma,
        "nrad": self.nrad,
        "mdis": self.mdis,
        "ucubic": self.ucubic,
        "cost3": self.cost3,
        "vcheck": self.vcheck,
        "vthresh0": vthresh[0],
        "vthresh1": vthresh[1],
        "vthresh2": vthresh[2],
        "sclip": self.sclip,
        "mclip": self.mclip,
    } | kwargs

@Scaler.cachedproperty
def kernel_radius(self) -> int:
    return self.mdis

def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any,
) -> vs.VideoNode:
    kwargs = self.get_deint_args(**kwargs)

    if kwargs["sclip"] or kwargs["mclip"]:
        raise CustomNotImplementedError("sclip and mclip are currently not supported.", self.scale)

    return super().scale(clip, width, height, shift, **kwargs)

def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    """
    Supersample a clip by a given scaling factor.

    Note: Setting `tff=True` results in less chroma shift for non-centered chroma locations.

    Args:
        clip: The source clip.
        rfactor: Scaling factor for supersampling.
        shift: Subpixel shift (top, left) applied during scaling.
        **kwargs: Additional arguments forwarded to the scale function.

    Raises:
        CustomValueError: If resulting resolution is non-positive.

    Returns:
        The supersampled clip.
    """
    ...

def transpose(
    self,
    clip: vs.VideoNode,
    *,
    sclip: vs.VideoNode | None = None,
    mclip: vs.VideoNode | None = None,
    **kwargs: Any,
) -> tuple[vs.VideoNode, Mapping[str, vs.VideoNode | None]]:
    # At this point, sclip and mclip can only be a VideoNode or None
    if isinstance(sclip, vs.VideoNode):
        sclip = sclip.std.Transpose()

    if isinstance(mclip, vs.VideoNode):
        mclip = mclip.std.Transpose()

    return clip.std.Transpose(), kwargs | {"sclip": sclip, "mclip": mclip}

def antialias(self, clip: vs.VideoNode, direction: AADirection = AADirection.BOTH, **kwargs: Any) -> vs.VideoNode:
    """
    Apply anti-aliasing to the given clip.

    Args:
        clip: The input clip.
        direction: Direction in which to apply anti-aliasing. Defaults to AADirection.BOTH.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Anti-aliased clip.
    """
    tff = fallback(kwargs.pop("tff", self.tff), True)

    for y in sorted(self.AADirection, key=lambda x: x.value, reverse=self.transpose_first):
        if direction in (y, self.AADirection.BOTH):
            if y == self.AADirection.HORIZONTAL:
                clip, tclips = self.transpose(clip, **kwargs)
                kwargs |= tclips

            clip = self._interpolate(clip, tff, self.double_rate, False, **kwargs)

            if self.double_rate:
                clip = core.std.Merge(clip[::2], clip[1::2])

            if y == self.AADirection.HORIZONTAL:
                clip, tclips = self.transpose(clip, **kwargs)
                kwargs |= tclips

    return clip

def bob(self, clip: vs.VideoNode, *, tff: FieldBasedLike | bool | None = None, **kwargs: Any) -> vs.VideoNode:
    """
    Apply bob deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, True, False, **kwargs)

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

def deinterlace(
    self,
    clip: vs.VideoNode,
    *,
    tff: FieldBasedLike | bool | None = None,
    double_rate: bool | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply deinterlacing to the given clip.

    Args:
        clip: The input clip.
        tff: Field order of the clip.
        double_rate: Whether to double the frame rate (True) or retain the original rate (False).
        **kwargs: Additional arguments passed to the plugin function.

    Returns:
        Deinterlaced clip.
    """
    field_based = FieldBased.from_param_or_video(fallback(tff, self.tff, default=None), clip, True, self.__class__)

    return self._interpolate(clip, field_based.is_tff, fallback(double_rate, self.double_rate), False, **kwargs)

def get_deint_args(self, *, clip: vs.VideoNode | None = None, **kwargs: Any) -> dict[str, Any]:
    pscrn = (
        fallback(self.pscrn, 1 if self.opencl or clip.format.sample_type is vs.FLOAT else 4) if clip else self.pscrn
    )

    return {
        "nsize": self.nsize,
        "nns": self.nns,
        "qual": self.qual,
        "etype": self.etype,
        "pscrn": pscrn,
    } | kwargs

@Scaler.cachedproperty
def kernel_radius(self) -> int:
    match self.nsize:
        case 0 | 4:
            return 8
        case 1 | 5:
            return 16
        case 3:
            return 48
        case _:
            return 32

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.

    Note: Setting `tff=True` results in less chroma shift for non-centered chroma locations.

    Args:
        clip: The source clip.
        width: Target width (defaults to clip width if None).
        height: Target height (defaults to clip height if None).
        shift: Subpixel shift (top, left) applied during scaling.
        **kwargs: Additional arguments forwarded to the deinterlacing function.

    Returns:
        The scaled clip.
    """
    tff_fallback = fallback(kwargs.pop("tff", self.tff), True)

    dims = self._wh_norm(clip, width, height)
    dest_dimensions = list(dims)
    sy, sx = shift
    in_width, in_height = clip.width, clip.height

    cloc = list(ChromaLocation.from_video(clip).get_offsets(clip))
    subsampling = [2**clip.format.subsampling_w, 2**clip.format.subsampling_h]

    nshift: list[list[float]] = [
        normalize_seq(sx, clip.format.num_planes),
        normalize_seq(sy, clip.format.num_planes),
    ]

    if not self.transpose_first:
        dest_dimensions.reverse()
        cloc.reverse()
        subsampling.reverse()
        nshift.reverse()

    for x, dim in enumerate(dest_dimensions):
        is_width = (not x and self.transpose_first) or (not self.transpose_first and x)

        if is_width:
            clip, _ = self.transpose(clip)

        while clip.height < dim:
            delta = max(nshift[x], key=lambda y: abs(y))
            tff = False if delta < 0 else True if delta > 0 else tff_fallback
            offset = -0.25 if tff else 0.25

            for y in range(clip.format.num_planes):
                if not y:
                    nshift[x][y] = (nshift[x][y] + offset) * 2
                else:
                    nshift[x][y] = (nshift[x][y] + offset) * 2 - cloc[x] / subsampling[x]

            clip = self._interpolate(clip, tff, False, True, **kwargs)

        if is_width:
            clip, _ = self.transpose(clip)

    if not self.transpose_first:
        nshift.reverse()

    self._ss_shifts = nshift

    if self.noshift:
        noshift = normalize_seq(self.noshift, clip.format.num_planes)

        if all(noshift) and dims == (clip.width, clip.height):
            return clip

        for ns in nshift:
            for i in range(len(ns)):
                ns[i] *= not noshift[i]

    sar_scale = Fraction(clip.height // in_height, clip.width // in_width)

    return ComplexScaler.ensure_obj(self.scaler, self.__class__).scale(
        clip, width, height, (nshift[1], nshift[0]), _sar_scale=sar_scale
    )