color ¶

def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

    return vs.core.std.SetFrameProp(clip, self.prop_key, self.value)

@classmethod
def ensure_presence(cls, clip: VideoNodeT, value: int | Self | None, func: FuncExceptT | None = None) -> VideoNodeT:
    """
    Ensure the presence of the property in the VideoNode.
    """

    enum_value = cls.from_param_or_video(value, clip, True, func)

    return vs.core.std.SetFrameProp(clip, enum_value.prop_key, enum_value.value)

@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnumT] | PropEnumT], func: FuncExceptT | None = None
) -> VideoNodeT:
    """
    Ensure the presence of multiple PropEnums at once.
    """

    return vs.core.std.SetFrameProps(
        clip,
        **{
            value.prop_key: value.value
            for value in [
                cls if isinstance(cls, PropEnum) else cls.from_video(clip, True, func) for cls in prop_enums
            ]
        },
    )

@classmethod
def from_param(cls, value: Any, func_except: Any = None) -> Self | None:
    """
    Determine the ColorRange through a parameter.

    Args:
        value: Value or ColorRange object.
        func_except: Function returned for custom error handling. This should only be set by VS package
            developers.

    Returns:
        ColorRange object or None.
    """

@classmethod
def from_param_or_video(
    cls,
    value: int | ColorRange | ColorRangeT | None,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False,
    func_except: FuncExceptT | None = None,
) -> ColorRange: ...

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> ColorRange:
    """
    Guess the color range from the frame resolution.
    """

    from ..utils import get_var_infos

    fmt, _, _ = get_var_infos(frame)

    if fmt.color_family == vs.RGB:
        return cls.FULL

    return cls.LIMITED

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> ColorRange:
    """
    Obtain the color range of a clip from the frame properties.

    Args:
        src: Input clip, frame, or props.
        strict: Be strict about the frame properties. Sets the ColorRange as MISSING if prop is not there.

    Returns:
        ColorRange object.
    """

    return _base_from_video(cls, src, UnsupportedColorRangeError, strict, func)

@classmethod
def is_unknown(cls, value: int | Self) -> bool:
    """
    Whether the value represents an unknown value.
    """

    return False

@classmethod
def is_valid(cls, value: int) -> bool:
    """
    Check if the given value is a valid int value of this enum.
    """
    return int(value) in map(int, cls.__members__.values())

@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

    return vs.core.std.SetFrameProp(clip, self.prop_key, self.value)

@classmethod
def ensure_presence(cls, clip: VideoNodeT, value: int | Self | None, func: FuncExceptT | None = None) -> VideoNodeT:
    """
    Ensure the presence of the property in the VideoNode.
    """

    enum_value = cls.from_param_or_video(value, clip, True, func)

    return vs.core.std.SetFrameProp(clip, enum_value.prop_key, enum_value.value)

@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnumT] | PropEnumT], func: FuncExceptT | None = None
) -> VideoNodeT:
    """
    Ensure the presence of multiple PropEnums at once.
    """

    return vs.core.std.SetFrameProps(
        clip,
        **{
            value.prop_key: value.value
            for value in [
                cls if isinstance(cls, PropEnum) else cls.from_video(clip, True, func) for cls in prop_enums
            ]
        },
    )

@classmethod
def from_param(cls, value: Any, func_except: Any = None) -> Self | None:
    """
    Determine the Matrix through a parameter.

    Args:
        value: Value or Matrix object.
        func_except: Function returned for custom error handling.

    Returns:
        Matrix object or None.
    """

@classmethod
def from_param_or_video(
    cls,
    value: int | Matrix | MatrixT | None,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False,
    func_except: FuncExceptT | None = None,
) -> Matrix: ...

@classmethod
def from_primaries(cls, primaries: Primaries, strict: bool = False) -> Matrix:
    """
    Obtain the matrix from a Primaries object.

    Args:
        primaries: Primaries object.
        strict: Be strict about the primaries-matrix mapping. Will ALWAYS error with Primaries.UNKNOWN.

    Returns:
        Matrix object.

    Raises:
        UnsupportedPrimariesError: Primaries is not supported.
    """

    if primaries not in _primaries_matrix_map:
        if strict:
            raise UnsupportedPrimariesError(f"{primaries} is not supported!", cls.from_primaries)

        return cls(primaries.value)

    return _primaries_matrix_map[primaries]

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> Matrix:
    """
    Guess the matrix based on the clip's resolution.

    Args:
        frame: Input clip or frame.

    Returns:
        Matrix object.
    """

    from ..utils import get_var_infos

    fmt, width, height = get_var_infos(frame)

    if fmt.color_family == vs.RGB:
        return Matrix.RGB

    if width <= 1024 and height <= 576:
        if height > 486:
            return Matrix.BT470BG

        return Matrix.SMPTE170M

    return Matrix.BT709

