I'm setting up an auto-encoder that converts my Osmo Pocket 3 footage to AV1 when I insert the SD card. Before picking settings I ran a test: 150 encodes across presets 4–7 and CRF 20–36, with VMAF, VMAF NEG and BD-rate. Sharing in case it's useful, and I'd welcome critique of the method.

TL;DR

• Preset 5 is the sweet spot on this footage. At equal quality it's 20% smaller than preset 7, against 22% for preset 4, and it takes 1.5× preset 7's time against 1.9×.
• Preset 6 is better than it looks at the same CRF. At the same CRF it's only 4% smaller than preset 7. But it also scores about 0.3 VMAF higher, so at matched quality it's 15% smaller. On the 4K60 clip it's even 3% bigger at the same CRF, yet 12% smaller at matched quality.
• CRF sets the quality almost independently of preset. At the same CRF, presets 4 and 7 land within 0.44 VMAF of each other on every clip (0.1–0.2 on average). So you can pick the CRF first and then the preset, without a full matrix.
• I went with preset 5, CRF 32. Output is about 13–14% of the camera files, at a mean VMAF of ~96.5.

Setup

• Encoder: ffmpeg (gyan.dev full build, 2026-09-28 git) with libsvtav1, SVT-AV1 v4.2.0. -c:v libsvtav1 -preset P -crf Q -pix_fmt yuv420p10le -svtav1-params tune=0. No other parameters, video only.
• Hardware: i7-12700H laptop (6P+8E, 20 threads), Windows 11, on AC power, encodes run one at a time. Times are wall-clock and include HEVC decode.
• Source: Osmo Pocket 3 HEVC, normal colour profile (bt709). Clips are ≤10 s excerpts from the middle of each file, stream-copied so the source is bit-exact. 11 clips in total:
  • 6× 1080p60 10-bit, ~32 Mb/s, handheld
  • 4× 4K30 8-bit timelapses, 80–124 Mb/s
  • 1× 4K60 10-bit, ~92 Mb/s
• Metrics: VMAF v0.6.1 and v0.6.1neg at native resolution, both sides converted to yuv420p10le. Scored on every 2nd frame (n_subsample=2). I report the mean, 5th percentile and worst 1%.
• BD-rate: per clip, PCHIP on log-bitrate vs mean VMAF, then averaged over clips. All presets are anchored to preset 7.
• Test matrix. I started with a full matrix, found that CRF ≈ quality across presets, and then trimmed it:

So the BD-rate for presets 5 and 6 is computed on the CRF 28–32 range, which is effectively a 2-point, log-linear comparison. As a sanity check, preset 4 vs 7 gives −22.2% on the 28–32 range and −22.7% over the full overlapping range.

Result 1: preset trade-off at matched quality

Each step down in preset buys less:

The ranking is the same on every one of the 11 clips. Per clip, preset 5 is within 1.6–3.0 points of preset 4, and preset 6 is 3.5–7.5 points behind preset 5. NEG shows the same ranking, so it isn't VMAF rewarding sharpening.

Result 2: same CRF ≠ same quality

All four presets at CRF 32, all clips (duration-weighted):

Preset 6 consistently lands higher in quality at a given CRF than 7, 5 and 4. It has the highest VMAF of the four on 10 of 11 clips, at both CRF 28 and CRF 32. If you only compare file sizes at the same CRF (which is what I did first), preset 6 looks pointless. At matched quality it's a real option: it gives the best savings per extra second of encoding.

Result 3: per resolution/fps

Absolute speed at CRF 28/32 on this laptop:

Even preset 7 is barely real-time for 1080p60.

• The slower presets help most on handheld 1080p60.
• The 4K30 timelapses gain the least, despite being the slowest per minute of footage.
• One grainy timelapse is an outlier. At preset 5 / CRF 32 it stays at 32% of its source bitrate, against 7–9% for the other timelapses, and gains the least from slower presets (−11% at p5). Presumably the encoder is spending bits on the camera's noise.

Result 4: CRF ladder

Preset 7. Sizes at p5/p4 are about 17% lower at the same quality.

