Skip to content

color

Classes:

Attributes:

ColorRangeLike module-attribute

ColorRangeLike: TypeAlias = int | ColorRange | ColorRange | HoldsPropValue

Type alias for values that can be used to initialize a ColorRange.

ColorRangeT module-attribute

ColorRangeT = ColorRangeLike

Deprecated alias of ColorRangeLike

MatrixLike module-attribute

MatrixLike: TypeAlias = int | MatrixCoefficients | Matrix | HoldsPropValue

Type alias for values that can be used to initialize a Matrix.

MatrixT module-attribute

MatrixT = MatrixLike

Deprecated alias of MatrixLike

PrimariesLike module-attribute

PrimariesLike: TypeAlias = int | ColorPrimaries | Primaries | HoldsPropValue

Type alias for values that can be used to initialize a Primaries.

PrimariesT module-attribute

PrimariesT = PrimariesLike

Deprecated alias of PrimariesLike

TransferLike module-attribute

TransferLike: TypeAlias = (
    int | TransferCharacteristics | Transfer | HoldsPropValue
)

Type alias for values that can be used to initialize a Transfer.

TransferT module-attribute

TransferT = TransferLike

Deprecated alias of TransferLike

ColorRange

Bases: PropEnum

Pixel Range (ITU-T H.265 Equations E-10 through E-20.

Methods:

  • apply

    Applies the property to the VideoNode.

  • ensure_presence

    Ensure the presence of the property in the VideoNode.

  • ensure_presences

    Ensure the presence of multiple PropEnums at once.

  • from_param

    Determine the ColorRange through a parameter.

  • from_param_or_video
  • from_res

    Guess the color range from the frame resolution.

  • from_video

    Obtain the color range of a clip from the frame properties.

  • is_unknown

    Whether the value represents an unknown value.

  • is_valid

    Check if the given value is a valid int value of this enum.

  • prop_key

    The key used in props to store the enum.

Attributes:

  • FULL

    Full (PC) dynamic range, 0-255 in 8 bits.

  • LIMITED

    Studio (TV) legal range, 16-235 in 8 bits.

  • PC
  • TV
  • is_full (bool) –

    Check if ColorRange is full.

  • is_limited (bool) –

    Check if ColorRange is limited.

  • pretty_string (str) –

    Get a pretty, displayable string of the enum member.

  • string (str) –

    Get the string representation used in resize plugin/encoders.

  • value_vs (int) –

    VapourSynth (props) value.

  • value_zimg (int) –

    zimg (resize plugin) value.

FULL class-attribute instance-attribute

FULL = 0

Full (PC) dynamic range, 0-255 in 8 bits.

| Note that float clips should ALWAYS be FULL range! | RGB clips will ALWAYS be FULL range!

LIMITED class-attribute instance-attribute

LIMITED = 1

Studio (TV) legal range, 16-235 in 8 bits.

| This is primarily used with YUV integer formats.

PC class-attribute instance-attribute

PC = FULL

TV class-attribute instance-attribute

TV = LIMITED

is_full property

is_full: bool

Check if ColorRange is full.

is_limited property

is_limited: bool

Check if ColorRange is limited.

pretty_string property

pretty_string: str

Get a pretty, displayable string of the enum member.

string property

string: str

Get the string representation used in resize plugin/encoders.

value_vs property

value_vs: int

VapourSynth (props) value.

value_zimg property

value_zimg: int

zimg (resize plugin) value.

apply

apply(clip: VideoNodeT) -> VideoNodeT

Applies the property to the VideoNode.

Source code in vstools/enums/base.py
105
106
107
108
109
110
def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

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

ensure_presence classmethod

ensure_presence(
    clip: VideoNodeT,
    value: int | Self | None,
    /,
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of the property in the VideoNode.

Source code in vstools/enums/base.py
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@classmethod
def ensure_presence(
    cls, clip: VideoNodeT, value: int | Self | None, /, func: FuncExcept | 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)

ensure_presences staticmethod

ensure_presences(
    clip: VideoNodeT,
    prop_enums: Iterable[type[PropEnum] | PropEnum],
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of multiple PropEnums at once.

Source code in vstools/enums/base.py
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnum] | PropEnum], func: FuncExcept | 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 (
                prop_enum if isinstance(prop_enum, PropEnum) else prop_enum.from_video(clip, True, func)
                for prop_enum in prop_enums
            )
        },
    )

from_param classmethod

from_param(value: None, func_except: FuncExcept | None = None) -> None
from_param(
    value: ColorRangeLike, func_except: FuncExcept | None = None
) -> Self
from_param(
    value: ColorRangeLike | None, func_except: FuncExcept | None = None
) -> Self | None
from_param(value: Any, func_except: Any = None) -> Self | None

Determine the ColorRange through a parameter.

Parameters:

  • value

    (Any) –

    Value or ColorRange object.

  • func_except

    (Any, default: None ) –

    Function returned for custom error handling. This should only be set by VS package developers.

Returns:

  • Self | None

    ColorRange object or None.

