Skip to content

info

Functions:

  • expect_bits

    Expected output bitdepth for a clip.

  • get_color_family

    Get the color family of a given clip.

  • get_depth

    Get the bitdepth of a given clip or value.

  • get_framerate

    Get the framerate from any object holding it.

  • get_h

    Calculate the height given a width and an aspect ratio.

  • get_plane_sizes

    Get the size of a given clip's plane using the index.

  • get_resolutions

    Get a tuple containing the resolutions of every plane of the given clip.

  • get_sample_type

    Get the sample type of a given clip.

  • get_subsampling

    Get the subsampling of a clip as a human-readable name.

  • get_var_infos

    Get information from a variable resolution clip or frame.

  • get_video_format

    Retrieve a VapourSynth VideoFormat object from various input types.

  • get_w

    Calculate the width given a height and an aspect ratio.

expect_bits

expect_bits(
    clip: VideoNode, /, expected_depth: int = 16, **kwargs: Any
) -> tuple[ConstantFormatVideoNode, int]

Expected output bitdepth for a clip.

This function is meant to be used when a clip may not match the expected input bitdepth. Both the dithered clip and the original bitdepth are returned.

Parameters:

  • clip

    (VideoNode) –

    Input clip.

  • expected_depth

    (int, default: 16 ) –

    Expected bitdepth. Default: 16.

Returns:

  • tuple[ConstantFormatVideoNode, int]

    Tuple containing the clip dithered to the expected depth and the original bitdepth.

Source code
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def expect_bits(clip: vs.VideoNode, /, expected_depth: int = 16, **kwargs: Any) -> tuple[ConstantFormatVideoNode, int]:
    """
    Expected output bitdepth for a clip.

    This function is meant to be used when a clip may not match the expected input bitdepth.
    Both the dithered clip and the original bitdepth are returned.

    Args:
        clip: Input clip.
        expected_depth: Expected bitdepth. Default: 16.

    Returns:
        Tuple containing the clip dithered to the expected depth and the original bitdepth.
    """
    assert check_variable_format(clip, expect_bits)

    bits = get_depth(clip)

    if bits != expected_depth:
        clip = depth(clip, expected_depth, **kwargs)

    return clip, bits

get_color_family

get_color_family(
    clip: VideoFormatT | HoldsVideoFormatT | ColorFamily,
) -> ColorFamily

Get the color family of a given clip.

Source code
114
115
116
117
118
119
120
121
122
def get_color_family(clip: VideoFormatT | HoldsVideoFormatT | vs.ColorFamily, /) -> vs.ColorFamily:
    """
    Get the color family of a given clip.
    """

    if isinstance(clip, vs.ColorFamily):
        return clip

    return get_video_format(clip).color_family

get_depth

get_depth(clip: VideoFormatT | HoldsVideoFormatT) -> int

Get the bitdepth of a given clip or value.

Source code
 95
 96
 97
 98
 99
100
def get_depth(clip: VideoFormatT | HoldsVideoFormatT, /) -> int:
    """
    Get the bitdepth of a given clip or value.
    """

    return get_video_format(clip).bits_per_sample

get_framerate

get_framerate(clip: VideoNode | Fraction | tuple[int, int] | float) -> Fraction

Get the framerate from any object holding it.

Source code
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def get_framerate(clip: vs.VideoNode | Fraction | tuple[int, int] | float) -> Fraction:
    """
    Get the framerate from any object holding it.
    """

    if isinstance(clip, vs.VideoNode):
        return clip.fps

    if isinstance(clip, Fraction):
        return clip

    if isinstance(clip, tuple):
        return Fraction(*clip)

    return Fraction(clip)

get_h

get_h(width: float, ar: SupportsFloat = 16 / 9, /, mod: int = 2) -> int
get_h(
    width: float, ref: VideoNode | VideoFrame, /, mod: int | None = None
) -> int
get_h(width: float, dar: Dar, /, mod: int | None = None) -> int
get_h(width: float, sar: Sar, /, mod: int | None = None) -> int
get_h(
    width: float,
    ar_or_ref: VideoNode | VideoFrame | SupportsFloat | Dar | Sar = 16 / 9,
    /,
    mod: int | None = None,
) -> int

Calculate the height given a width and an aspect ratio.

Either an aspect ratio (as a float), a reference clip, or a Dar/Sar object can be given. A mod can also be set, which will ensure the output height is MOD#.

The output is rounded by default (as fractional output resolutions are not supported anywhere).

Parameters:

  • width

    (float) –

    Width to use for the calculation.

  • ar_or_ref

    (VideoNode | VideoFrame | SupportsFloat | Dar | Sar, default: 16 / 9 ) –

    Aspect ratio, reference clip, or Dar/Sar object from which the AR will be calculated. Default: 1.778 (16 / 9).

  • mod

    (int | None, default: None ) –

    Mod for the output width to comply to. If None, do not force it to comply to anything. Default: None.

Returns:

  • int

    Calculated height.