(Size is a percentage of the camera's HEVC file.)

• Each +4 CRF removes about a third of the bitrate and costs about 1 VMAF on the mean.
• The timelapses' weakest frames fall off about twice as fast as 1080p's.
• The 4K60 clip's weakest frames don't depend on the CRF. Its 5th percentile sits at 88–91 regardless, even at preset 4 / CRF 20, and its worst 1% at ~70–79. My guess is a few fast-motion frames that VMAF dislikes no matter what.

Caveats

• Sample. 11 short clips from two days of shooting with one camera. 4K60 is a single clip.
• VMAF model. v0.6.1 at native 4K assumes 1080p viewing at 3H, so it's probably optimistic for 4K on a big screen.
• Timing. Laptop timings include some thermal and background noise. But the ratios were consistent across clips and groups.
• Untuned settings. Only tune=0; no variance boost, film grain or other parameters. Those could shift the picture.

Hope it's useful. I'm curious about how other people experience the preset 4/5/6 trade-offs.

While the encoding mode doesn't make much of a difference for libx264 and libx265, it seems to make a significant difference for libsvtav1!
This observation is consistent; it does not depend on the video, the preset, or the resolution.

Details of the protocol and public data are available here: https://mendevi.readthedocs.io/latest/dataset/explore/crf_vs_cbr_vs_qp.html

Intuitively, we might expect QP mode to consume less power because it does not require multiple cycles to track an external variable.

But then, WHY IS CBR FASTER???

I get roughly the same result whether I plot quality on the x-axis or time on the y-axis.

Any ideas? Or directions for research?

v2.0 is a major performance update. VMAF, VMAF NEG and VMAF v1 now run on
any GPU, the other metrics and Video Compare are several times faster, and the
app uses far less memory.

This will likely be the last major release of VideoMetricsLab. While it was a lot of fun to work on this, it has consumed far too much of my life in the past month and I need to back off on this a lot to have a healthier life. I will still do little things here and there, but releases will be much slower going forward.

VideoMetricsLab is a free Windows app for measuring and comparing video quality. Add a source and any number of encodes, and it calculates VMAF, VMAF v1, SSIMULACRA2, Butteraugli, ColorVideo VDP, PSNR, SSIM and XPSNR in one run, accelerated on NVIDIA, AMD and Intel GPUs. Per-frame graphs show exactly where each encode falls behind, and frame-exact playback switches instantly between the source and each encode, so you can see the differences the scores point to. It’s built for anyone tuning encoders, comparing codecs or settings, or checking a release before it ships.

Let me know what you think, have any issues, or have feature requests.

v2.0 changelog

Metric performance

• Added Vulkan support for VMAF v1, so it now runs on any GPU (NVIDIA, AMD or Intel), up to 17x faster than on a 24 core CPU.
• Added Vulkan support for VMAF v0.6.1 and VMAF NEG, so they run on any GPU: 4.8x-6.4x faster than Netflix’s own CUDA code on an RTX 5090, and up to 28x faster than on a 24 core CPU. On NVIDIA GPUs, choose Vulkan in Settings > GPU metrics > GPU backend.
• PSNR, SSIM and XPSNR are now calculated in the app with libvmaf-fast, 2.7x-11x faster than with FFmpeg.
• Added software decoding in the app for videos the GPU can't decode, such as VVC, making VMAF 1.8x-2.7x faster for them.
• SSIMULACRA2 and Butteraugli on the CPU are now 7x faster.

System performance

• Video Compare now plays 4K HDR at 120 frames a second instead of 14, using a fifteenth of the CPU.
• Greatly reduced memory use: the app now idles at 180 MB instead of 840 MB, and VMAF v1 at 4K uses 2.6 GB instead of 13.8 GB.
• Metric Graphs, Video Compare and Settings now open instantly, and the window stays responsive with hundreds of videos.
• Video Compare no longer uses any CPU while idle.
• Detected black bars are now remembered between sessions.

New features

• Added a command line, VideoMetricsLab-cli, for running comparisons from scripts.
• Video Compare can now play HDR video in Display P3 colours on the GPU.
• Added the ability to zoom in Video Compare.
• Added an option to highlight each metric's best and worst results in the Videos tab.
• Added a dark theme, which follows Windows or can be chosen in Settings.
• Added drag and drop for videos, pasting a reference path, reordering rows by dragging, and sorting by any column.
• File dialogs now open in the folder your videos last came from, and the app can reopen your last session's videos.

Features:

Metrics

• VMAF v0.6.1, VMAF NEG, VMAF v1, PSNR, SSIM, XPSNR, SSIMULACRA2, Butteraugli and ColorVideo VDP, for many test videos at once.
• VMAF models for standard, phone, 4K and HFR viewing.

Fast on any GPU

• VMAF, VMAF NEG and VMAF v1 on NVIDIA, AMD and Intel GPUs with libvmaf-fast: VMAF v1 up to 17x faster.
• SSIMULACRA2, Butteraugli and ColorVideo VDP on the GPU with Vship (CUDA, HIP or Vulkan); libjxl on the CPU when no GPU can be used, for SSIMULACRA2 and Butteraugli.
• PSNR, SSIM and XPSNR 2.7x-11x faster, calculated in the app.
• GPU video decoding, with software decoding for formats the GPU can't handle, such as VVC.

Compare and inspect

• Frame-exact playback that switches instantly between the source and each encode (hold S), with zoom, at up to 120 fps in 4K HDR.
• Metric curves, statistics and per-frame scores (per second for ColorVideo VDP), with each metric's best and worst results highlighted.
• Bitrate by frame, second or GOP.

Workflow

• Black bars and resolution mismatches handled automatically.
• Results saved and reloaded automatically.
• Drag and drop videos, sort and reorder the list, and a dark theme.
• A command line, VideoMetricsLab-cli, for scripts.
• Two test videos calculated in parallel on many-core CPUs.

The app can be downloaded below.

https://github.com/4KVCD/VideoMetricsLab/releases

Hi, I have a few TV series here - mostly animated shows in 720p/1080p (H.264) - and I’d like to compress them to AV1. My main priority is maximizing storage savings while maintaining acceptable quality. Is SVT-AV1-HDR the encoder of choice for this, or should I look at SVT-AV1 instead? What settings should I try out? Thanks!

For those curious how far compiling ffmpeg+libsvtav1 from source can get you versus prebuilt binaries, here is a quick comparison on macos-arm64 and ubuntu-x86_64.

macos-arm64:

ubuntu-x86_64:

results were recorded with hyperfine using preset 3, crf 25, libsvtav1.

TLDR: optimizations (O3+LTO+PGO) can shave off about 10-15% depending on the platform.

Latest versions of SVT-AV1-HDR Encoder Lib v4.2.0-3-ga46bc2d59 "Ghost Robot" doesn't seem to be injecting the HDR metdata into the encoded file video stream. This used to work in SVT-AV1-HDR Encoder Lib v4.1.0 "Chromedome". I know I can add the metadata tags to mkv container, but I rather have it directly in the video stream like before.

VSPipe.exe -c y4m input.vpy - | SvtAv1EncApp.exe --input-depth 10 --input - --progress 2 --crf 36 --preset 2 --tune 6 --enable-dlf 2 --qp-scale-compress-strength 2 --film-grain 10 --ac-bias 1.0 --color-primaries 9 --transfer-characteristics 16 --matrix-coefficients 9 --mastering-display "G(0.2650,0.6900)B(0.1500,0.0600)R(0.6800,0.3200)WP(0.3127,0.3290)L(1000.0000,0.0050)" --content-light 1000,110 --output output.ivf

Has something changed? Am I doing something wrong?

One surprising result: On CPU with ffmpeg, decoding with VVC consumed on average 10x more energy than h264, h265, vp9 and av1 on the same videos / same machines!

To get there, I ran 4 months of video encoding/decoding tests on 7 different machines.

The result is a fully open dataset with 140k+ encode/decode runs with measurements for time, power (real wattmeter + RAPL), CPU/RAM usage, temperature, bitrate, metrics and ffprobe.

Setup:

• 10 encoders (libx264, h264_vaapi, h264_nvenc, libx265, hevc_nvenc, vvc, libaom-av1, libsvtav1, libvpx-vp9, av1_nvenc)
• 5 decoders (CPU only)
• 30 videos from JVET CTC x 4 resolutions (SD/HD/FHD/UHD4K)
• 24 quality points per encoder
• 3 efforts per encoder (fast/medium/slow)
• 5 quality metrics (PSNR/SSIM/VIF/VMAF/LPIPS_ALEX)
• 4 complexity metrics (SI/TI)

The data was collected with mendevi.

Here is an example of how to use the dataset to visualise the energy required to decode a video stream on a CPU, depending on the codec.

https://reddit.com/link/1wz5lu3/video/t8etai3b8vth1/player

Here is another example comparing the bitrate and distortion performance of AV1 versus H.264, regardless of the duration.

Which analysis would you like to see?

If you’d like to explore the dataset yourself, a lightweight JSON version is available here, while the full 50 GB SQLite dataset can be downloaded via torrent here.

I am thinking about trading in my 14" base m4 macbook pro (16+512) for a mac mini m6 32 gb. I have a NAS , with the current insane price of Hdds , I am thinking about getting something more powerful to transcode and compress videos and pictures in order to save space.

I am mainly using Handbrake to transcode my videos(movies and anime) to AV1 codec, most of them are hevc 1080p. I am only going to do software transcode for better quality so the lack of hardware encoding doesn't bother me , whats matter is cpu multi core performance for this task . As for pictures I plan to convert them to Webp format. Given the m6 is quite an improvement in multi core performance over the base m5 and m4 , do you think it can give me much better performance in these tasks?

Even though I prefer Macs , what are the other options besides Macs that are not to expensive and is power efficient ?

Looking for an AVIF compressor with tinkerer options, to try out different tunings, HDR, progressive etc. Basically Squoosh, but with updated dependencies and settings.

Must have preview and comparison with original.

Prefer offline processing, but no biggie if trusted provider. Basically want to start tinkering, but I am a designer and kind of need visual feedback. Anyone knows of such a tool?

***v1.4 is here with some huge new features like GPU accelerated VMAF! Enjoy.***

Here's an app I wrote to analyze video quality between different encodes. This was inspired by FFMetrics, but I wanted many more features for comparisons, like advanced statistics and an ability to easily and instantly subjectively A/B compare encoded videos with the source. This makes subjective video quality comparisons so much easier when you can compare on a frame by frame basis and while the video is playing, and instantly switch to the source or a different encoded video.

So I decided to write my own app, and I'd like to share it with all of you. I hope you all enjoy.

Let me know what you think, have any issues, or have feature requests.

v1.4 changelog

• VMAF v0.6.1 and VMAF NEG can now be calculated on NVIDIA GPUs.
• GPU metrics now take frames straight from the GPU's video decoder (NVIDIA, Intel and AMD) instead of through FFmpeg, using much less CPU and running noticeably faster.
• Updated Vship's Vulkan build to 5.1.2, with SSIMULACRA2 on Intel GPUs.
• A crash in Vship, libvmaf or the GPU driver while calculating metrics no longer closes the app.
• Reworked the progress line, with each metric's progress and time remaining.
• VMAF NEG now sits beside VMAF v0.6.1.
• Fixed wrong scores for videos with an odd width or height when decoded on NVIDIA GPUs.
• Fixed SSIMULACRA2, Butteraugli and CVVDP comparing mismatched frames when a video has dropped or extra frames.
• Fixed CPU SSIMULACRA2 and Butteraugli scores being far from the GPU's on SDR video. Saved CPU scores are recalculated once.
• Fixed 24 fps videos being accepted against 23.976 fps ones (and 30 against 29.97, 60 against 59.94).
• Fixed GPU metrics on PCs whose only GPU is Intel's.
• Fixed FFmpeg's GPU decoding not being used on AMD GPUs.

Features:

• Calculate VMAF, VMAF NEG, PSNR, SSIM, XPSNR, SSIMULACRA2, Butteraugli, and ColorVideo VDP for multiple test videos.
• Vship integration for GPU acceleration for ColorVideo VDP, SSIMULACRA2, and Butteraugli, on NVIDIA (CUDA), AMD (HIP) and any other GPU with a Vulkan driver
• GPU acceleration for VMAF v0.6.1 and VMAF NEG on NVIDIA GPUs (GeForce GTX 16 and RTX 20 series or newer), with a bundled libvmaf built with CUDA
• libjxl integration for CPU fallback for SSIMULACRA2, and Butteraugli (no CPU support for ColorVideo VDP)
• VMAF v0.6.1 and v1 models for standard, phone, 4K, and HFR viewing scenarios.
• Compare metric curves, statistics, and per-frame scores (per second for ColorVideo VDP).
• Switch instantly between the source and test videos during playback, hold S to show the source, or inspect exact frames.
• Inspect bitrate independently by frame, second, or GOP.
• Detect black bars and handle resolution mismatches automatically.
• Use GPU decoding with independent software fallback per input.
• Calculate two test videos in parallel on many-core CPUs.
• Auto save completed results and auto load results when matching videos are loaded again.

The app can be downloaded below.

https://github.com/4KVCD/VideoMetricsLab/releases

A year ago I watched a fun youtube video about making a model from AV1-encoded files. It uses the motion vectors present in the videos to reconstruct the physical environment filmed.

Today I wanted to test the abilities of LLMs to implement this without access to any of their code (which isn't public anyway). I just gave it the papers and the task. It can basically take a video, or a collection of photos, and return a 3D model of sorts (more like a cloud of points).

Here is the effect:
https://github.com/lukaszsobala/AV1-sfm-reimplemented

Works nicely and uses the GPU for acceleration, if you have one. Zouein used Nvidia cards, and I don't swim in money so I don't have one; this one uses Intel or AMD GPUs (iGPUs as well, or Vulkan which I could not test) for acceleration.

What are your thoughts?

Large Scale Codebase Migrations and Optimizations: Argon agents are working on migrating C/C++ codebases to Rust across Google — scaling from tens of thousands of lines in core libraries like re2, libgav1 up to 800K+ lines for the Fuchsia Zircon kernel. Given the criticality of many of these systems, such large-scale rewrites are undergoing rigorous automated and manual auditing, emulation testing, and review before rolling out to production.

For libgav1, Google's open source software for decoding video, Argon agents took an existing Rust port and replaced 32K lines of SIMD code by running many rounds of profile-guided experiments, studying the compiler's output, producing safe Rust so the compiler would vectorize it automatically. The end result is a memory-safe video decoder that runs 2.7x faster than the Rust port, with identical video output, bringing it closer to the optimized C++.

Hello, I have a quick question or four.

In all of the scenarios below, I am encoding an 8-bit AVC source to a 10-bit SVT-AV1 fork using Staxrip.

1) If I am encoding an AVC/H.264 source that has 8-bit color and I want to use full 10-bit processing, do I always need to run the VaporSynth Filter BitDepth (fmtc) 10?

2) More specifically, I know that the SVT-AV1-Essential fork has --hbd-mds 1 built in by default, while SVT-AV1-Tritium needs it to be manually called. However I assume in both cases I would still use the VS Filter as that's on the "source processing" side while the --hbd-mds 1 argument applies to the "encoding" side, but can someone please confirm?

