# Comparison

Quality comparisons allow you to evaluate different video sources/releases and identify differences in visual quality, helping determine which source provides the best experience.
This guide covers how to set up and use VSView with VapourSynth to create accurate comparisons.

uv pip install vsview[recommended] vsjetpack[full] awsmfunc vsfpng

pip install vsview[recommended] vsjetpack[full] awsmfunc vsfpng

In order to create a comparison, you will need to create a VapourSynth script.

Create a file called comp.py. Launch it in your favorite text editor and add sections as desired:

- from vstools import vs, core, depth, set_output, PropEnum, Matrix, Transfer, Primaries, ColorRange, FieldBased
+ from vstools import vs, core, depth, PropEnum, Matrix, Transfer, Primaries, ColorRange, FieldBased

+ from vsview import set_output

- set_output(clip1, name=source1)
+ set_output(clip1, source1)

## Dependencies: Allows VSView to run [required; do not remove]
from vstools import vs, core, depth, PropEnum, Matrix, Transfer, Primaries, ColorRange, FieldBased, ChromaLocation
from vssource import FFMS2, LSMAS
from vskernels import Point, EwaLanczosSharp, Hermite
from vsdeinterlace import vfm, vdecimate
from awsmfunc.types.placebo import PlaceboColorSpace as ColorSpace
from awsmfunc.types.placebo import PlaceboTonemapFunction as Tonemap
from awsmfunc.types.placebo import PlaceboGamutMapping as Gamut
from awsmfunc.types.placebo import PlaceboTonemapOpts
from vsview import set_output

## File paths: Hold Shift and Right-click your file, select copy as path, and paste it here. Change LSMAS to FFMS2 if you encounter any issues
clip1 = LSMAS.source(r"C:\Paste\File\Path\Here.mkv")
clip2 = LSMAS.source(r"C:\Paste\File\Path\Here.mkv")
clip3 = LSMAS.source(r"C:\Paste\File\Path\Here.mkv")

## Source: Name of the source
source1 = "FirstSourceName"
source2 = "SecondSourceName"
source3 = "ThirdSourceName"

## <Additional comp settings>
## Place any additional settings you want to use in your comp here
## <End of additional comp settings>

## Output: Comment/uncomment as needed depending on how many clips you're comparing
set_output(clip1, source1)
set_output(clip2, source2)
set_output(clip3, source3)

Quick inverse telecine filter for converting telecined clips (usually 30 fps interlaced video) back to the original framerate (24 fps progressive).

clip1 = vdecimate(vfm(clip1))

Properly tags progressive content in interlaced container as progressive for correct chroma upscaling.

clip1 = FieldBased.PROGRESSIVE.apply(clip1)

Converts clips to 16-bit depth with 4:4:4 chroma subsampling.

clip1 = EwaLanczosSharp().scale(depth(clip1, 16), format=vs.YUV444P16, antiring=0.6)

Sets the source frame rate (fps) based on fractional input (fpsnum/fpsden). For example, fpsnum=24000 and fpsden=1001 forces the clip frame rate to 23.976 fps. This should be used on sources that have different frame rates that don't automatically stay in sync. If they do stay in sync, note that the source has dropped or duplicate frames.

clip1 = core.std.AssumeFPS(clip1, fpsnum=24000, fpsden=1001)

Removes the first n frames from the source. For example, [24:] will skip the first 24 frames and start the source at frame 25. This should be used on sources that are out of sync. To get the frame difference, find a unique frame (e.g. scene changes) in the correct and incorrect source. Note the frame numbers each one begin at, then set the difference of the two for the incorrect source.

clip1 = clip1[24:]

Crops the source video by n pixels from the selected side. For example, left=20 will remove 20 horizontal pixels starting from the left side. This should be used on sources that use letterboxing or other form of borders. Make sure to check for variable aspect ratios throughout the file and only crop the smallest border.

clip1 = core.std.Crop(clip1, left=240, right=240, top=0, bottom=0)

Sets the correct color information, should be used on sources with incorrect/missing metadata.

clip1 = PropEnum.ensure_presences(clip1, (Matrix.BT709, Transfer.BT709, Primaries.BT709, ColorRange.LIMITED))

clip1 = PropEnum.ensure_presences(clip1, (Matrix.BT709, Transfer.BT709, Primaries.BT709, ColorRange.LIMITED))

clip1 = PropEnum.ensure_presences(clip1, (Matrix.ST170_M, Transfer.BT601, Primaries.ST170_M, ColorRange.LIMITED))

clip1 = PropEnum.ensure_presences(clip1, (Matrix.BT470_BG, Transfer.BT601, Primaries.BT470_BG, ColorRange.LIMITED))

clip1 = PropEnum.ensure_presences(clip1, (Matrix.BT2020_NCL, Transfer.ST2084, Primaries.BT2020, ColorRange.LIMITED))

clip1 = PropEnum.ensure_presences(clip1, (Matrix.ST170_M, Transfer.BT709, Primaries.BT709, ColorRange.LIMITED))

clip1 = Point().resample(clip1, matrix=Matrix.ST170_M, format=vs.YUV444P16)
clip1 = PropEnum.ensure_presences(clip1, (Matrix.ST170_M, ColorRange.LIMITED))

