misc ¶

def color(
    self,
    clip: vs.VideoNode,
    color: float | MissingT | Sequence[float | MissingT | None] | None = (False, MISSING),
) -> vs.VideoNode:
    """
    Pad a clip with a constant color.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.COLOR(left=3, color=Z)
        >>> ZZZ|ABCDE
        ```

    Args:
        clip: Input clip.
        color: Constant color that should be added on the sides:

               * number: This will be treated as such and not converted or clamped.
               * False: Lowest value for this clip format and color range.
               * True: Highest value for this clip format and color range.
               * None: Neutral value for this clip format.
               * MISSING: Automatically set to False if RGB, else None.

    Returns:
        Padded clip with colored borders.
    """
    self._get_values(clip)

    def _norm(colr: float | bool | MissingT | None) -> Sequence[float]:
        if colr is MISSING:
            colr = False if clip.format.color_family is vs.RGB else None

        if colr is False:
            return get_lowest_values(clip, clip)

        if colr is True:
            return get_peak_values(clip, clip)

        if colr is None:
            return get_neutral_values(clip)

        return normalize_seq(colr, clip.format.num_planes)

    if not isinstance(color, Sequence):
        norm_colors = _norm(color)
    else:
        norm_colors = [_norm(c)[i] for i, c in enumerate(normalize_seq(color, clip.format.num_planes))]

    return core.std.AddBorders(clip, self.left, self.right, self.top, self.bottom, norm_colors)

def crop(self, clip: vs.VideoNode, crop_scale: float | tuple[float, float] | None = None) -> vs.VideoNode:
    """
    Crop a clip with the padding values.

    Args:
        clip: Input clip.
        crop_scale: Optional scale factor for the padding values. If None, no scaling is applied.

    Returns:
        Cropped clip.
    """
    if crop_scale is None:
        crop_scale = (clip.width / self.padded_width, clip.height / self.padded_height)
    elif not isinstance(crop_scale, tuple):
        crop_scale = (crop_scale, crop_scale)

    left_pad, right_pad, top_pad, bottom_pad = tuple(crop_scale[0 if i < 2 else 1] for i in range(4))
    return clip.std.Crop(
        left=int(self.left * left_pad),
        right=int(self.right * right_pad),
        top=int(self.top * top_pad),
        bottom=int(self.bottom * bottom_pad),
    )

@classmethod
def from_mod(cls, clip: vs.VideoNode, mod: int = 16, min: int = 4, align: Align = Align.MIDDLE_CENTER) -> Self:
    """
    Initialize Padder based on modulus constraints of a clip.

    Args:
        clip: Input clip to calculate mod padding for.
        mod: Modulus value (e.g. 16).
        min: Minimum padding required.
        align: Align option.

    Returns:
        Padder instance with calculated padding values and input clip size.
    """
    return cls(*cls.mod_padding(clip, mod, min, align), clip.width, clip.height)

def mirror(self, clip: vs.VideoNode) -> vs.VideoNode:
    """
    Pad a clip with reflect mode. This will reflect the clip on each side.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.MIRROR(left=3)
        >>> CBA|ABCDE
        ```

    Args:
        clip: Input clip.

    Returns:
        Padded clip with reflected borders.
    """
    width, height, *_ = self._get_values(clip)

    return (
        clip.std.RemoveFrameProps()
        .resize.Point(
            width,
            height,
            src_top=-self.top,
            src_left=-self.left,
            src_width=width,
            src_height=height,
        )
        .std.CopyFrameProps(clip)
    )