Source code in vstools/enums/color.py
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
@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.
    """

from_param_or_video classmethod

from_param_or_video(
    value: ColorRangeLike | None,
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> ColorRange
Source code in vstools/enums/color.py
1203
1204
1205
1206
1207
1208
1209
1210
@classmethod
def from_param_or_video(
    cls,
    value: ColorRangeLike | None,
    src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> ColorRange: ...

from_res classmethod

from_res(frame: VideoNode | VideoFrame) -> ColorRange

Guess the color range from the frame resolution.

Source code in vstools/enums/color.py
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
@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

from_video classmethod

from_video(
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func: FuncExcept | None = None,
) -> ColorRange

Obtain the color range of a clip from the frame properties.

Parameters:

  • src

    (VideoNode | VideoFrame | Mapping[str, Any]) –

    Input clip, frame, or props.

  • strict

    (bool, default: False ) –

    Be strict about the frame properties. Sets the ColorRange as MISSING if prop is not there.

Returns:

Source code in vstools/enums/color.py
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any], strict: bool = False, func: FuncExcept | 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)

is_unknown classmethod

is_unknown(value: int | Self) -> bool

Whether the value represents an unknown value.

Source code in vstools/enums/base.py
21
22
23
24
25
26
27
@classmethod
def is_unknown(cls, value: int | Self) -> bool:
    """
    Whether the value represents an unknown value.
    """

    return False

is_valid classmethod

is_valid(value: int) -> bool

Check if the given value is a valid int value of this enum.

Source code in vstools/enums/base.py
148
149
150
151
152
153
@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())

prop_key classmethod

prop_key() -> str

The key used in props to store the enum.

Source code in vstools/enums/base.py
29
30
31
32
33
34
35
36
@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

Matrix

Bases: PropEnum

Matrix coefficients (ITU-T H.265 Table E.5).

Methods:

  • apply

    Applies the property to the VideoNode.

  • ensure_presence

    Ensure the presence of the property in the VideoNode.

  • ensure_presences

    Ensure the presence of multiple PropEnums at once.

  • from_param

    Determine the Matrix through a parameter.

  • from_param_or_video
  • from_primaries

    Obtain the matrix from a Primaries object.

  • from_res

    Guess the matrix based on the clip's resolution.

  • from_transfer

    Obtain the matrix from a Transfer object.

  • from_video

    Obtain the matrix of a clip from the frame properties.

  • is_unknown

    Check if Matrix is Matrix.UNKNOWN.

  • is_valid

    Check if the given value is a valid int value of this enum.

  • prop_key

    The key used in props to store the enum.

Attributes:

BT2020CL class-attribute instance-attribute

BT2020CL = 10

KR = 0.2627; KB = 0.0593
Rec. ITU-R BT.2020-2 constant luminance system See ITU-T H.265 Equations E-49 to E-58

BT2020NCL class-attribute instance-attribute

BT2020NCL = 9

KR = 0.2627; KB = 0.0593
Rec. ITU-R BT.2020-2 non-constant luminance system Rec. ITU-R BT.2100-2 Y'CbCr See ITU-T H.265 Equations E-28 to E-30

BT470BG class-attribute instance-attribute

BT470BG = 5

KR = 0.299; KB = 0.114
(Functionally the same as Matrix.SMPTE170M) Rec. ITU-R BT.470-6 System B, G (historical) Rec. ITU-R BT.601-7 625 Rec. ITU-R BT.1358-0 625 (historical) Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM IEC 61966-2-1 sYCC IEC 61966-2-4 xvYCC601 See ITU-T H.265 Equations E-28 to E-30

BT601_525 class-attribute instance-attribute

BT601_525 = SMPTE170M

BT601_625 class-attribute instance-attribute

BT601_625 = BT470BG

BT709 class-attribute instance-attribute

BT709 = 1

Kr = 0.2126; Kb = 0.0722
Rec. ITU-R BT.709-6 Rec. ITU-R BT.1361-0 conventional colour gamut system and extended colour gamut system (historical) IEC 61966-2-4 xvYCC709 SMPTE RP 177 (1993) Annex B

CHROMACL class-attribute instance-attribute

CHROMACL = 13

# See ITU-T H.265 Equations E-22 to E-27
Chromaticity-derived constant luminance system See ITU-T H.265 Equations E-49 to E-58

CHROMANCL class-attribute instance-attribute

CHROMANCL = 12

# See ITU-T H.265 Equations E-22 to E-27
Chromaticity-derived non-constant luminance system See ITU-T H.265 Equations E-28 to E-30

FCC class-attribute instance-attribute

FCC = 4

KR = 0.30; KB = 0.11
FCC Title 47 Code of Federal Regulations (2003) 73.682 (a) (20) See ITU-T H.265 Equations E-28 to E-30

GBR class-attribute instance-attribute

GBR = RGB

ICTCP class-attribute instance-attribute

ICTCP = 14

ICtCp
Rec. ITU-R BT.2100-2 ICTCP See ITU-T H.265 Equations E-62 to E-64 for transfer_characteristics value 16 (PQ) See ITU-T H.265 Equations E-65 to E-67 for transfer_characteristics value 18 (HLG)

RGB class-attribute instance-attribute

RGB = 0

# Identity
The identity matrix. Typically used for GBR (often referred to as RGB); however, may also be used for YZX (often referred to as XYZ) IEC 61966-2-1 sRGB SMPTE ST 428-1 (2006) See ITU-T H.265 Equations E-31 to E-33

SMPTE170M class-attribute instance-attribute

SMPTE170M = 6

Kr = 0.299; Kb = 0.114
(Functionally the same as Matrix.BT470BG) Rec. ITU-R BT.601-7 525 Rec. ITU-R BT.1358-1 525 or 625 (historical) Rec. ITU-R BT.1700-0 NTSC SMPTE ST 170 (2004) See ITU-T H.265 Equations E-28 to E-30

SMPTE240M class-attribute instance-attribute

SMPTE240M = 7

KR = 0.212; KB = 0.087
SMPTE ST 240 (1999, historical) See ITU-T H.265 Equations E-28 to E-30

UNKNOWN class-attribute instance-attribute

UNKNOWN = 2

Image characteristics are unknown or are determined by the application.

YCGCO class-attribute instance-attribute

YCGCO = 8

KR = 0.2126; KB = 0.0722
See Implementation And Evaluation Of Residual Color Transform For 4:4:4 RGB Lossless Coding

pretty_string property

pretty_string: str

string property

string: str

apply

apply(clip: VideoNodeT) -> VideoNodeT

Applies the property to the VideoNode.

Source code in vstools/enums/base.py
105
106
107
108
109
110
def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

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

ensure_presence classmethod

ensure_presence(
    clip: VideoNodeT,
    value: int | Self | None,
    /,
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of the property in the VideoNode.

Source code in vstools/enums/base.py
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@classmethod
def ensure_presence(
    cls, clip: VideoNodeT, value: int | Self | None, /, func: FuncExcept | 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)

ensure_presences staticmethod

ensure_presences(
    clip: VideoNodeT,
    prop_enums: Iterable[type[PropEnum] | PropEnum],
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of multiple PropEnums at once.

Source code in vstools/enums/base.py
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnum] | PropEnum], func: FuncExcept | 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 (
                prop_enum if isinstance(prop_enum, PropEnum) else prop_enum.from_video(clip, True, func)
                for prop_enum in prop_enums
            )
        },
    )

from_param classmethod

from_param(value: None, func_except: FuncExcept | None = None) -> None
from_param(value: MatrixLike, func_except: FuncExcept | None = None) -> Self
from_param(
    value: MatrixLike | None, func_except: FuncExcept | None = None
) -> Self | None
from_param(value: Any, func_except: Any = None) -> Self | None

Determine the Matrix through a parameter.

Parameters:

  • value

    (Any) –

    Value or Matrix object.

  • func_except

    (Any, default: None ) –

    Function returned for custom error handling.

Returns:

  • Self | None

    Matrix object or None.

Source code in vstools/enums/color.py
218
219
220
221
222
223
224
225
226
227
228
229
@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.
    """