Reverses Double-Range Compression to fix washed out colors.

clip1 = depth(clip1, range_in=ColorRange.LIMITED, range_out=ColorRange.FULL)
clip1 = ColorRange.LIMITED.apply(clip1)

Sets the range as full for incorrectly tagged sources to fix blown out highlights and crushed blacks.

clip1 = ColorRange.FULL.apply(clip1)

Sometimes an HDR source will be mostly or even entirely within the SDR range, often seen with anime on Netflix. In these cases you can clip the source to get an exact match to SDR, unlike with traditional tonemapping. Clipping should always be attempted first before resorting to tonemapping, even if some highlights get blown out. You may also need to apply a 0.92 gamma adjustment afterwards.

Clip HDR source to SDR

clip1 = Point().resample(clip1, matrix=Matrix.BT709, transfer=Transfer.BT709, primaries=Primaries.BT709, format=vs.YUV444P16)

Clip DV (Profile 5) source to SDR

clip1args = PlaceboTonemapOpts(source_colorspace=ColorSpace.DOVI, target_colorspace=ColorSpace.HDR10, use_dovi=True)
clip1 = core.placebo.Tonemap(clip1, **clip1args.vsplacebo_dict())
clip1 = PropEnum.ensure_presences(clip1, (Matrix.BT2020_NCL, Transfer.ST2084, Primaries.BT2020))
clip1 = Point().resample(clip1, matrix=Matrix.BT709, transfer=Transfer.BT709, primaries=Primaries.BT709, format=vs.YUV444P16)

Converts the dynamic range of the source (i.e. HDR/DV -> SDR).

• For converting HDR (washed out colors) -> SDR, set ColorSpace.HDR10
• For converting DV (green/purple hue) -> SDR, set ColorSpace.DOVI

clip1args = PlaceboTonemapOpts(source_colorspace=ColorSpace.HDR10, target_colorspace=ColorSpace.SDR, tone_map_function=Tonemap.Spline, gamut_mapping=Gamut.Perceptual, peak_detect=True, use_dovi=True, contrast_recovery=0.3 ,dst_max=100)
clip1 = core.placebo.Tonemap(clip1, **clip1args.vsplacebo_dict())
clip1 = core.std.SetFrameProps(clip1, _Matrix=vs.MATRIX_BT709, _Transfer=vs.TRANSFER_BT709, _Primaries=vs.PRIMARIES_BT709)

Converts the clip to 32 bit depth for accurate output

clip1 = depth(clip1, 32)

Adjusts the gamma level of the video. Should be used to fix the QuickTime gamma bug (0.88) or similar where one source is brighter than others.

clip1 = core.std.Levels(clip1, gamma=0.88, planes=0)

Converts to RGBS which is required for debanding and scaling

clip1 = Point().resample(clip1, format=vs.RGBS)

Otherwise competitive sources with obvious banding should be debanded to see how they'd fare with mpv's built-in deband filter. The debanded clip should never replace the original. Instead, it should be added as an additional node.

clip1 = core.placebo.Deband(clip1, planes=1|2|4, threshold=48 / 16.384, grain=32 / 8.192)

Upscales lower resolution sources to match the highest resolution source. (Recommended)

clip1 = EwaLanczosSharp().scale(clip1, 1920, 1080, sigmoid=True, antiring=0.6)

Downscales higher resolution sources to match a lower resolution source. Only use this for demonstrative purposes

clip1 = Hermite().scale(clip1, 1920, 1080, linear=True)

uv run vsview comp.py

uv run vsview "C:\path\to\comp.py"

vsview comp.py

vsview "C:\path\to\comp.py"

1. Open the settings menu in the top left

2. Under Plugin - Comparison, set the following:

   • Set Collection Name Template to {name} ({year}) - S01E01 - {vs_names}
   • Enter your slow.pics credentials (optional)

Once complete, close and relaunch VSView to apply these changes.

For the purpose of making comparisons, you will only need the following binds:

1. Open the Plugins window and select the Comparisons tab

2. Under TMDB Name search for the show/movie and select it, change/remove the episode number if needed

3. Before creating a comparison, skim through all your sources and ensure that they are displaying correctly and stay in sync throughout the entire runtime. Most issues can be fixed using filters in your comparison script

4. Select the frames to be uploaded. There are multiple methods to doing so:

   • Manual: Scrub through the video and mark each frame using Ctrl+Space
   • Automatic: Specify an amount of random frames in the Plugin menu and click Select frames
   • Frames should ideally show a variety of scenarios (e.g. light/dark, static/high-motion, flat/grainy, etc.). Make sure to include scenes with on-screen text and bright reds when possible
   • An average of 50 frames is recommended, which is the maximum allowed for automatic comparisons. You can still add more manual frames on top of this if needed

5. Hit the Extract & Upload button. VSView will automatically screenshot all selected frames and upload a comparison to slow.pics

The following will help make your comparison as effective as possible

• Include every available Blu-ray, you generally will need to check U2 (Private tracker)
• If 2 sources have identical video, only include 1 and label it as such (eg JPN/USA BD)
• We generally recommend choosing episode 2 to ensure both the OP and ED are shown
• Include at least 1 web source when available
• Include all relevant encodes, see below