3) Is there ever a reason to use the VaporSynth Filter BitDepth (fmtc) set to 8? (when using 8-bit AVC to 10-bit AV1)

4) Is there ever a reason to use the --hbd-mds 2 (8/10-bit Hybrid) setting, or should I always use --hbd-mds 1?

Thank you!

Do YouTube videos using the AV1 or VP9 codecs play smoothly in the browser on the Pixel 10 and 11?

Here's an app I wrote to analyze video quality between different encodes. This was inspired by FFMetrics, but I wanted many more features for comparisons, like advanced statistics and an ability to easily and instantly subjectively A/B compare encoded videos with the source. This makes subjective video quality comparisons so much easier when you can compare on a frame by frame basis and while the video is playing, and instantly switch to the source or a different encoded video.

So I decided to write my own app, and I'd like to share it with all of you. I hope you all enjoy.

Let me know what you think, have any issues, or have feature requests.

v1.3 changelog

• Added the window in 20 languages: Simplified and Traditional Chinese, Spanish, Brazilian Portuguese, German, French, Japanese, Russian, Korean, Italian, Polish, Turkish, Arabic, Indonesian, Vietnamese, Ukrainian, Thai, Czech, Hungarian and Dutch. The app opens in Windows' display language, and Settings > Window > Language chooses another. The log, saved results and exported files stay in English.
• Added Intel GPU support for the GPU metrics with Vship's Vulkan build, which runs on any GPU with a Vulkan driver. Settings > GPU metrics > GPU backend chooses the build: Auto (the default) uses CUDA on NVIDIA, HIP on AMD and Vulkan on other GPUs. On Vulkan, SSIMULACRA2 is calculated on the CPU, because Vship 5.1.1's Vulkan build scores it too high (up to 17 points at 4K).
• Updated the GPU metrics to Vship 5.1's API and color handling. Videos tagged BT.2020 SDR, SMPTE 170M (NTSC/DVD), Display P3, ICtCp or YCgCo, and monochrome and alpha videos, are now scored on the GPU instead of falling back to the CPU, and CVVDP no longer fails on them. RGB videos without a transfer tag are now read as sRGB, as Vship's own FFVship does, and their saved GPU scores are recalculated.
• Added a setting to calculate SSIMULACRA2, Butteraugli and CVVDP together in one pass per video (Settings > GPU metrics, off by default). It's better GPU utilization for faster metrics calculations, and it decodes each video once instead of once per metric, but needs much more GPU memory.
• Each metric's score now appears and is saved as soon as it is done, instead of when the whole video is finished. Stopping a run or closing the app loses at most the metric in progress.
• Fixed test frames stamped slightly earlier than the source's being compared with the previous source frame, which gave clusters of near-zero VMAF NEG and XPSNR scores. Each test frame is now compared with the source frame nearest in time. Saved scores of affected videos are kept until they are recalculated.
• Hovering a red Failed cell now says why that metric failed.
• Added a session log under Settings > Storage > Log files, with Export log... (the log files as one .zip) and Copy log (the latest run) buttons.
• The app now checks GitHub for a newer release when it starts, and says so only if there is one. Turn it off in Settings > Window.
• Windows no longer goes to sleep while metrics are being calculated. The screen can still turn off.
• Included various small bug fixes and reliability improvements.