from_param_or_video classmethod

from_param_or_video(
    value: MatrixLike | None,
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Matrix
Source code in vstools/enums/color.py
231
232
233
234
235
236
237
238
@classmethod
def from_param_or_video(
    cls,
    value: MatrixLike | None,
    src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Matrix: ...

from_primaries classmethod

from_primaries(primaries: Primaries, strict: bool = False) -> Matrix

Obtain the matrix from a Primaries object.

Parameters:

  • primaries

    (Primaries) –

    Primaries object.

  • strict

    (bool, default: False ) –

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

Returns:

Raises:

Source code in vstools/enums/color.py
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
@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]

from_res classmethod

from_res(frame: VideoNode | VideoFrame) -> Matrix

Guess the matrix based on the clip's resolution.

Parameters:

  • frame

    (VideoNode | VideoFrame) –

    Input clip or frame.

Returns:

Source code in vstools/enums/color.py
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
@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

from_transfer classmethod

from_transfer(transfer: Transfer, strict: bool = False) -> Matrix

Obtain the matrix from a Transfer object.

Parameters:

  • transfer

    (Transfer) –

    Transfer object.

  • strict

    (bool, default: False ) –

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

Returns:

Raises:

Source code in vstools/enums/color.py
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
@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]

from_video classmethod

from_video(
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func: FuncExcept | None = None,
) -> Matrix

Obtain the matrix of a clip from the frame properties.

Parameters:

  • src

    (VideoNode | VideoFrame | Mapping[str, Any]) –

    Input clip, frame, or props.

  • strict

    (bool, default: False ) –

    Be strict about the frame properties. Will ALWAYS error with Matrix.UNKNOWN.

Returns:

Raises:

Source code in vstools/enums/color.py
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any], strict: bool = False, func: FuncExcept | 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)

is_unknown classmethod

is_unknown(value: int | Matrix) -> bool

Check if Matrix is Matrix.UNKNOWN.

Source code in vstools/enums/color.py
240
241
242
243
244
245
246
@classmethod
def is_unknown(cls, value: int | Matrix) -> bool:
    """
    Check if Matrix is Matrix.UNKNOWN.
    """

    return value == cls.UNKNOWN

is_valid classmethod

is_valid(value: int) -> bool

Check if the given value is a valid int value of this enum.

Source code in vstools/enums/base.py
148
149
150
151
152
153
@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())

prop_key classmethod

prop_key() -> str

The key used in props to store the enum.

Source code in vstools/enums/base.py
29
30
31
32
33
34
35
36
@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

Primaries

Bases: PropEnum

Color primaries (ITU-T H.265 Table E.3).

Methods:

  • apply

    Applies the property to the VideoNode.

  • ensure_presence

    Ensure the presence of the property in the VideoNode.

  • ensure_presences

    Ensure the presence of multiple PropEnums at once.

  • from_libplacebo

    Obtain the primaries from libplacebo.

  • from_matrix

    Obtain the primaries from a Matrix object.

  • from_param

    Determine the Primaries through a parameter.

  • from_param_or_video
  • from_res

    Guess the primaries based on the clip's resolution.

  • from_transfer

    Obtain the primaries from a Transfer object.

  • from_video

    Obtain the primaries of a clip from the frame properties.

  • is_unknown

    Check if Primaries is unknown.

  • is_valid

    Check if the given value is a valid int value of this enum.

  • prop_key

    The key used in props to store the enum.

