deblock ¶

def deblock_qed(
    clip: vs.VideoNode,
    quant: tuple[int | None, int | None] = (24, 26),
    alpha: tuple[int | None, int | None] = (1, 1),
    beta: tuple[int | None, int | None] = (2, 2),
    chroma_mode: int = 0,
    planes: PlanesT = None,
) -> ConstantFormatVideoNode:
    """
    A post-processed deblock. Uses full frequencies of Deblock's changes on block borders, but DCT-lowpassed changes on
    block interiors. Designed to provide 8x8 deblocking sensitive to the amount of blocking in the source, compared to
    other deblockers which apply a uniform deblocking across every frame.

    Args:
        clip: Clip to process.
        quant: Strength of the deblocking. Tuple for (border, interior) values.
        alpha: Both a sensitivity and strength modifier. Tuple for (border, interior) values.
        beta: Sensitivity to detect blocking. Tuple for (border, interior) values.
        chroma_mode: Chroma deblocking behaviour.

               - 0 = Use proposed method for chroma deblocking.
               - 1 = Directly use chroma deblock from the normal deblock.
               - 2 = Directly use chroma deblock from the strong deblock.

        planes: Planes to process.

    Returns:
        Deblocked clip
    """
    assert check_variable(clip, deblock_qed)

    planes_pp = 0 if chroma_mode else planes

    normal, strong = (
        clip.deblock.Deblock(quant[0], alpha[0], beta[0], planes),
        clip.deblock.Deblock(quant[1], alpha[1], beta[1], planes),
    )

    mask = norm_expr(
        clip[0],
        "Y 8 % 7 % X 8 % 7 % and 0 255 ?",
        planes_pp,
        clip.format.replace(sample_type=vs.SampleType.INTEGER, bits_per_sample=8),
    )
    strong_diff = norm_expr([clip, strong, mask], "z x y - 1.01 * neutral + neutral ?", planes_pp)
    strong_pp = strong_diff.dctf.DCTFilter([1, 1, 0, 0, 0, 0, 0, 0], planes_pp)
    deblocked = norm_expr([clip, normal, strong_pp, mask], "a y x z neutral - - ?", planes_pp)

    if clip.format.color_family is not vs.GRAY:
        if chroma_mode == 1:
            deblocked = join(deblocked, normal)
        if chroma_mode == 2:
            deblocked = join(deblocked, strong)

    return deblocked

def dpir_mask(
    clip: vs.VideoNode,
    low: float = 5,
    high: float = 10,
    lines: float | None = None,
    luma_scaling: float = 12,
    linemask: GenericMaskT | bool = True,
    relative: bool = False,
) -> vs.VideoNode:
    y = depth(get_y(clip), 32)

    if linemask is True:
        linemask = FDoG

    mask = adg_mask(y, luma_scaling, relative, func=dpir_mask)

    if relative:
        mask = gauss_blur(mask, 1.5)

    mask = norm_expr(mask, f"{high} 255 / x {low} 255 / * -", func=dpir_mask)

    if linemask:
        lines = fallback(lines, high)
        linemask = normalize_mask(linemask, y)

        lines_clip = mask.std.BlankClip(color=lines / 255)

        mask = mask.std.MaskedMerge(lines_clip, linemask)

    return mask

def mpeg2stinx(
    clip: vs.VideoNode,
    bobber: Deinterlacer = NNEDI3(),
    tff: bool = True,
    mask: bool = True,
    radius: int | tuple[int, int] = 2,
    limit: float | None = 1.0,
) -> ConstantFormatVideoNode:
    """
    This filter is designed to eliminate certain combing-like compression artifacts that show up all too often
    in hard-telecined MPEG-2 encodes, and works to a smaller extent on bitrate-starved hard-telecined AVC as well.
    General artifact removal is better accomplished with actual denoisers.

    Args:
        clip: Clip to process.
        tff: The field order.
        mask: Whether to use BWDIF motion masking.
        bobber: Callable to use in place of the internal deinterlacing filter.
        radius: x, y radius of min-max clipping (i.e. repair) to remove artifacts.
        limit: If specified, temporal limiting is used, where the changes by crossfieldrepair are limited to this times
            the difference between the current frame and its neighbours.

    Returns:
        Clip with cross-field noise reduced.
    """

    def _crossfield_repair(clip: vs.VideoNode, bobbed: vs.VideoNode) -> vs.VideoNode:
        clip = core.std.Interleave([clip] * 2)

        if sw == 1 and sh == 1:
            repaired = repair(clip, bobbed, 1)
        else:
            inpand, expand = Morpho.inpand(bobbed, sw, sh), Morpho.expand(bobbed, sw, sh)
            repaired = MeanMode.MEDIAN([clip, inpand, expand])

        return repaired.std.SeparateFields(tff).std.SelectEvery(4, (2, 1)).std.DoubleWeave(tff)[::2]

    def _temporal_limit(src: vs.VideoNode, flt: vs.VideoNode, adj: vs.VideoNode | None) -> vs.VideoNode:
        if limit is None:
            return flt

        assert adj

        diff = norm_expr([core.std.Interleave([src] * 2), adj], "x y - abs", func=mpeg2stinx).std.SeparateFields(tff)
        diff = MeanMode.MINIMUM([diff.std.SelectEvery(4, (0, 1)), diff.std.SelectEvery(4, (2, 3))])
        diff = Morpho.expand(diff, sw=2, sh=1).std.DoubleWeave(tff)[::2]

        return norm_expr([flt, src, diff], "z {limit} * LIM! x y LIM@ - y LIM@ + clip", limit=limit, func=mpeg2stinx)

    def _bobfunc(clip: vs.VideoNode) -> vs.VideoNode:
        bobbed = bobber.bob(clip)

        if mask:
            bobbed = BWDIF(tff=tff, edeint=bobbed).bob(clip)

        return bobbed

    assert check_variable(clip, mpeg2stinx)
    assert check_progressive(clip, mpeg2stinx)

    sw, sh = normalize_seq(radius, 2)
    bobber = bobber.copy(tff=tff)

    if limit is not None:
        adjs = shift_clip_multi(clip)
        adjs.pop(1)
        adj = core.std.Interleave(adjs)
    else:
        adj = None

    fixed1 = _temporal_limit(clip, _crossfield_repair(clip, _bobfunc(clip)), adj)
    fixed2 = _temporal_limit(fixed1, _crossfield_repair(fixed1, _bobfunc(fixed1)), adj)

    return core.std.SetFieldBased(fixed1.std.Merge(fixed2), FieldBased.PROGRESSIVE)