Skip to content

fade

Functions:

crossfade 

crossfade(
    clipa: VideoNode,
    clipb: VideoNode,
    function: EasingT,
    debug: bool | int | tuple[int, int] = False,
) -> VideoNode
Source code 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def crossfade(
    clipa: vs.VideoNode, clipb: vs.VideoNode, function: EasingT, debug: bool | int | tuple[int, int] = False
) -> vs.VideoNode:
    assert clipa.format and clipb.format

    if not clipa.height == clipb.height and clipa.width == clipb.width and clipa.format.id == clipb.format.id:
        raise ValueError("crossfade: Both clips must have the same length, dimensions and format.")

    ease_function = function(0, 1, clipa.num_frames)

    def _fading(n: int) -> vs.VideoNode:
        weight = ease_function.ease(n)
        merge = clipa.std.Merge(clipb, weight)
        return merge.text.Text(str(weight), 9, 2) if debug else merge

    return clipa.std.FrameEval(_fading)

fade 

fade(
    clipa: VideoNode,
    clipb: VideoNode,
    invert: bool,
    start: int,
    end: int,
    function: EasingT = Linear,
) -> VideoNode
Source code 
19
20
21
22
23
24
25
26
27
def fade(
    clipa: vs.VideoNode, clipb: vs.VideoNode, invert: bool, start: int, end: int, function: EasingT = Linear
) -> vs.VideoNode:
    clipa_cut = clipa[start:end]
    clipb_cut = clipb[start:end]

    fade = crossfade(clipa_cut, clipb_cut, function) if invert else crossfade(clipb_cut, clipa_cut, function)

    return insert_clip(clipa, fade, start)

fade_freeze 

fade_freeze(
    clipa: VideoNode,
    clipb: VideoNode,
    invert: bool,
    start: int,
    end: int,
    function: EasingT = Linear,
) -> VideoNode
Source code 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def fade_freeze(
    clipa: vs.VideoNode, clipb: vs.VideoNode, invert: bool, start: int, end: int, function: EasingT = Linear
) -> vs.VideoNode:
    start_f, end_f = (start, end) if invert else (end, start)

    length = end - start + 1

    return fade(
        insert_clip(clipa, clipa[start_f] * length, start),
        insert_clip(clipb, clipb[end_f] * length, start),
        invert,
        start,
        end,
        function,
    )

fade_in 

fade_in(
    clip: VideoNode, start: int, end: int, function: EasingT = Linear
) -> VideoNode
Source code 
47
48
def fade_in(clip: vs.VideoNode, start: int, end: int, function: EasingT = Linear) -> vs.VideoNode:
    return fade(clip, clip.std.BlankClip(), False, start, end, function)

fade_in_freeze 

fade_in_freeze(
    clip: VideoNode, start: int, end: int, function: EasingT = Linear
) -> VideoNode
Source code 
55
56
def fade_in_freeze(clip: vs.VideoNode, start: int, end: int, function: EasingT = Linear) -> vs.VideoNode:
    return fade_in(insert_clip(clip, clip[end] * (end - start + 1), start), start, end, function)

fade_out 

fade_out(
    clip: VideoNode, start: int, end: int, function: EasingT = Linear
) -> VideoNode
Source code 
51
52
def fade_out(clip: vs.VideoNode, start: int, end: int, function: EasingT = Linear) -> vs.VideoNode:
    return fade(clip, clip.std.BlankClip(), True, start, end, function)

fade_out_freeze 

fade_out_freeze(
    clip: VideoNode, start: int, end: int, function: EasingT = Linear
) -> VideoNode
Source code 
59
60
def fade_out_freeze(clip: vs.VideoNode, start: int, end: int, function: EasingT = Linear) -> vs.VideoNode:
    return fade_out(insert_clip(clip, clip[start] * (end - start + 1), start), start, end, function)

fade_ranges 

fade_ranges(
    clip_a: VideoNode,
    clip_b: VideoNode,
    ranges: FrameRangeN | FrameRangesN,
    fade_length: int = 5,
    ease_func: EasingT = Linear,
) -> VideoNode
Source code 
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def fade_ranges(
    clip_a: vs.VideoNode,
    clip_b: vs.VideoNode,
    ranges: FrameRangeN | FrameRangesN,
    fade_length: int = 5,
    ease_func: EasingT = Linear,
) -> vs.VideoNode:
    nranges = normalize_ranges(clip_b, ranges)
    nranges = [(s - fade_length, e + fade_length) for s, e in nranges]
    nranges = normalize_ranges(clip_b, nranges)

    franges = [range(s, e + 1) for s, e in nranges]

    ease_function = ease_func(0, 1, fade_length)

    def _fading(n: int) -> vs.VideoNode:
        frange: range | None = next((x for x in franges if n in x), None)

        if frange is None:
            return clip_a

        if frange.start + fade_length >= n >= frange.start:
            weight = ease_function.ease(n - frange.start)

            return clip_a.std.Merge(clip_b, weight)

        if frange.stop - fade_length <= n <= frange.stop:
            weight = ease_function.ease(frange.stop - n)

            return clip_b.std.Merge(clip_a, 1 - weight)

        return clip_b

    return clip_a.std.FrameEval(_fading)