Source code
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
def get_h(
    width: float,
    ar_or_ref: vs.VideoNode | vs.VideoFrame | SupportsFloat | Dar | Sar = 16 / 9,
    /,
    mod: int | None = None,
) -> int:
    """
    Calculate the height given a width and an aspect ratio.

    Either an aspect ratio (as a float), a reference clip, or a Dar/Sar object can be given.
    A mod can also be set, which will ensure the output height is MOD#.

    The output is rounded by default (as fractional output resolutions are not supported anywhere).

    Args:
        width: Width to use for the calculation.
        ar_or_ref: Aspect ratio, reference clip, or Dar/Sar object from which the AR will be calculated. Default: 1.778
            (16 / 9).
        mod: Mod for the output width to comply to. If None, do not force it to comply to anything. Default: None.

    Returns:
        Calculated height.
    """

    if isinstance(ar_or_ref, (Dar, Sar)):
        aspect_ratio = 1.0 / float(ar_or_ref)
        mod = mod or 2
    elif not isinstance(ar_or_ref, SupportsFloat):
        ref = ar_or_ref
        assert ref.format
        aspect_ratio = ref.height / ref.width
        mod = fallback(mod, ref.format.subsampling_h and 2 << ref.format.subsampling_h)
    else:
        aspect_ratio = 1.0 / float(ar_or_ref)

        if mod is None:
            mod = 0 if width % 2 else 2

    height = width * aspect_ratio

    if mod:
        return mod_x(height, mod)

    return round(height)

get_plane_sizes

get_plane_sizes(
    frame: VideoNode | VideoFrame, /, index: int
) -> tuple[int, int]

Get the size of a given clip's plane using the index.

Source code
166
167
168
169
170
171
172
173
174
175
176
177
178
179
def get_plane_sizes(frame: vs.VideoNode | vs.VideoFrame, /, index: int) -> tuple[int, int]:
    """
    Get the size of a given clip's plane using the index.
    """

    assert frame.format and frame.width

    width, height = frame.width, frame.height

    if index != 0:
        width >>= frame.format.subsampling_w
        height >>= frame.format.subsampling_h

    return width, height

get_resolutions

get_resolutions(
    clip: VideoNode | VideoFrame,
) -> tuple[tuple[int, int, int], ...]

Get a tuple containing the resolutions of every plane of the given clip.

Source code
182
183
184
185
186
187
188
189
def get_resolutions(clip: vs.VideoNode | vs.VideoFrame) -> tuple[tuple[int, int, int], ...]:
    """
    Get a tuple containing the resolutions of every plane of the given clip.
    """

    assert clip.format

    return tuple((plane, *get_plane_sizes(clip, plane)) for plane in range(clip.format.num_planes))

get_sample_type

get_sample_type(
    clip: VideoFormatT | HoldsVideoFormatT | SampleType,
) -> SampleType

Get the sample type of a given clip.

Source code
103
104
105
106
107
108
109
110
111
def get_sample_type(clip: VideoFormatT | HoldsVideoFormatT | vs.SampleType, /) -> vs.SampleType:
    """
    Get the sample type of a given clip.
    """

    if isinstance(clip, vs.SampleType):
        return clip

    return get_video_format(clip).sample_type

get_subsampling

get_subsampling(clip: VideoFormatT | HoldsVideoFormatT) -> str | None

Get the subsampling of a clip as a human-readable name.

Parameters:

Returns:

  • str | None

    String with a human-readable name.

Raises:

  • CustomValueError

    Unknown subsampling.

Source code
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
def get_subsampling(clip: VideoFormatT | HoldsVideoFormatT, /) -> str | None:
    """
    Get the subsampling of a clip as a human-readable name.

    Args:
        clip: Input clip.

    Returns:
        String with a human-readable name.

    Raises:
        CustomValueError: Unknown subsampling.
    """

    fmt = get_video_format(clip)

    if fmt.color_family != vs.YUV:
        return None

    if fmt.subsampling_w == 2 and fmt.subsampling_h == 2:
        return "410"

    if fmt.subsampling_w == 2 and fmt.subsampling_h == 0:
        return "411"

    if fmt.subsampling_w == 1 and fmt.subsampling_h == 1:
        return "420"

    if fmt.subsampling_w == 1 and fmt.subsampling_h == 0:
        return "422"

    if fmt.subsampling_w == 0 and fmt.subsampling_h == 1:
        return "440"

    if fmt.subsampling_w == 0 and fmt.subsampling_h == 0:
        return "444"

    raise UnsupportedSubsamplingError("Unknown subsampling.", get_subsampling)

get_var_infos

get_var_infos(frame: VideoNode | VideoFrame) -> tuple[VideoFormat, int, int]

Get information from a variable resolution clip or frame.

Source code
32
33
34
35
36
37
38
39
40
41
42
43
def get_var_infos(frame: vs.VideoNode | vs.VideoFrame) -> tuple[vs.VideoFormat, int, int]:
    """
    Get information from a variable resolution clip or frame.
    """

    if isinstance(frame, vs.VideoNode) and not (frame.width and frame.height and frame.format):
        with frame.get_frame(0) as frame:
            return get_var_infos(frame)

    assert frame.format

    return frame.format, frame.width, frame.height