@classmethod
def mod_padding(
    cls,
    sizes: tuple[int, int] | vs.VideoNode,
    mod: int = 16,
    min: int = 4,
    align: Align = Align.MIDDLE_CENTER,
) -> tuple[int, int, int, int]:
    """
    Calculate required padding to make clip dimensions divisible by modulus.

    Args:
        sizes: Width and height tuple or a VideoNode.
        mod: Modulus value (e.g. 16).
        min: Minimum padding required.
        align: Align option.

    Returns:
        A tuple of left, right, top, bottom padding values.
    """
    if isinstance(sizes, vs.VideoNode):
        sizes = (sizes.width, sizes.height)

    ph, pv = (mod - (((x + min * 2) - 1) % mod + 1) for x in sizes)
    left, top = floor(ph / 2), floor(pv / 2)
    left, right, top, bottom = tuple(x + min for x in (left, ph - left, top, pv - top))

    if align & Align.TOP:
        bottom += top
        top = 0
    elif align & Align.BOTTOM:
        top += bottom
        bottom = 0

    if align & Align.LEFT:
        right += left
        left = 0
    elif align & Align.RIGHT:
        left += right
        right = 0

    return left, right, top, bottom

@classmethod
def mod_padding_crop(
    cls,
    sizes: tuple[int, int] | vs.VideoNode,
    mod: int = 16,
    min: int = 4,
    crop_scale: float | tuple[float, float] = 2,
    align: Align = Align.MIDDLE_CENTER,
) -> tuple[tuple[int, int, int, int], tuple[int, int, int, int]]:
    """
    Calculate mod padding and its corresponding cropped padding.

    Args:
        sizes: Width and height tuple or a VideoNode.
        mod: Modulus value (e.g. 16).
        min: Minimum padding required.
        crop_scale: Crop scale factor.
        align: Align option.

    Returns:
        A tuple containing padding tuple and scaled crop padding tuple.
    """
    if not isinstance(crop_scale, tuple):
        crop_scale = (crop_scale, crop_scale)
    padding = cls.mod_padding(sizes, mod, min, align)
    return padding, tuple(int(pad * crop_scale[0 if i < 2 else 1]) for i, pad in enumerate(padding))  # type: ignore[return-value]