@classmethod
def from_transfer(cls, transfer: Transfer, strict: bool = False) -> Matrix:
    """
    Obtain the matrix from a Transfer object.

    Args:
        transfer: Transfer object.
        strict: Be strict about the transfer-matrix mapping. Will ALWAYS error with Transfer.UNKNOWN.

    Returns:
        Matrix object.

    Raises:
        UnsupportedTransferError: Transfer is not supported.
    """

    if transfer not in _transfer_matrix_map:
        if strict:
            raise UnsupportedTransferError(f"{transfer} is not supported!", cls.from_transfer)

        return cls(transfer.value)

    return _transfer_matrix_map[transfer]

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> Matrix:
    """
    Obtain the matrix of a clip from the frame properties.

    Args:
        src: Input clip, frame, or props.
        strict: Be strict about the frame properties. Will ALWAYS error with Matrix.UNKNOWN.

    Returns:
        Matrix object.

    Raises:
        UndefinedMatrixError: Matrix is undefined.
        UndefinedMatrixError: Matrix can not be determined from the frameprops.
    """

    return _base_from_video(cls, src, UndefinedMatrixError, strict, func)

@classmethod
def is_unknown(cls, value: int | Matrix) -> bool:
    """
    Check if Matrix is Matrix.UNKNOWN.
    """

    return value == cls.UNKNOWN

@classmethod
def is_valid(cls, value: int) -> bool:
    """
    Check if the given value is a valid int value of this enum.
    """
    return int(value) in map(int, cls.__members__.values())

@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

@classproperty
@classmethod
def BT2020(cls) -> MatrixCoefficients:  # noqa: N802
    """
    Matrix Coefficients for BT2020.
    """

    return MatrixCoefficients(0.08145, 4.5, 0.0993, 2.22222)

@classproperty
@classmethod
def BT709(cls) -> MatrixCoefficients:  # noqa: N802
    """
    Matrix Coefficients for BT709.
    """

    return MatrixCoefficients(0.08145, 4.5, 0.0993, 2.22222)

@classproperty
@classmethod
def SMPTE240M(cls) -> MatrixCoefficients:  # noqa: N802
    """
    Matrix Coefficients for SMPTE240M.
    """

    return MatrixCoefficients(0.0912, 4.0, 0.1115, 2.22222)

@classproperty
@classmethod
def SRGB(cls) -> MatrixCoefficients:  # noqa: N802
    """
    Matrix Coefficients for SRGB.
    """

    return MatrixCoefficients(0.04045, 12.92, 0.055, 2.4)

@classmethod
def from_matrix(cls, matrix: Matrix) -> MatrixCoefficients:
    """
    Matrix Coefficients from a Matrix object's value.
    """

    if matrix not in _matrix_matrixcoeff_map:
        raise UnsupportedMatrixError(f"{matrix} is not supported!", cls.from_matrix)

    return _matrix_matrixcoeff_map[matrix]

@classmethod
def from_primaries(cls, primaries: Primaries) -> MatrixCoefficients:
    """
    Matrix Coefficients from a Primaries object's value.
    """

    if primaries not in _primaries_matrixcoeff_map:
        raise UnsupportedPrimariesError(f"{primaries} is not supported!", cls.from_primaries)

    return _primaries_matrixcoeff_map[primaries]

@classmethod
def from_transfer(cls, transfer: Transfer) -> MatrixCoefficients:
    """
    Matrix Coefficients from a Transfer object's value.
    """

    if transfer not in _transfer_matrixcoeff_map:
        raise UnsupportedTransferError(f"{transfer} is not supported!", cls.from_transfer)

    return _transfer_matrixcoeff_map[transfer]

def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

    return vs.core.std.SetFrameProp(clip, self.prop_key, self.value)

@classmethod
def ensure_presence(cls, clip: VideoNodeT, value: int | Self | None, func: FuncExceptT | None = None) -> VideoNodeT:
    """
    Ensure the presence of the property in the VideoNode.
    """

    enum_value = cls.from_param_or_video(value, clip, True, func)

    return vs.core.std.SetFrameProp(clip, enum_value.prop_key, enum_value.value)