Features:

• Calculate VMAF, VMAF NEG, PSNR, SSIM, XPSNR, SSIMULACRA2, Butteraugli, and ColorVideo VDP for multiple test videos.
• VShip integration for GPU acceleration for ColorVideo VDP, SSIMULACRA2, and Butteraugli
• libjxl integration for CPU fallback for SSIMULACRA2, and Butteraugli (no CPU support for ColorVideo VDP)
• VMAF v0.6.1 and v1 models for standard, phone, 4K, and HFR viewing scenarios.
• Compare metric curves, statistics, and per-frame scores (per second for ColorVideo VDP).
• Switch instantly between the source and test videos during playback, hold S to show the source, or inspect exact frames.
• Inspect bitrate independently by frame, second, or GOP.
• Detect black bars and handle resolution mismatches automatically.
• Use GPU decoding with independent software fallback per input.
• Calculate two test videos in parallel on many-core CPUs.
• Auto save completed results and auto load results when matching videos are loaded again.

The app can be downloaded below.

https://github.com/4KVCD/VideoMetricsLab/releases

Here's an app I wrote to analyze video quality between different encodes. This was inspired by FFMetrics, but I wanted many more features for comparisons, like advanced statistics and an ability to easily and instantly subjectively A/B compare encoded videos with the source. This makes subjective video quality comparisons so much easier when you can compare on a frame by frame basis and while the video is playing, and instantly switch to the source or a different encoded video.