def repeat(self, clip: vs.VideoNode) -> vs.VideoNode:
    """
    Pad a clip with repeat mode. This will simply repeat the last row/column till the end.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.REPEAT(left=3)
        >>> AAA|ABCDE
        ```

    Args:
        clip: Input clip.

    Returns:
        Padded clip with repeated borders.
    """
    *_, fmt, w_sub, h_sub = self._get_values(clip)

    padded = clip.std.AddBorders(self.left, self.right, self.top, self.bottom)

    right_idx, bottom_idx = clip.width + self.left, clip.height + self.top

    pads = [
        (self.left, right_idx, self.top, bottom_idx),
        (self.left // w_sub, right_idx // w_sub, self.top // h_sub, bottom_idx // h_sub),
    ][: fmt.num_planes]

    return padded.akarin.Expr(
        [
            """
            X {left} < L! Y {top} < T! X {right} > R! Y {bottom} > B!

            T@ B@ or L@ R@ or and
                L@
                    T@ {left} {top}  x[] {left} {bottom} x[] ?
                    T@ {right} {top} x[] {right} {bottom} x[] ?
                ?
                L@
                    {left} Y x[]
                    R@
                        {right} Y x[]
                        T@
                            X {top} x[]
                            B@
                                X {bottom} x[]
                                x
                            ?
                        ?
                    ?
                ?
            ?
        """.format(left=l_, right=r_ - 1, top=t_, bottom=b_ - 1)
            for l_, r_, t_, b_ in pads
        ]
    )

@staticmethod
def COLOR(
    clip: vs.VideoNode,
    left: int = 0,
    right: int = 0,
    top: int = 0,
    bottom: int = 0,
    color: float | MissingT | Sequence[float | MissingT | None] | None = (False, MISSING),
) -> vs.VideoNode:
    """
    Pad a clip with a constant color.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.COLOR(left=3, color=Z)
        >>> ZZZ|ABCDE
        ```

    Args:
        clip: Input clip.
        left: Padding added to the left side of the clip.
        right: Padding added to the right side of the clip.
        top: Padding added to the top side of the clip.
        bottom: Padding added to the bottom side of the clip.
        color: Constant color that should be added on the sides:

               * number: This will be treated as such and not converted or clamped.
               * False: Lowest value for this clip format and color range.
               * True: Highest value for this clip format and color range.
               * None: Neutral value for this clip format.
               * MISSING: Automatically set to False if RGB, else None.

    Returns:
        Padded clip with colored borders.
    """
    return Padder(left, right, top, bottom).color(clip, color)

@staticmethod
def MIRROR(clip: vs.VideoNode, left: int = 0, right: int = 0, top: int = 0, bottom: int = 0) -> vs.VideoNode:
    """
    Pad a clip with reflect mode. This will reflect the clip on each side.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.MIRROR(left=3)
        >>> CBA|ABCDE
        ```

    Args:
        clip: Input clip.
        left: Padding added to the left side of the clip.
        right: Padding added to the right side of the clip.
        top: Padding added to the top side of the clip.
        bottom: Padding added to the bottom side of the clip.

    Returns:
        Padded clip with reflected borders.
    """
    return Padder(left, right, top, bottom).mirror(clip)

@staticmethod
def REPEAT(clip: vs.VideoNode, left: int = 0, right: int = 0, top: int = 0, bottom: int = 0) -> vs.VideoNode:
    """
    Pad a clip with repeat mode. This will simply repeat the last row/column till the end.

    Visual example:
        ```
        >>> |ABCDE
        >>> padder.REPEAT(left=3)
        >>> AAA|ABCDE
        ```

    Args:
        clip: Input clip.
        left: Padding added to the left side of the clip.
        right: Padding added to the right side of the clip.
        top: Padding added to the top side of the clip.
        bottom: Padding added to the bottom side of the clip.

    Returns:
        Padded clip with repeated borders.
    """
    return Padder(left, right, top, bottom).repeat(clip)

def COLOR(self, clip: vs.VideoNode, color: float | Sequence[float | None] | None = (False, None)) -> vs.VideoNode:
    """
    Pad a clip with a constant color.

    Args:
        clip: Input clip.
        color: Constant color that should be added on the sides:

               * number: This will be treated as such and not converted or clamped.
               * False: Lowest value for this clip format and color range.
               * True: Highest value for this clip format and color range.
               * None: Neutral value for this clip format.
               * MISSING: Automatically set to False if RGB, else None.

    Returns:
        Padded clip with colored borders.
    """
    padding = Padder.mod_padding(clip, self.mod, self.min, self.align)
    pad = Padder(*padding, clip.width, clip.height)
    out = pad.color(clip, color)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out

def CROP(self, clip: vs.VideoNode, crop_scale: float | tuple[float, float] | None = None) -> vs.VideoNode:
    """
    Crop a clip with the padding values.

    Args:
        clip: Input clip.
        crop_scale: Optional scale factor for the padding values. If None, no scaling is applied.

    Returns:
        Cropped clip.
    """
    (padding, sizes) = self.pad_ops.pop(0)

    input_width = sizes[0] - padding[0] - padding[1]
    input_height = sizes[1] - padding[2] - padding[3]
    pad = Padder(padding[0], padding[1], padding[2], padding[3], input_width, input_height)
    return pad.crop(clip, crop_scale)

def MIRROR(self, clip: vs.VideoNode) -> vs.VideoNode:
    """
    Pad a clip with reflect mode. This will reflect the clip on each side.

    Args:
        clip: Input clip.

    Returns:
        Padded clip with reflected borders.
    """
    padding = Padder.mod_padding(clip, self.mod, self.min, self.align)
    pad = Padder(*padding, clip.width, clip.height)
    out = pad.mirror(clip)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out

def REPEAT(self, clip: vs.VideoNode) -> vs.VideoNode:
    """
    Pad a clip with repeat mode. This will simply repeat the last row/column till the end.

    Args:
        clip: Input clip.

    Returns:
        Padded clip with repeated borders.
    """
    padding = Padder.mod_padding(clip, self.mod, self.min, self.align)
    pad = Padder(*padding, clip.width, clip.height)
    out = pad.repeat(clip)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out