f3kdb ¶

@deprecated('"F3kdb.deband" is deprecated, use "f3k_deband" instead.', category=DeprecationWarning)
@inject_self
def deband(  # type: ignore[override]
    self,
    clip: vs.VideoNode,
    radius: int = 16,
    thr: int | list[int] = 96,
    grain: float | list[float] = 0.0,
    sample_mode: SampleMode | SampleModeMidDiffInfo = SampleMode.SQUARE,
    dynamic_grain: bool = False,
    blur_first: bool | None = None,
    seed: int | None = None,
    random: RandomAlgoT | tuple[RandomAlgoT, RandomAlgoT] = RandomAlgo.UNIFORM,
    planes: PlanesT = None,
    _func: FuncExceptT | None = None,
) -> vs.VideoNode:
    """
    Args:
        clip: Input clip.
        radius: Banding detection range.
        thr: Banding detection threshold for respective plane. If difference between current pixel and reference
            pixel is less than threshold, it will be considered as banded
        grain: Specifies amount of grains added in the last debanding stage.
        sample_mode: Determines how pixels are taken as reference.
        dynamic_grain: Use different grain pattern for each frame.
        blur_first: If True current pixel is compared with average value of all pixels. If False current pixel is
            compared with all pixels. The pixel is considered as banded pixel only if all differences are less than
            threshold.
        seed: Seed for random number generation
        random: Random number algorithm for reference positions / grains.
        planes: Which planes to process.
    """
    func = FunctionUtil(clip, _func or self.deband, planes, (vs.GRAY, vs.YUV), (8, 16))

    if not hasattr(core, "neo_f3kdb"):
        raise CustomRuntimeError("You are missing the neo_f3kdb plugin!", func.func)

    if "y_2" not in core.neo_f3kdb.Deband.__signature__.parameters:  # type: ignore
        raise CustomRuntimeError("You are using an outdated version of neo_f3kdb, upgrade now!", func.func)

    radius = fallback(self.radius, radius)

    y, cb, cr = normalize_seq(fallback(self.thr, thr), 3)
    gry, grc = normalize_seq(fallback(self.grain, grain), 2)

    sample_mode = fallback(self.sample_mode, sample_mode)

    random_ref, random_grain = normalize_seq(random, 2)

    if isinstance(random_ref, RandomAlgoWithInfo):
        random_algo_ref = int(random_ref)
        random_param_ref = random_ref.sigma
    else:
        random_algo_ref = int(random_ref)
        random_param_ref = 1.0

    if isinstance(random_grain, RandomAlgoWithInfo):
        random_algo_grain = int(random_grain)
        random_param_grain = random_grain.sigma
    else:
        random_algo_grain = int(random_grain)
        random_param_grain = 1.0

    y1 = cb1 = cr1 = y2 = cb2 = cr2 = None

    if isinstance(sample_mode, SampleModeMidDiffInfo):
        y1, cb1, cr1 = func.norm_seq(sample_mode.thr_max, 0)
        y2, cb2, cr2 = func.norm_seq(sample_mode.thr_mid, 0)
        sample_mode = sample_mode.sample_mode

    blur_first = fallback(self.blur_first or blur_first, max(y, cb, cr) < 2048)

    debanded = core.neo_f3kdb.Deband(
        func.work_clip,
        radius,
        y,
        cb,
        cr,
        round(gry * 255 * 0.8),
        round(grc * 255 * 0.8),
        sample_mode.value,
        self.seed or seed,
        blur_first,
        self.dynamic_grain or dynamic_grain,
        None,
        None,
        None,
        False,
        16,
        random_algo_ref,
        random_algo_grain,
        random_param_ref,
        random_param_grain,
        None,
        y1,
        cb1,
        cr1,
        y2,
        cb2,
        cr2,
        True,
    )

    return func.return_clip(debanded)

def __call__(self, *args: Any) -> Any:
    if self != RandomAlgo.GAUSSIAN:
        return TypeError

    return RandomAlgoWithInfo(self, *args)

def __call__(self, *args: Any) -> Any:
    if self != SampleMode.MEAN_DIFF:
        raise TypeError

    return SampleModeMidDiffInfo(self, *args)