So I decided to write my own app, and I'd like to share it with all of you. I hope you all enjoy.

Let me know what you think, have any issues, or have feature requests.

v1.2.1 bug fix release

• Added a VMAF v1 column with its own model list. The existing VMAF column is now labelled VMAF v0.6.1, and scores saved by earlier versions still load. VMAF v1's Auto model is chosen by the resolution the videos are compared at: 4K and above uses the 4K / 1.5H model, because 1.5 screen heights is the standard viewing distance for 4K (VMAF v0.6.1's 4K model uses it too). Anything below 4K uses the 1080p / 3H model, the standard distance for HD.
• Reworked the run status: each video shows its CPU and GPU metrics progress separately, with elapsed time and a more accurate queue ETA, plus many related bug fixes.
• Cancelling a run will now keep the metrics a video had already finished.
• Cancelling a run will now stay on the Videos tab rather than jump to the Metric Graphs tab.
• Video Compare no longer re-checks the reference each time a different test video is picked.
• Fixed saved VMAF scores not loading on rows set to VMAF model Auto.
• Fixed the metrics ticked in the Videos tab column headers being unticked after a restart.
• Included various small bug fixes and reliability improvements.

v1.2 release:

• Added GPU support for ColorVideo VDP, SSIMULACRA2, and Butteraugli with Vship integration.
• Added CPU fallback for SSIMULACRA2 and Butteraugli with libjxl. ColorVideo VDP has no CPU fallback.
• Added CVVDP per-second scores and graphing alongside its whole-video score.
• Added an Add/remove metrics control to the Videos tab so metric columns can be shown or hidden, and new metrics can be added to completed analyses without recalculating existing results.
• Included various small under-the-hood bug fixes and reliability improvements.

