enums ¶

Bases: CustomIntEnum

Controls how motion vectors are applied to pixels.

Attributes:

• ABSOLUTE –

  Motion vectors point directly to destination pixels.

• RELATIVE –

  Motion vectors describe how source pixels should be shifted.

ABSOLUTE = 0

RELATIVE = 1

Bases: IntFlag

Motion vector analyze direction.

Attributes:

• BACKWARD –

  Backward motion compensation.

• BOTH –

  Backward and forward motion compensation.

• FORWARD –

  Forward motion compensation.

BACKWARD = 1

BOTH = BACKWARD | FORWARD

FORWARD = 2

Bases: CustomIntEnum

Abstraction around both mvtools plugin versions.

Methods:

• Degrain –

  Get the Degrain function for motion compensated denoising.

• from_video –

  Automatically select the appropriate plugin based on the given clip.

Attributes:

• Analyze (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Analyze function for analyzing motion vectors.

• BlockFPS (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the BlockFPS function for block-based frame rate conversion.

• Compensate (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Compensate function for motion compensation.

• FLOAT –

  Fork by IFeelBloated. Only works with float single precision clips.

• Flow (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Flow function for motion vector visualization.

• FlowBlur (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the FlowBlur function for motion-compensated frame blending.

• FlowFPS (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the FlowFPS function for motion-compensated frame rate conversion.

• FlowInter (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the FlowInter function for motion-compensated frame interpolation.

• INTEGER –

  Original plugin. Only accepts integer 8-16 bits clips.

• Mask (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Mask function for generating motion masks.

• Recalculate (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Recalculate function for refining motion vectors.

• SCDetection (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the SCDetection function for scene change detection.

• Super (VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]) –

  Get the Super function for creating motion vector clips.

• namespace (Any) –

  Get the appropriate MVTools namespace based on plugin type.

Analyze: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

BlockFPS: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

Compensate: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

FLOAT = 1

Flow: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

FlowBlur: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

FlowFPS: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

FlowInter: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

INTEGER = 0

Mask: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

Recalculate: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

SCDetection: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

Super: VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

namespace: Any

Degrain(
    tr: int | None = None,
) -> VSFunctionAllArgs[VideoNode, ConstantFormatVideoNode]

102
103
104
105
106
107
108
109
110
111

def Degrain(self, tr: int | None = None) -> VSFunctionAllArgs[vs.VideoNode, ConstantFormatVideoNode]:
    """Get the Degrain function for motion compensated denoising."""

    if tr is None and self is not MVToolsPlugin.FLOAT:
        raise CustomValueError('This implementation needs a temporal radius!', f'{self.name}.Degrain')

    try:
        return getattr(self.namespace, f"Degrain{fallback(tr, '')}")
    except AttributeError:
        raise CustomValueError('This temporal radius isn\'t supported!', f'{self.name}.Degrain', tr)

from_video(clip: VideoNode) -> MVToolsPlugin

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

@classmethod
def from_video(cls, clip: vs.VideoNode) -> MVToolsPlugin:
    """
    Automatically select the appropriate plugin based on the given clip.

    :param clip:    The clip to process.

    :return:        The accompanying MVTools plugin for the clip.
    """
    assert check_variable_format(clip, cls.from_video)

    if clip.format.sample_type is vs.FLOAT:
        return MVToolsPlugin.FLOAT

    return MVToolsPlugin.INTEGER

Bases: CustomIntEnum

Defines the type of analysis mask to generate.

Attributes:

• COLORMAP –

  Creates a color visualization of motion vectors, mapping x/y components to U/V planes.

• HORIZONTAL –

  Visualizes horizontal motion vector components. Values are in pixels + 128.

• MOTION –

  Generates a mask based on motion vector magnitudes.

• OCCLUSION –

  Generates a mask highlighting areas where motion estimation fails due to occlusion.

• SAD –

  Generates a mask based on SAD (Sum of Absolute Differences) values.

• VERTICAL –

  Visualizes vertical motion vector components. Values are in pixels + 128.

COLORMAP = 5

HORIZONTAL = 3

MOTION = 0

OCCLUSION = 2

SAD = 1

VERTICAL = 4

Bases: CustomIntEnum

Controls how motion vectors are searched and selected.

Provides presets that configure multiple motion estimation parameters like lambda, LSAD threshold, and penalty values to optimize for either raw SAD scores or motion coherence.

Attributes:

• COHERENCE –

  Optimize for motion vector coherence, preferring vectors that align with surrounding blocks.

• SAD –

  Optimize purely for lowest SAD scores when searching motion vectors.

COHERENCE = 1

SAD = 0

Bases: CustomIntEnum

Controls how motion estimation penalties scale with hierarchical levels.

Attributes:

• LINEAR –

  Penalties scale linearly with hierarchical level size.

• NONE –

  Penalties remain constant across all hierarchical levels.

• QUADRATIC –

  Penalties scale quadratically with hierarchical level size.

LINEAR = 1

NONE = 0

QUADRATIC = 2

Bases: CustomIntEnum

Hierarchical levels smoothing and reducing (halving) filter.

Attributes:

• AVERAGE –

  Simple 4 pixels averaging.

• CUBIC –

  Cubic filter for even more smoothing.

• QUADRATIC –

  Quadratic filter for even more smoothing.

• TRIANGLE –

  Triangle filter for even more smoothing.

• TRIANGLE_SHIFTED –

  Triangle (shifted) filter for more smoothing (decrease aliasing).

AVERAGE = 0

CUBIC = 4

QUADRATIC = 3

TRIANGLE = 2

TRIANGLE_SHIFTED = 1

Bases: CustomIntEnum

Specifies how block differences (SAD) are calculated between frames. Can use spatial data, DCT coefficients, SATD, or combinations to improve motion estimation.

Attributes:

• ADAPTIVE_SATD_DCT –

  Adaptively choose between SATD data or DCT-weighted mixed mode for each block.

• ADAPTIVE_SATD_LUMA –

  Adaptively use SATD weighted by SAD, but only when there are significant luma changes.

• ADAPTIVE_SATD_MIXED –

  Adaptively choose between SATD data or an equal mix of SATD and DCT data for each block.

• ADAPTIVE_SPATIAL_DCT –

  Adaptively choose between spatial data or DCT-weighted mixed mode for each block.

• ADAPTIVE_SPATIAL_MIXED –

  Adaptively choose between spatial data or an equal mix of spatial and DCT data for each block.

• DCT –

  Calculate differences using DCT coefficients. Slower, especially for block sizes other than 8x8.

• MIXED_SADEQSATD_DCT –

  Mix of SAD, SATD and DCT data. Weight varies from SAD-only to equal SAD/SATD mix.

• MIXED_SATD_DCT –

  Use both SATD and DCT data, weighted based on the average luma difference between frames.

• MIXED_SPATIAL_DCT –

  Use both spatial and DCT data, weighted based on the average luma difference between frames.

• SATD –

  Use Sum of Absolute Transformed Differences (SATD) instead of SAD for luma comparison.

• SPATIAL –

  Calculate differences using raw pixel values in spatial domain.

ADAPTIVE_SATD_DCT = 8

ADAPTIVE_SATD_LUMA = 10

ADAPTIVE_SATD_MIXED = 7

ADAPTIVE_SPATIAL_DCT = 4

ADAPTIVE_SPATIAL_MIXED = 3

DCT = 1

MIXED_SADEQSATD_DCT = 9

MIXED_SATD_DCT = 6

MIXED_SPATIAL_DCT = 2

SATD = 5

SPATIAL = 0

Bases: CustomIntEnum

Decides the type of search at every level.

Attributes:

• DIAMOND –

  Logarithmic search, also named Diamond Search.

• EXHAUSTIVE –

  Exhaustive search, square side is 2 * radius + 1. It's slow, but gives the best results SAD-wise.

• EXHAUSTIVE_H –

  Pure horizontal exhaustive search, width is 2 * radius + 1.

• EXHAUSTIVE_V –

  Pure vertical exhaustive search, height is 2 * radius + 1.

• HEXAGON –

  Hexagon search (similar to x264).

• NSTEP –

  N step searches.

• ONETIME –

  One time search.

• UMH –

  Uneven Multi Hexagon search (similar to x264).

DIAMOND = 2

EXHAUSTIVE = 3

EXHAUSTIVE_H = 6

EXHAUSTIVE_V = 7

HEXAGON = 4

NSTEP = 1

ONETIME = 0

UMH = 5

Bases: CustomIntEnum

Subpixel interpolation method for pel = 2 or 4.

This enum controls the calculation of the first level only. If pel=4, bilinear interpolation is always used to compute the second level.

Attributes:

• BICUBIC –

  Bicubic interpolation (4-tap Catmull-Rom).

• BILINEAR –

  Soft bilinear interpolation.

• WIENER –

  Sharper Wiener interpolation (6-tap, similar to Lanczos).

BICUBIC = 1

BILINEAR = 0

WIENER = 2

Bases: CustomIntEnum

This is method for dividing coarse blocks into smaller ones.

Attributes:

• BILINEAR –

  Bilinear interpolation of 4 neighbors.

• NEAREST –

  Use motion of nearest block.

BILINEAR = 1

NEAREST = 0