@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnumT] | PropEnumT], func: FuncExceptT | None = None
) -> VideoNodeT:
    """
    Ensure the presence of multiple PropEnums at once.
    """

    return vs.core.std.SetFrameProps(
        clip,
        **{
            value.prop_key: value.value
            for value in [
                cls if isinstance(cls, PropEnum) else cls.from_video(clip, True, func) for cls in prop_enums
            ]
        },
    )

@classmethod
def from_libplacebo(cls, val: int) -> int:
    """
    Obtain the primaries from libplacebo.
    """

    return _placebo_primaries_map[val]

@classmethod
def from_matrix(cls, matrix: Matrix, strict: bool = False) -> Primaries:
    """
    Obtain the primaries from a Matrix object.

    Args:
        matrix: Matrix object.
        strict: Be strict about the matrix-primaries mapping. Will ALWAYS error with Matrix.UNKNOWN.

    Returns:
        Primaries object.

    Raises:
        UnsupportedMatrixError: Matrix is not supported.
    """

    if matrix not in _matrix_primaries_map:
        if strict:
            raise UnsupportedMatrixError(f"{matrix} is not supported!", cls.from_matrix)

        return cls(matrix.value)

    return _matrix_primaries_map[matrix]

@classmethod
def from_param(cls, value: Any, func_except: Any = None) -> Self | None:
    """
    Determine the Primaries through a parameter.

    Args:
        value: Value or Primaries object.
        func_except: Function returned for custom error handling. This should only be set by VS package
            developers.

    Returns:
        Primaries object or None.
    """

@classmethod
def from_param_or_video(
    cls,
    value: int | Primaries | PrimariesT | None,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False,
    func_except: FuncExceptT | None = None,
) -> Primaries: ...

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> Primaries:
    """
    Guess the primaries based on the clip's resolution.

    Args:
        frame: Input clip or frame.

    Returns:
        Primaries object.
    """

    from ..utils import get_var_infos

    fmt, width, height = get_var_infos(frame)

    if fmt.color_family == vs.RGB:
        return Primaries.BT709

    if width <= 1024 and height <= 576:
        if height > 486:
            return Primaries.BT470BG

        return Primaries.SMPTE170M

    return Primaries.BT709

@classmethod
def from_transfer(cls, transfer: Transfer, strict: bool = False) -> Primaries:
    """
    Obtain the primaries from a Transfer object.

    Args:
        transfer: Transfer object.
        strict: Be strict about the transfer-primaries mapping. Will ALWAYS error with Transfer.UNKNOWN.

    Returns:
        Matrix object.

    Raises:
        UnsupportedTransferError: Transfer is not supported.
    """

    if transfer not in _transfer_primaries_map:
        if strict:
            raise UnsupportedTransferError(f"{transfer} is not supported!", cls.from_transfer)

        return cls(transfer.value)

    return _transfer_primaries_map[transfer]

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> Primaries:
    """
    Obtain the primaries of a clip from the frame properties.

    Args:
        src: Input clip, frame, or props.
        strict: Be strict about the frame properties. Will ALWAYS error with Primaries.UNKNOWN.

    Returns:
        Primaries object.

    Raises:
        UndefinedPrimariesError: Primaries is undefined.
        UndefinedPrimariesError: Primaries can not be determined from the frame properties.
    """

    return _base_from_video(cls, src, UndefinedPrimariesError, strict, func)

@classmethod
def is_unknown(cls, value: int | Primaries) -> bool:
    """
    Check if Primaries is unknown.
    """

    return value == cls.UNKNOWN

@classmethod
def is_valid(cls, value: int) -> bool:
    """
    Check if the given value is a valid int value of this enum.
    """
    return int(value) in map(int, cls.__members__.values())

@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

    return vs.core.std.SetFrameProp(clip, self.prop_key, self.value)

@classmethod
def ensure_presence(cls, clip: VideoNodeT, value: int | Self | None, func: FuncExceptT | None = None) -> VideoNodeT:
    """
    Ensure the presence of the property in the VideoNode.
    """

    enum_value = cls.from_param_or_video(value, clip, True, func)

    return vs.core.std.SetFrameProp(clip, enum_value.prop_key, enum_value.value)

@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnumT] | PropEnumT], func: FuncExceptT | None = None
) -> VideoNodeT:
    """
    Ensure the presence of multiple PropEnums at once.
    """

    return vs.core.std.SetFrameProps(
        clip,
        **{
            value.prop_key: value.value
            for value in [
                cls if isinstance(cls, PropEnum) else cls.from_video(clip, True, func) for cls in prop_enums
            ]
        },
    )