Skip to content

abstract

Classes:

  • Descaler –

    Abstract descaling interface.

  • Kernel –

    Abstract kernel interface.

  • Resampler –

    Abstract resampling interface.

  • Scaler –

    Abstract scaling interface.

Attributes:

BaseScalerT module-attribute 

BaseScalerT = TypeVar('BaseScalerT', bound=BaseScaler)

DescalerT module-attribute 

DescalerT = Union[str, type[Descaler], Descaler]

KernelT module-attribute 

KernelT = Union[str, type[Kernel], Kernel]

ResamplerT module-attribute 

ResamplerT = Union[str, type[Resampler], Resampler]

ScalerT module-attribute 

ScalerT = Union[str, type[Scaler], Scaler]

abstract_kernels module-attribute 

abstract_kernels: list[BaseScalerMeta] = []

partial_abstract_kernels module-attribute 

partial_abstract_kernels: list[BaseScalerMeta] = []

BaseScaler 

BaseScaler(**kwargs: Any)

Bases: vs_object, ABC

Base abstract scaling interface.

Methods:

Attributes:

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
201
202
203
204
205
206
207
208
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
192
193
194
195
196
197
198
199
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

BaseScalerMeta

Bases: ABCMeta

Descaler 

Descaler(**kwargs: Any)

Bases: BaseScaler

Abstract descaling interface.

Methods:

Attributes:

  • descale_function (Callable[..., ConstantFormatVideoNode]) –

    Descale function called internally when descaling

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

descale_function instance-attribute 

descale_function: Callable[..., ConstantFormatVideoNode]

Descale function called internally when descaling

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

descale 

descale(
    clip: VideoNode,
    width: int | None,
    height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None, height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    width, height = self._wh_norm(clip, width, height)

    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs |= dict(border_handling=BorderHandling.from_param(border_handling, self.descale))

    if field_based.is_inter:
        shift_y, shift_x = self._shift_norm(shift, False, self.descale)

        kwargs_tf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[0], shift_x[0]), **kwargs)
        kwargs_bf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[1], shift_x[1]), **kwargs)

        de_kwargs_tf = self.get_descale_args(clip, (shift_y[0], shift_x[0]), *de_base_args, **kwargs_tf)
        de_kwargs_bf = self.get_descale_args(clip, (shift_y[1], shift_x[1]), *de_base_args, **kwargs_bf)

        if height % 2:
            raise CustomIndexError('You can\'t descale to odd resolution when crossconverted!', self.descale)

        field_shift = 0.125 * height / clip.height

        fields = clip.std.SeparateFields(field_based.is_tff)

        interleaved = core.std.Interleave([
            self.descale_function(fields[offset::2], **_norm_props_enums(
                de_kwargs | dict(src_top=de_kwargs.get('src_top', 0.0) + (field_shift * mult))
            ))
            for offset, mult, de_kwargs in [(0, 1, de_kwargs_tf), (1, -1, de_kwargs_bf)]
        ])

        descaled = interleaved.std.DoubleWeave(field_based.is_tff)[::2]
    else:
        shift = self._shift_norm(shift, True, self.descale)

        kwargs, shift = sample_grid_model.for_src(clip, width, height, shift, **kwargs)

        de_kwargs = self.get_descale_args(clip, shift, *de_base_args, **kwargs)

        descaled = self.descale_function(clip, **_norm_props_enums(de_kwargs))

    return depth(descaled, bits)

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
201
202
203
204
205
206
207
208
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
192
193
194
195
196
197
198
199
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_descale_args 

get_descale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            src_top=shift[0],
            src_left=shift[1]
        )
        | self.get_clean_kwargs(*funcs)
        | dict(width=width, height=height)
        | kwargs
    )

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
424
425
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.descale, )

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

Kernel 

Kernel(**kwargs: Any)

Bases: Scaler, Descaler, Resampler

Abstract kernel interface.

Methods:

Attributes:

  • descale_function (Callable[..., ConstantFormatVideoNode]) –

    Descale function called internally when descaling

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

  • resample_function (Callable[..., ConstantFormatVideoNode]) –

    Resample function called internally when resampling

  • scale_function (Callable[..., VideoNode]) –

    Scale function called internally when scaling

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

descale_function instance-attribute 

descale_function: Callable[..., ConstantFormatVideoNode]

Descale function called internally when descaling

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

resample_function instance-attribute 

resample_function: Callable[..., ConstantFormatVideoNode]

Resample function called internally when resampling

scale_function instance-attribute 

scale_function: Callable[..., VideoNode]

Scale function called internally when scaling

descale 

