funcs ¶

def __call__(
    self, clip: vs.VideoNode, color: float | Sequence[float] = 0.0, planes: PlanesT = None
) -> ConstantFormatVideoNode:
    """
    Give a mathematically perfect solution to decombing fades made *after* telecine
    (which made perfect IVTC impossible) that start or end in a solid color.

    Steps between the frames are not adjusted, so they will remain uneven depending on the telecine pattern,
    but the decombing is blur-free, ensuring minimum information loss. However, this may cause small amounts
    of combing to remain due to error amplification, especially near the solid-color end of the fade.

    This is an improved version of the Fix-Telecined-Fades plugin.

    Make sure to run this *after* IVTC!

    Args:
        clip: Clip to process.
        color: Fade source/target color (floating-point plane averages). Accepts a single float or a sequence of
            floats to control the color per plane.

    Returns:
        Clip with fades to/from `color` accurately deinterlaced. Frames that don't contain such fades may be
        damaged.
    """

    func = FunctionUtil(clip, self.__class__, planes, vs.YUV, 32)

    fields = limiter(func.work_clip).std.SeparateFields(tff=True)

    fields = norm_expr(fields, "x {color} - abs", planes, color=color, func=self.__class__)
    for i in func.norm_planes:
        fields = fields.std.PlaneStats(None, i, f"P{i}")

    props_clip = core.akarin.PropExpr(
        [func.work_clip, fields[::2], fields[1::2]],
        lambda: {f"f{f}Avg{i}": f"{c}.P{i}Average" for f, c in zip("tb", "yz") for i in func.norm_planes},
    )

    expr = (
        "Y 2 % x.fbAvg{i} x.ftAvg{i} ? AVG! "
        "AVG@ x {color} - x.ftAvg{i} x.fbAvg{i} {expr_mode} AVG@ / * {color} + x ?"
    )

    fix = norm_expr(
        props_clip,
        expr,
        planes,
        i=func.norm_planes,
        color=color,
        expr_mode="+ 2 /" if self == self.AVERAGE else "min",
        func=self.__class__,
    )

    return func.return_clip(fix)

def __call__(
    self,
    clip: vs.VideoNode,
    pattern: int,
    vectors: MotionVectors | None = None,
    preset: MVToolsPreset = MVToolsPreset.HQ_COHERENCE,
    blksize: int | tuple[int, int] = 8,
    refine: int = 1,
    thsad_recalc: int | None = None,
    export_globals: bool = False,
) -> ConstantFormatVideoNode | tuple[ConstantFormatVideoNode, MVTools]:
    """
    Virtually oversamples the video to 120 fps with motion interpolation on credits only, and decimates to 24 fps.
    Requires manually specifying the 3:2 pulldown pattern (the clip must be split into parts if it changes).

    Args:
        clip: Bob-deinterlaced clip.
        vectors: Motion vectors to use.
        pattern: First frame of any clean-combed-combed-clean-clean sequence.
        preset: MVTools preset defining base values for the MVTools object. Default is HQ_COHERENCE.
        blksize: Size of a block. Larger blocks are less sensitive to noise, are faster, but also less accurate.
        refine: Number of times to recalculate motion vectors with halved block size.
        thsad_recalc: Only bad quality new vectors with a SAD above this will be re-estimated by search. thsad value
            is scaled to 8x8 block size.
        export_globals: Whether to return the MVTools object.

    Returns:
        Decimated clip with text resampled down to 24p.
    """

    def _floor_div_tuple(x: tuple[int, int]) -> tuple[int, int]:
        return x[0] // 2, x[1] // 2

    assert check_variable(clip, self.__class__)

    step, lookup = self.value
    offset = lookup[pattern % 5]
    offsets = [(offset + i * step) % 40 for i in range(4)]

    blksize = blksize if isinstance(blksize, tuple) else (blksize, blksize)

    mv = MVTools(clip, vectors=vectors, **preset | KwargsT(search_clip=partial(prefilter_to_full_range, slope=1)))

    if not vectors:
        mv.analyze(tr=1, blksize=blksize, overlap=_floor_div_tuple(blksize))

        for _ in range(refine):
            blksize = _floor_div_tuple(blksize)
            overlap = _floor_div_tuple(blksize)

        mv.recalculate(thsad=thsad_recalc, blksize=blksize, overlap=overlap)

    comp = mv.flow_interpolate(multi=4)
    fixed = core.std.SelectEvery(comp, 40, sorted(offsets))

    return (fixed, mv) if export_globals else fixed