get_video_format

get_video_format(
    value: int | VideoFormatT | HoldsVideoFormatT,
    /,
    *,
    sample_type: int | SampleType | None = None,
) -> VideoFormat

Retrieve a VapourSynth VideoFormat object from various input types.

Parameters:

  • value

    (int | VideoFormatT | HoldsVideoFormatT) –

    The format source. This can be: - A bidepth format if value < 32 - A unique format ID - A VideoFormat-like object - An object holding a VideoFormat (i.e., exposing a format attribute)

  • sample_type

    (int | SampleType | None, default: None ) –

    Optional override for the sample type. Accepts either an integer or a SampleType. If None, the default or inferred sample type is used.

Returns:

  • VideoFormat

    A VideoFormat object derived from the input.

Source code
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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
92
def get_video_format(
    value: int | VideoFormatT | HoldsVideoFormatT, /, *, sample_type: int | vs.SampleType | None = None
) -> vs.VideoFormat:
    """
    Retrieve a VapourSynth VideoFormat object from various input types.

    Args:
        value: The format source. This can be:
               - A bidepth format if `value < 32`
               - A unique format ID
               - A VideoFormat-like object
               - An object holding a VideoFormat (i.e., exposing a `format` attribute)

        sample_type: Optional override for the sample type. Accepts either an integer or a SampleType. If None, the
            default or inferred sample type is used.

    Returns:
        A VideoFormat object derived from the input.
    """

    from ..utils.vs_enums import VSPresetVideoFormat

    if sample_type is not None:
        sample_type = vs.SampleType(sample_type)

    if isinstance(value, vs.VideoFormat):
        return value

    if isinstance(value, VSPresetVideoFormat):
        return vs.core.get_video_format(value)

    if isinstance(value, int):
        if value > 32:
            return vs.core.get_video_format(value)

        if sample_type is None:
            sample_type = vs.SampleType(value == 32)

        return vs.core.query_video_format(vs.YUV, sample_type, value)

    if isinstance(value, vs.VideoNode):
        assert check_variable_format(value, get_video_format)

    if sample_type is not None:
        return value.format.replace(sample_type=sample_type)

    return value.format

get_w

get_w(height: float, ar: SupportsFloat = 16 / 9, /, mod: int = 2) -> int
get_w(
    height: float, ref: VideoNode | VideoFrame, /, mod: int | None = None
) -> int
get_w(height: float, dar: Dar, /, mod: int | None = None) -> int
get_w(height: float, sar: Sar, /, mod: int | None = None) -> int
get_w(
    height: float,
    ar_or_ref: VideoNode | VideoFrame | SupportsFloat | Dar | Sar = 16 / 9,
    /,
    mod: int | None = None,
) -> int

Calculate the width given a height and an aspect ratio.

Either an aspect ratio (as a float), a reference clip, or a Dar/Sar object can be given. A mod can also be set, which will ensure the output width is MOD#.

The output is rounded by default (as fractional output resolutions are not supported anywhere).

Parameters:

  • height

    (float) –

    Height to use for the calculation.

  • ar_or_ref

    (VideoNode | VideoFrame | SupportsFloat | Dar | Sar, default: 16 / 9 ) –

    Aspect ratio, reference clip, or Dar/Sar object from which the AR will be calculated. Default: 1.778 (16 / 9).

  • mod

    (int | None, default: None ) –

    Mod for the output width to comply to. If None, do not force it to comply to anything. Default: None.

Returns:

  • int

    Calculated width.

Source code
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
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
def get_w(
    height: float,
    ar_or_ref: vs.VideoNode | vs.VideoFrame | SupportsFloat | Dar | Sar = 16 / 9,
    /,
    mod: int | None = None,
) -> int:
    """
    Calculate the width given a height and an aspect ratio.

    Either an aspect ratio (as a float), a reference clip, or a Dar/Sar object can be given.
    A mod can also be set, which will ensure the output width is MOD#.

    The output is rounded by default (as fractional output resolutions are not supported anywhere).

    Args:
        height: Height to use for the calculation.
        ar_or_ref: Aspect ratio, reference clip, or Dar/Sar object from which the AR will be calculated. Default: 1.778
            (16 / 9).
        mod: Mod for the output width to comply to. If None, do not force it to comply to anything. Default: None.

    Returns:
        Calculated width.
    """

    if isinstance(ar_or_ref, (Dar, Sar)):
        aspect_ratio = float(ar_or_ref)
        mod = mod or 2
    elif not isinstance(ar_or_ref, SupportsFloat):
        ref = ar_or_ref
        assert ref.format
        aspect_ratio = ref.width / ref.height
        mod = fallback(mod, ref.format.subsampling_w and 2 << ref.format.subsampling_w)
    else:
        aspect_ratio = float(ar_or_ref)

        if mod is None:
            mod = 0 if height % 2 else 2

    width = height * aspect_ratio

    if mod:
        return mod_x(width, mod)

    return round(width)