Attributes:

ACES_0 class-attribute instance-attribute

ACES_0 = 116

ACES Primaries #0 (ultra wide)

ACES_1 class-attribute instance-attribute

ACES_1 = 117

ACES Primaries #1

ADOBE class-attribute instance-attribute

ADOBE = 108

Adobe RGB (1998).

APPLE class-attribute instance-attribute

APPLE = 107

Apple RGB.

BT2020 class-attribute instance-attribute

BT2020 = 9
Primary       x      y
Green     0.1700 0.7970
Blue      0.1310 0.0460
Red       0.7080 0.2920
White D65 0.3127 0.3290

Rec. ITU-R BT.2020-2 Rec. ITU-R BT.2100-2

BT470BG class-attribute instance-attribute

BT470BG = 5
Primary      x      y
Green     0.2900 0.6000
Blue      0.1500 0.0600
Red       0.6400 0.3300
White D65 0.3127 0.3290

Rec. ITU-R BT.470-6 System B, G (historical) Rec. ITU-R BT.601-7 625 Rec. ITU-R BT.1358-0 625 (historical) Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM

BT470M class-attribute instance-attribute

BT470M = 4
Primary     x      y
Green    0.2100 0.7100
Blue     0.1400 0.0800
Red      0.6700 0.3300
White C  0.3100 0.3160

Rec. ITU-R BT.470-6 System M (historical) NTSC Recommendation for transmission standards for colour television (1953) FCC Title 47 Code of Federal Regulations (2003) 73.682 (a) (20)

BT601_525 class-attribute instance-attribute

BT601_525 = SMPTE170M

BT601_625 class-attribute instance-attribute

BT601_625 = BT470BG

BT709 class-attribute instance-attribute

BT709 = 1
Primary      x      y
Green     0.3000 0.6000
Blue      0.1500 0.0600
Red       0.6400 0.3300
White D65 0.3127 0.3290

Rec. ITU-R BT.709-6 Rec. ITU-R BT.1361-0 conventional colour gamutsystem and extended colour gamut system (historical) IEC 61966-2-1 sRGB or sYCC IEC 61966-2-4 SMPTE RP 177 (1993) Annex B

CIE1931 class-attribute instance-attribute

CIE1931 = ST428

DCI_P3 class-attribute instance-attribute

DCI_P3 = ST431_2

DISPLAY_P3 class-attribute instance-attribute

DISPLAY_P3 = ST432_1

EBU3213 class-attribute instance-attribute

EBU3213 = JEDEC_P22

FILM class-attribute instance-attribute

FILM = 8
Primary    x      y
Green   0.2430 0.6920 #(Wratten 58)
Blue    0.1450 0.0490 #(Wratten 47)
Red     0.6810 0.3190 #(Wratten 25)
White C 0.3100 0.3160

Generic film (colour filters using Illuminant C)

JEDEC_P22 class-attribute instance-attribute

JEDEC_P22 = 22
Primary      x      y
Green     0.2950 0.6050
Blue      0.1550 0.0770
Red       0.6300 0.3400
White D65 0.3127 0.3290

EBU Tech. 3213-E (1975)

PROPHOTO class-attribute instance-attribute

PROPHOTO = 109

ProPhoto RGB (ROMM).

ROMM class-attribute instance-attribute

ROMM = PROPHOTO

SGAMUT class-attribute instance-attribute

SGAMUT = 114

Sony S-Gamut.

SMPTE170M class-attribute instance-attribute

SMPTE170M = 6

(Functionally the same as Primaries.SMPTE240M)

Primary      x      y
Green     0.3100 0.5950
Blue      0.1550 0.0700
Red       0.6300 0.3400
White D65 0.3127 0.3290

Rec. ITU-R BT.601-7 525 Rec. ITU-R BT.1358-1 525 or 625 (historical) Rec. ITU-R BT.1700-0 NTSC SMPTE ST 170 (2004)

SMPTE240M class-attribute instance-attribute

SMPTE240M = 7

(Functionally the same as Primaries.SMPTE170M)

Primary      x      y
Green     0.3100 0.5950
Blue      0.1550 0.0700
Red       0.6300 0.3400
White D65 0.3127 0.3290

SMPTE ST 240 (1999, historical)

ST428 class-attribute instance-attribute

ST428 = 10
Primary        x   y
Green    (Y)  0.0 1.0
Blue     (Z)  0.0 0.0
Red      (X)  1.0 0.0
Centre White  1/3 1/3

SMPTE ST 428-1 (2006) (CIE 1931 XYZ)

ST431_2 class-attribute instance-attribute

ST431_2 = 11
Primary    x      y
Green   0.2650 0.6900
Blue    0.1500 0.0600
Red     0.6800 0.3200
White   0.3140 0.3510

SMPTE RP 431-2 (2011) SMPTE ST 2113 (2019) "P3DCI"

ST432_1 class-attribute instance-attribute

ST432_1 = 12
Primary      x      y
Green     0.2650 0.6900
Blue      0.1500 0.0600
Red       0.6800 0.3200
White D65 0.3127 0.3290

SMPTE EG 432-1 (2010) SMPTE ST 2113 (2019) "P3D65"