Features:

• Calculate VMAF, VMAF NEG, PSNR, SSIM, XPSNR, SSIMULACRA2, Butteraugli, and ColorVideo VDP for multiple test videos.
• VShip integration for GPU acceleration for ColorVideo VDP, SSIMULACRA2, and Butteraugli
• libjxl integration for CPU fallback for SSIMULACRA2, and Butteraugli (no CPU support for ColorVideo VDP)
• VMAF v0.6.1 and v1 models for standard, phone, 4K, and HFR viewing scenarios.
• Compare metric curves, statistics, and per-frame scores (per second for ColorVideo VDP).
• Switch instantly between the source and test videos during playback, hold S to show the source, or inspect exact frames.
• Inspect bitrate independently by frame, second, or GOP.
• Detect black bars and handle resolution mismatches automatically.
• Use GPU decoding with independent software fallback per input.
• Calculate two test videos in parallel on many-core CPUs.
• Auto save completed results and auto load results when matching videos are loaded again.

The app can be downloaded below.

https://github.com/4KVCD/VideoMetricsLab/releases

Here's an app I wrote to analyze video quality between different encodes. This was inspired by FFMetrics, but I wanted many more features for comparisons, like advanced statistics and an ability to easily and instantly subjectively A/B compare encoded videos with the source. This makes subjective video quality comparisons so much easier when you can compare on a frame by frame basis and while the video is playing, and instantly switch to the source or a different encoded video.

