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.

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

    :return:                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.

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

    :return:                            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
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.

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

    :return:                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.

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

    :return:                                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.

    :param frame:       Input clip or frame.

    :return:            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.

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

    :return:                                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.

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

    :return:                            Matrix object.

    :raises UndefinedMatrixError:       Matrix is undefined.
    :raises 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
def prop_key(cls) -> str:
    """The key used in props to store the enum."""

    return f'_{cls.__name__}'

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

    return MatrixCoefficients(0.08145, 4.5, 0.0993, 2.22222)

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

    return MatrixCoefficients(0.08145, 4.5, 0.0993, 2.22222)

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

    return MatrixCoefficients(0.0912, 4.0, 0.1115, 2.22222)

@classproperty
def SRGB(cls) -> MatrixCoefficients:
    """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.

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

    :return:                                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.

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

    :return:                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.

    :param frame:       Input clip or frame.

    :return:            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.

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

    :return:                                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.

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

    :return:                            Primaries object.

    :raises UndefinedPrimariesError:    Primaries is undefined.
    :raises 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
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:
    """Get the enum member from its int representation."""