UNKNOWN class-attribute instance-attribute

UNKNOWN = 2

Unspecified Image characteristics are unknown or are determined by the application.

VARICAM class-attribute instance-attribute

VARICAM = VGAMUT

VGAMUT class-attribute instance-attribute

VGAMUT = 113

Panasonic V-Gamut (VARICAM).

XYZ class-attribute instance-attribute

XYZ = ST428

pretty_string property

pretty_string: str

string property

string: str

value_libplacebo property

value_libplacebo: int

libplacebo value.

value_vs property

value_vs: int

VapourSynth value.

Raises:

apply

apply(clip: VideoNodeT) -> VideoNodeT

Applies the property to the VideoNode.

Source code in vstools/enums/base.py
105
106
107
108
109
110
def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

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

ensure_presence classmethod

ensure_presence(
    clip: VideoNodeT,
    value: int | Self | None,
    /,
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of the property in the VideoNode.

Source code in vstools/enums/base.py
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@classmethod
def ensure_presence(
    cls, clip: VideoNodeT, value: int | Self | None, /, func: FuncExcept | 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)

ensure_presences staticmethod

ensure_presences(
    clip: VideoNodeT,
    prop_enums: Iterable[type[PropEnum] | PropEnum],
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of multiple PropEnums at once.

Source code in vstools/enums/base.py
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnum] | PropEnum], func: FuncExcept | 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 (
                prop_enum if isinstance(prop_enum, PropEnum) else prop_enum.from_video(clip, True, func)
                for prop_enum in prop_enums
            )
        },
    )

from_libplacebo classmethod

from_libplacebo(val: int) -> int

Obtain the primaries from libplacebo.

Source code in vstools/enums/color.py
1095
1096
1097
1098
1099
1100
1101
@classmethod
def from_libplacebo(cls, val: int) -> int:
    """
    Obtain the primaries from libplacebo.
    """

    return _placebo_primaries_map[val]

from_matrix classmethod

from_matrix(matrix: Matrix, strict: bool = False) -> Primaries

Obtain the primaries from a Matrix object.

Parameters:

  • matrix

    (Matrix) –

    Matrix object.

  • strict

    (bool, default: False ) –

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

Returns:

Raises:

Source code in vstools/enums/color.py
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
@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]

from_param classmethod

from_param(value: None, func_except: FuncExcept | None = None) -> None
from_param(value: PrimariesLike, func_except: FuncExcept | None = None) -> Self
from_param(
    value: PrimariesLike | None, func_except: FuncExcept | None = None
) -> Self | None
from_param(value: Any, func_except: Any = None) -> Self | None

Determine the Primaries through a parameter.

Parameters:

  • value

    (Any) –

    Value or Primaries object.

  • func_except

    (Any, default: None ) –

    Function returned for custom error handling. This should only be set by VS package developers.

Returns:

  • Self | None

    Primaries object or None.

