funcs ¶

@cachedproperty
def chroma_planes(self) -> list[vs.VideoNode]:
    """
    Get a list of all chroma planes in the normalised clip.
    """

    if self != [0] or self.norm_clip.format.num_planes == 1:
        return []

    return [plane(self.norm_clip, i) for i in (1, 2)]

@cachedproperty
def chromaloc(self) -> ChromaLocation:
    """
    Get the clip's chroma location.
    """

    return ChromaLocation.from_param_or_video(self._chromaloc, self.clip, True, self.func)

@cachedproperty
def color_range(self) -> ColorRange:
    """
    Get the clip's color range.
    """

    return ColorRange.from_param_or_video(self._range_in, self.clip, True, self.func)

@cachedproperty
def matrix(self) -> Matrix:
    """
    Get the clip's matrix.
    """

    return Matrix.from_param_or_video(self._matrix, self.clip, True, self.func)

@cachedproperty
def norm_clip(self) -> ConstantFormatVideoNode:
    """
    Get a "normalized" clip. This means color space and bitdepth are converted if necessary.
    """

    if isinstance(self.bitdepth, (range, set)) and self.clip.format.bits_per_sample not in self.bitdepth:
        from .. import get_depth

        src_depth = get_depth(self.clip)
        target_depth = next((bits for bits in self.bitdepth if bits >= src_depth), max(self.bitdepth))

        clip = depth(self.clip, target_depth)
    elif isinstance(self.bitdepth, int):
        clip = depth(self.clip, self.bitdepth)
    else:
        clip = self.clip

    assert check_variable(clip, self.func)

    cfamily = clip.format.color_family

    if not self.allowed_cfamilies or cfamily in self.allowed_cfamilies:
        return clip

    if cfamily is vs.RGB:
        if not self._matrix:
            raise UndefinedMatrixError(
                "You must specify a matrix for RGB to {} conversions!".format(
                    "/".join(cf.name for cf in sorted(self.allowed_cfamilies, key=lambda x: x.name))
                ),
                self.func,
            )

        self.cfamily_converted = True

        clip = clip.resize.Bicubic(format=clip.format.replace(color_family=vs.YUV).id, matrix=self._matrix)

    elif (
        cfamily in (vs.YUV, vs.GRAY) and not set(self.allowed_cfamilies) & {vs.YUV, vs.GRAY}
    ) or self.planes not in (0, [0]):
        self.cfamily_converted = True

        clip = clip.resize.Bicubic(
            format=clip.format.replace(color_family=vs.RGB, subsampling_h=0, subsampling_w=0).id,
            matrix_in=self._matrix,
            chromaloc_in=self._chromaloc,
            range_in=self._range_in.value_zimg if self._range_in else None,
        )

        InvalidColorspacePathError.check(self.func, clip)

    return clip

def norm_seq(self, seq: T | Sequence[T], null: T) -> list[T]:
    """
    Normalize a value or sequence to a list mapped to the clip's planes.
    Unprocessed planes will be set to the given "null" value.
    """

    return [x if i in self else null for i, x in enumerate(normalize_seq(seq, self.num_planes))]

def normalize_planes(self, planes: PlanesT) -> list[int]:
    """
    Normalize the given sequence of planes.
    """

    return normalize_planes(self.work_clip, planes)

@cachedproperty
def order(self) -> FieldBased:
    """
    Get the clip's field order.
    """

    return FieldBased.from_param_or_video(self._order, self.clip, True, self.func)

@cachedproperty
def primaries(self) -> Primaries:
    """
    Get the clip's primaries.
    """

    return Primaries.from_param_or_video(self._primaries, self.clip, True, self.func)

def return_clip(self, processed: vs.VideoNode) -> ConstantFormatVideoNode:
    """
    Merge back the chroma if necessary and convert the processed clip back to the original clip's format.
    If `bitdepth != None`, the bitdepth will also be converted if necessary.

    Args:
        processed: The clip with all the processing applied to it.

    Returns:
        Processed clip converted back to the original input clip's format.
    """

    assert check_variable(processed, self.func)

    if len(self.chroma_planes):
        processed = join([processed, *self.chroma_planes], self.norm_clip.format.color_family)

    if self.chroma_only:
        processed = join(self.norm_clip, processed)

    if self.bitdepth:
        processed = depth(processed, self.clip)

    if self.cfamily_converted:
        processed = processed.resize.Bicubic(
            format=self.clip.format.id,
            matrix=self.matrix if self.norm_clip.format.color_family is vs.RGB else None,
            chromaloc=self.chromaloc,
            range=self.color_range.value_zimg,
        )

    return processed

@cachedproperty
def transfer(self) -> Transfer:
    """
    Get the clip's transfer.
    """

    return Transfer.from_param_or_video(self._transfer, self.clip, True, self.func)

def with_planes(self, planes: PlanesT) -> list[int]:
    return self.normalize_planes(sorted(set(self + self.normalize_planes(planes))))

def without_planes(self, planes: PlanesT) -> list[int]:
    return self.normalize_planes(sorted(set(self) - {*self.normalize_planes(planes)}))

@cachedproperty
def work_clip(self) -> ConstantFormatVideoNode:
    """
    Get the "work clip" as specified from the input planes.
    """

    return plane(self.norm_clip, 0) if self.luma_only else self.norm_clip