So I decided to write my own app, and I'd like to share it with all of you. I hope you all enjoy.

Let me know what you think, have any issues, or have feature requests.

v1.1.1

• Fixed the metric graph clipping VMAF v1 scores above 100.
• Show the application version in the window title: VideoMetricsLab 1.1.1.
• Omit calculation-library version metadata from non-VMAF cache entries

v1.1 release

• Add VMAF v1 models for standard, phone, 4K, and HFR viewing scenarios.
• Bunch of code refactoring for adding future metrics

Features:

• Calculate VMAF, VMAF NEG, PSNR, SSIM, and XPSNR for multiple test videos.
• VMAF v0.61 and v1 models for standard, phone, 4K, and HFR viewing scenarios.
• Compare metric curves, statistics, and per-frame scores.
• Instant switch between source and encoded video for easy visual A/B comparisons, both frame by frame and during playback, and between different encoded videos.
• Inspect bitrate by frame, second, or GOP without running quality metrics.
• Detect black bars and handle resolution mismatches automatically.
• Use GPU decoding when supported, with independent software fallback per input.
• Calculate two test videos in parallel on many-core CPUs.
• Cache completed results and restore them when matching videos are loaded again.

The app can be downloaded below.

https://github.com/4KVCD/VideoMetricsLab/releases