Source code in vstools/enums/color.py
968
969
970
971
972
973
974
975
976
977
978
979
980
@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.
    """

from_param_or_video classmethod

from_param_or_video(
    value: PrimariesLike | None,
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Primaries
Source code in vstools/enums/color.py
982
983
984
985
986
987
988
989
@classmethod
def from_param_or_video(
    cls,
    value: PrimariesLike | None,
    src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Primaries: ...

from_res classmethod

from_res(frame: VideoNode | VideoFrame) -> Primaries

Guess the primaries based on the clip's resolution.

Parameters:

  • frame

    (VideoNode | VideoFrame) –

    Input clip or frame.

Returns:

Source code in vstools/enums/color.py
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
@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

from_transfer classmethod

from_transfer(transfer: Transfer, strict: bool = False) -> Primaries

Obtain the primaries from a Transfer object.

Parameters:

  • transfer

    (Transfer) –

    Transfer object.

  • strict

    (bool, default: False ) –

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

Returns:

Raises:

Source code in vstools/enums/color.py
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
@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]

from_video classmethod

from_video(
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func: FuncExcept | None = None,
) -> Primaries

Obtain the primaries of a clip from the frame properties.

Parameters:

  • src

    (VideoNode | VideoFrame | Mapping[str, Any]) –

    Input clip, frame, or props.

  • strict

    (bool, default: False ) –

    Be strict about the frame properties. Will ALWAYS error with Primaries.UNKNOWN.

Returns:

Raises:

Source code in vstools/enums/color.py
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any], strict: bool = False, func: FuncExcept | 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)

is_unknown classmethod

is_unknown(value: int | Primaries) -> bool

Check if Primaries is unknown.

Source code in vstools/enums/color.py
991
992
993
994
995
996
997
@classmethod
def is_unknown(cls, value: int | Primaries) -> bool:
    """
    Check if Primaries is unknown.
    """

    return value == cls.UNKNOWN

is_valid classmethod

is_valid(value: int) -> bool

Check if the given value is a valid int value of this enum.

Source code in vstools/enums/base.py
148
149
150
151
152
153
@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())

prop_key classmethod

prop_key() -> str

The key used in props to store the enum.

Source code in vstools/enums/base.py
29
30
31
32
33
34
35
36
@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

PropEnum

Bases: CustomIntEnum

Methods:

  • apply

    Applies the property to the VideoNode.

  • ensure_presence

    Ensure the presence of the property in the VideoNode.

  • ensure_presences

    Ensure the presence of multiple PropEnums at once.

  • from_param_or_video

    Get the enum member from a value that can be casted to this prop value

  • from_res

    Get an enum member from the video resolution with heuristics.

  • from_video

    Get an enum member from the frame properties or optionally fall back to resolution when strict=False.

  • is_unknown

    Whether the value represents an unknown value.

  • is_valid

    Check if the given value is a valid int value of this enum.

  • prop_key

    The key used in props to store the enum.

Attributes:

  • pretty_string (str) –

    Get a pretty, displayable string of the enum member.

  • string (str) –

    Get the string representation used in resize plugin/encoders.

pretty_string property

pretty_string: str

Get a pretty, displayable string of the enum member.

string property

string: str

Get the string representation used in resize plugin/encoders.

apply

apply(clip: VideoNodeT) -> VideoNodeT

Applies the property to the VideoNode.

Source code in vstools/enums/base.py
105
106
107
108
109
110
def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

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

ensure_presence classmethod

ensure_presence(
    clip: VideoNodeT,
    value: int | Self | None,
    /,
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of the property in the VideoNode.

Source code in vstools/enums/base.py
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@classmethod
def ensure_presence(
    cls, clip: VideoNodeT, value: int | Self | None, /, func: FuncExcept | 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)

ensure_presences staticmethod

ensure_presences(
    clip: VideoNodeT,
    prop_enums: Iterable[type[PropEnum] | PropEnum],
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of multiple PropEnums at once.

Source code in vstools/enums/base.py
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnum] | PropEnum], func: FuncExcept | 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 (
                prop_enum if isinstance(prop_enum, PropEnum) else prop_enum.from_video(clip, True, func)
                for prop_enum in prop_enums
            )
        },
    )

from_param_or_video classmethod

from_param_or_video(
    value: Any,
    src: VideoNode | VideoFrame | FrameProps,
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Self

Get the enum member from a value that can be casted to this prop value or grab it from frame properties.

If strict=False, gather the heuristics using the clip's size or format.

Parameters:

  • value

    (Any) –

    Value to cast.

  • src

    (VideoNode | VideoFrame | FrameProps) –

    Clip to get prop from.

  • strict

    (bool, default: False ) –

    Be strict about the frame properties. Default: False.

  • func_except

    (FuncExcept | None, default: None ) –

    Function returned for custom error handling.

Source code in vstools/enums/base.py
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
@classmethod
def from_param_or_video(
    cls,
    value: Any,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Self:
    """
    Get the enum member from a value that can be casted to this prop value
    or grab it from frame properties.

    If `strict=False`, gather the heuristics using the clip's size or format.

    Args:
        value: Value to cast.
        src: Clip to get prop from.
        strict: Be strict about the frame properties. Default: False.
        func_except: Function returned for custom error handling.
    """
    value = cls.from_param(value, func_except)

    if value is not None:
        return value

    return cls.from_video(src, strict, func_except)

from_res classmethod

from_res(frame: VideoNode | VideoFrame) -> Self

Get an enum member from the video resolution with heuristics.

Source code in vstools/enums/base.py
48
49
50
51
52
53
54
@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> Self:
    """
    Get an enum member from the video resolution with heuristics.
    """

    raise NotImplementedError

from_video classmethod

from_video(
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func: FuncExcept | None = None,
) -> Self

Get an enum member from the frame properties or optionally fall back to resolution when strict=False.

Source code in vstools/enums/base.py
56
57
58
59
60
61
62
63
64
@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any], strict: bool = False, func: FuncExcept | None = None
) -> Self:
    """
    Get an enum member from the frame properties or optionally fall back to resolution when strict=False.
    """

    raise NotImplementedError

is_unknown classmethod

is_unknown(value: int | Self) -> bool

Whether the value represents an unknown value.

Source code in vstools/enums/base.py
21
22
23
24
25
26
27
@classmethod
def is_unknown(cls, value: int | Self) -> bool:
    """
    Whether the value represents an unknown value.
    """

    return False

is_valid classmethod

is_valid(value: int) -> bool

Check if the given value is a valid int value of this enum.

Source code in vstools/enums/base.py
148
149
150
151
152
153
@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())

prop_key classmethod

prop_key() -> str

The key used in props to store the enum.

Source code in vstools/enums/base.py
29
30
31
32
33
34
35
36
@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"

Transfer

Bases: PropEnum

Transfer characteristics (ITU-T H.265 Table E.4).

Methods:

  • apply

    Applies the property to the VideoNode.

  • ensure_presence

    Ensure the presence of the property in the VideoNode.

  • ensure_presences

    Ensure the presence of multiple PropEnums at once.

  • from_libplacebo

    Obtain the transfer from libplacebo.

  • from_matrix

    Obtain the transfer from a Matrix object.

  • from_param

    Determine the Transfer through a parameter.

  • from_param_or_video
  • from_primaries

    Obtain the transfer from a Primaries object.

  • from_res

    Guess the transfer based on the clip's resolution.

  • from_video

    Obtain the transfer of a clip from the frame properties.

  • is_unknown

    Check if Transfer is unknown.

  • is_valid

    Check if the given value is a valid int value of this enum.

  • prop_key

    The key used in props to store the enum.

Attributes:

BT1886 class-attribute instance-attribute

BT1886 = BT709

BT2020_10 class-attribute instance-attribute

BT2020_10 = 14

(Functionally the same as Transfer.BT709, Transfer.BT601, and Transfer.BT2020_12) Rec. ITU-R BT.2020-2

BT2020_12 class-attribute instance-attribute

BT2020_12 = 15

(Functionally the same as Transfer.BT709, Transfer.BT601, and Transfer.BT2020_10) Rec. ITU-R BT.2020-2

BT470BG class-attribute instance-attribute

BT470BG = 5

Rec. ITU-R BT.470-6 System B, G (historical) Rec. ITU-R BT.1700-0 625 PAL and 625 SECAM

BT470M class-attribute instance-attribute

BT470M = 4

Rec. ITU-R BT.470-6 System M (historical) NTSC Recommendation for transmission standards for colour television (1953) FCC, Title 47 Code of Federal Regulations (2003) 73.682 (a) (20)

BT601 class-attribute instance-attribute

BT601 = 6

(Functionally the same as Transfer.BT709, Transfer.BT2020_10, and Transfer.BT2020_12) Rec. ITU-R BT.601-7 525 or 625 Rec. ITU-R BT.1358-1 525 or 625 (historical) Rec. ITU-R BT.1700-0 NTSC SMPTE ST 170 (2004)

BT709 class-attribute instance-attribute

BT709 = 1

(Functionally the same as Transfer.BT601, Transfer.BT2020_10, and Transfer.BT2020_12) Rec. ITU-R BT.709-6 Rec. ITU-R BT.1361-0 conventional Colour gamut system (historical)

GAMMA18 class-attribute instance-attribute

GAMMA18 = 104

Pure power gamma 1.8

GAMMA20 class-attribute instance-attribute

GAMMA20 = 105

Pure power gamma 2.0

GAMMA22 class-attribute instance-attribute

GAMMA22 = BT470M

GAMMA24 class-attribute instance-attribute

GAMMA24 = BT709

GAMMA26 class-attribute instance-attribute

GAMMA26 = 108

Pure power gamma 2.6

GAMMA28 class-attribute instance-attribute

GAMMA28 = BT470BG

HLG class-attribute instance-attribute

HLG = STD_B67

LINEAR class-attribute instance-attribute

LINEAR = 8

Linear transfer characteristics.

LOG100 class-attribute instance-attribute

LOG100 = 9

Logarithmic transfer characteristic (100:1 range).

LOG316 class-attribute instance-attribute

LOG316 = 10

Logarithmic transfer characteristic (100 * sqrt(10):1 range).

PQ class-attribute instance-attribute

PQ = ST2084

PROPHOTO class-attribute instance-attribute

PROPHOTO = 110

ProPhoto RGB (ROMM)

ROMM class-attribute instance-attribute

ROMM = PROPHOTO

SLOG_1 class-attribute instance-attribute

SLOG_1 = 115

Sony S-Log1

SLOG_2 class-attribute instance-attribute

SLOG_2 = 116

Sony S-Log2

SMPTE240M class-attribute instance-attribute

SMPTE240M = 7

SMPTE ST 240 (1999, historical).

SRGB class-attribute instance-attribute

SRGB = 13

IEC 61966-2-1 sRGB when matrix is equal to Matrix.RGB IEC 61966-2-1 sYCC when matrix is equal to Matrix.BT470BG

ST2084 class-attribute instance-attribute

ST2084 = 16

SMPTE ST 2084 (2014) for 10, 12, 14, and 16-bit systems Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system

ST428 class-attribute instance-attribute

ST428 = 111

Digital Cinema Distribution Master (XYZ)

STD_B67 class-attribute instance-attribute

STD_B67 = 18

Association of Radio Industries and Businesses (ARIB) STD-B67 Rec. ITU-R BT.2100-2 hybrid loggamma (HLG) system

UNKNOWN class-attribute instance-attribute

UNKNOWN = 2

Image characteristics are unknown or are determined by the application.

VARICAM class-attribute instance-attribute

VARICAM = VLOG

VLOG class-attribute instance-attribute

VLOG = 114

Panasonic V-Log (VARICAM)

XVYCC class-attribute instance-attribute

XVYCC = 11

IEC 61966-2-4.

XYZ class-attribute instance-attribute

XYZ = ST428

pretty_string property

pretty_string: str

string property

string: str

value_libplacebo property

value_libplacebo: int

libplacebo value.

value_vs property

value_vs: int

VapourSynth value.

Raises:

apply

apply(clip: VideoNodeT) -> VideoNodeT

Applies the property to the VideoNode.

Source code in vstools/enums/base.py
105
106
107
108
109
110
def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Applies the property to the VideoNode.
    """

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