descale(
    clip: VideoNode,
    width: int | None,
    height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None, height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    width, height = self._wh_norm(clip, width, height)

    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs |= dict(border_handling=BorderHandling.from_param(border_handling, self.descale))

    if field_based.is_inter:
        shift_y, shift_x = self._shift_norm(shift, False, self.descale)

        kwargs_tf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[0], shift_x[0]), **kwargs)
        kwargs_bf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[1], shift_x[1]), **kwargs)

        de_kwargs_tf = self.get_descale_args(clip, (shift_y[0], shift_x[0]), *de_base_args, **kwargs_tf)
        de_kwargs_bf = self.get_descale_args(clip, (shift_y[1], shift_x[1]), *de_base_args, **kwargs_bf)

        if height % 2:
            raise CustomIndexError('You can\'t descale to odd resolution when crossconverted!', self.descale)

        field_shift = 0.125 * height / clip.height

        fields = clip.std.SeparateFields(field_based.is_tff)

        interleaved = core.std.Interleave([
            self.descale_function(fields[offset::2], **_norm_props_enums(
                de_kwargs | dict(src_top=de_kwargs.get('src_top', 0.0) + (field_shift * mult))
            ))
            for offset, mult, de_kwargs in [(0, 1, de_kwargs_tf), (1, -1, de_kwargs_bf)]
        ])

        descaled = interleaved.std.DoubleWeave(field_based.is_tff)[::2]
    else:
        shift = self._shift_norm(shift, True, self.descale)

        kwargs, shift = sample_grid_model.for_src(clip, width, height, shift, **kwargs)

        de_kwargs = self.get_descale_args(clip, shift, *de_base_args, **kwargs)

        descaled = self.descale_function(clip, **_norm_props_enums(de_kwargs))

    return depth(descaled, bits)

ensure_obj classmethod 

ensure_obj(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> Kernel

ensure_obj(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Scaler

ensure_obj(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Descaler

ensure_obj(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Resampler

ensure_obj(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScaler
Source code 
647
648
649
650
651
652
653
654
@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

from_param classmethod 

from_param(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> type[Kernel]

from_param(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Scaler]

from_param(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Descaler]

from_param(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Resampler]

from_param(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScaler]
Source code 
611
612
613
614
615
616
617
@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_descale_args 

get_descale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
673
674
675
676
677
678
679
680
681
682
683
@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(True, clip, width, height, **kwargs)
    )

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
701
702
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> KwargsT
Source code 
656
657
658
659
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> KwargsT:
    return dict(width=width, height=height) | kwargs

get_resample_args 

get_resample_args(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
661
662
663
664
665
666
667
668
669
670
671
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

resample 

resample(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
438
439
440
441
442
443
444
445
446
@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
243
244
245
246
247
248
249
250
251
252
253
254
255
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    width, height = Scaler._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    return self.scale_function(
        clip, **_norm_props_enums(self.get_scale_args(clip, shift, width, height, **kwargs))
    )

shift 

shift(
    clip: VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

Resampler 

Resampler(**kwargs: Any)

Bases: BaseScaler

Abstract resampling interface.

Methods:

Attributes:

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

  • resample_function (Callable[..., ConstantFormatVideoNode]) –

    Resample function called internally when resampling

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

resample_function instance-attribute 

resample_function: Callable[..., ConstantFormatVideoNode]

Resample function called internally when resampling

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
201
202
203
204
205
206
207
208
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
192
193
194
195
196
197
198
199
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
463
464
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.resample, )

get_resample_args 

get_resample_args(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
448
449
450
451
452
453
454
455
456
457
458
459
460
461
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | kwargs
    )

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

resample 

resample(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
438
439
440
441
442
443
444
445
446
@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

Scaler 

Scaler(**kwargs: Any)

Bases: BaseScaler

Abstract scaling interface.

Methods:

Attributes:

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

  • scale_function (Callable[..., VideoNode]) –

    Scale function called internally when scaling

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function instance-attribute 

scale_function: Callable[..., VideoNode]

Scale function called internally when scaling

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
201
202
203
204
205
206
207
208
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
192
193
194
195
196
197
198
199
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
299
300
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.supersample)

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            src_top=shift[0],
            src_left=shift[1]
        )
        | self.get_clean_kwargs(*funcs)
        | dict(width=width, height=height)
        | kwargs
    )

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
243
244
245
246
247
248
249
250
251
252
253
254
255
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    width, height = Scaler._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    return self.scale_function(
        clip, **_norm_props_enums(self.get_scale_args(clip, shift, width, height, **kwargs))
    )

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)