ensure_presence classmethod

ensure_presence(
    clip: VideoNodeT,
    value: int | Self | None,
    /,
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of the property in the VideoNode.

Source code in vstools/enums/base.py
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@classmethod
def ensure_presence(
    cls, clip: VideoNodeT, value: int | Self | None, /, func: FuncExcept | 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)

ensure_presences staticmethod

ensure_presences(
    clip: VideoNodeT,
    prop_enums: Iterable[type[PropEnum] | PropEnum],
    func: FuncExcept | None = None,
) -> VideoNodeT

Ensure the presence of multiple PropEnums at once.

Source code in vstools/enums/base.py
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
@staticmethod
def ensure_presences(
    clip: VideoNodeT, prop_enums: Iterable[type[PropEnum] | PropEnum], func: FuncExcept | 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 (
                prop_enum if isinstance(prop_enum, PropEnum) else prop_enum.from_video(clip, True, func)
                for prop_enum in prop_enums
            )
        },
    )

from_libplacebo classmethod

from_libplacebo(val: int) -> int

Obtain the transfer from libplacebo.

Source code in vstools/enums/color.py
668
669
670
671
672
673
674
@classmethod
def from_libplacebo(cls, val: int) -> int:
    """
    Obtain the transfer from libplacebo.
    """

    return _placebo_transfer_map[val]

from_matrix classmethod

from_matrix(matrix: Matrix, strict: bool = False) -> Transfer

Obtain the transfer from a Matrix object.

Parameters:

  • matrix

    (Matrix) –

    Matrix object.

  • strict

    (bool, default: False ) –

    Be strict about the matrix-transfer mapping. Will ALWAYS error with Matrix.UNKNOWN.

Returns:

Raises:

Source code in vstools/enums/color.py
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
@classmethod
def from_matrix(cls, matrix: Matrix, strict: bool = False) -> Transfer:
    """
    Obtain the transfer from a Matrix object.

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

    Returns:
        Transfer object.

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

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

        return cls(matrix.value)

    return _matrix_transfer_map[matrix]

from_param classmethod

from_param(value: None, func_except: FuncExcept | None = None) -> None
from_param(value: TransferLike, func_except: FuncExcept | None = None) -> Self
from_param(
    value: TransferLike | None, func_except: FuncExcept | None = None
) -> Self | None
from_param(value: Any, func_except: Any = None) -> Self | None

Determine the Transfer through a parameter.

Parameters:

  • value

    (Any) –

    Value or Transfer object.

  • func_except

    (Any, default: None ) –

    Function returned for custom error handling. This should only be set by VS package developers.

Returns:

  • Self | None

    Transfer object or None.

Source code in vstools/enums/color.py
544
545
546
547
548
549
550
551
552
553
554
555
556
@classmethod
def from_param(cls, value: Any, func_except: Any = None) -> Self | None:
    """
    Determine the Transfer through a parameter.

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

    Returns:
        Transfer object or None.
    """

from_param_or_video classmethod

from_param_or_video(
    value: TransferLike | None,
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Transfer
Source code in vstools/enums/color.py
558
559
560
561
562
563
564
565
@classmethod
def from_param_or_video(
    cls,
    value: TransferLike | None,
    src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func_except: FuncExcept | None = None,
) -> Transfer: ...

from_primaries classmethod

from_primaries(primaries: Primaries, strict: bool = False) -> Transfer

Obtain the transfer from a Primaries object.

Parameters:

  • primaries

    (Primaries) –

    Primaries object.

  • strict

    (bool, default: False ) –

    Be strict about the primaries-transfer mapping. Will ALWAYS error with Primaries.UNKNOWN.

Returns:

Raises:

Source code in vstools/enums/color.py
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
@classmethod
def from_primaries(cls, primaries: Primaries, strict: bool = False) -> Transfer:
    """
    Obtain the transfer from a Primaries object.

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

    Returns:
        Transfer object.

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

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

        return cls(primaries.value)

    return _primaries_transfer_map[primaries]

from_res classmethod

from_res(frame: VideoNode | VideoFrame) -> Transfer

Guess the transfer based on the clip's resolution.

Parameters:

  • frame

    (VideoNode | VideoFrame) –

    Input clip or frame.

Returns:

Source code in vstools/enums/color.py
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> Transfer:
    """
    Guess the transfer based on the clip's resolution.

    Args:
        frame: Input clip or frame.

    Returns:
        Transfer object.
    """

    from ..utils import get_var_infos

    fmt, width, height = get_var_infos(frame)

    if fmt.color_family == vs.RGB:
        return Transfer.SRGB

    if width <= 1024 and height <= 576:
        return Transfer.BT601

    return Transfer.BT709

from_video classmethod

from_video(
    src: VideoNode | VideoFrame | Mapping[str, Any],
    strict: bool = False,
    func: FuncExcept | None = None,
) -> Transfer

Obtain the transfer of a clip from the frame properties.

Parameters:

  • src

    (VideoNode | VideoFrame | Mapping[str, Any]) –

    Input clip, frame, or props.

  • strict

    (bool, default: False ) –

    Be strict about the properties. The result may NOT be Transfer.UNKNOWN.

Returns:

Raises:

Source code in vstools/enums/color.py
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | Mapping[str, Any], strict: bool = False, func: FuncExcept | None = None
) -> Transfer:
    """
    Obtain the transfer of a clip from the frame properties.

    Args:
        src: Input clip, frame, or props.
        strict: Be strict about the properties. The result may NOT be Transfer.UNKNOWN.

    Returns:
        Transfer object.

    Raises:
        UndefinedTransferError: Transfer is undefined.
        UndefinedTransferError: Transfer can not be determined from the frameprops.
    """

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

is_unknown classmethod

is_unknown(value: int | Transfer) -> bool

Check if Transfer is unknown.

Source code in vstools/enums/color.py
567
568
569
570
571
572
573
@classmethod
def is_unknown(cls, value: int | Transfer) -> bool:
    """
    Check if Transfer is unknown.
    """

    return value == cls.UNKNOWN

is_valid classmethod

is_valid(value: int) -> bool

Check if the given value is a valid int value of this enum.

Source code in vstools/enums/base.py
148
149
150
151
152
153
@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())

prop_key classmethod

prop_key() -> str

The key used in props to store the enum.

Source code in vstools/enums/base.py
29
30
31
32
33
34
35
36
@classproperty
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"