3.16.1: the quality number is named for the encoder, and carried across

The slider said CRF whatever was selected. On VVenC the number is a QP,
on NVENC a CQ, and it kept its value through a change of encoder, which
is the wrong value: x265's CRF 23 is not VVenC's QP 23 (nearer 28) nor
SVT-AV1's CRF 23 (nearer 30).

The label now follows the encoder on the Video tab, the Quality tab, in
the search window, the log, the queue and the output filename (_cq30,
_qp32, _crf23). Switching encoders converts the number to its rough
equivalent on the new scale, from one table anchored on x265 CRF 18/28
with the pairings FFmpeg's guides and the encoders' defaults suggest:
x264 23 = x265 28 = SVT-AV1/libaom 35 = VP9 34 = VVenC 32, NVENC CQ
tracking the software encoder of the same codec. The value is remembered
against the encoder it was set for, so a detour through ProRes or stream
copy converts from the last encoder that had a scale. Presets and saved
settings apply the codec before the number, so theirs is never converted.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QVrEsRs2c81KKkDJGftmQq

Author: hclivess

README.md

@@ -15,6 +15,19 @@ and a grainy film print never wanted the same one.
 
 ![videer processing a queue](thumb.png)
 
+## Changes in 3.16.1
+
+- **The quality number is named for the encoder, and carried across when the encoder changes.** The slider
+  said *CRF* whatever was selected — on VVenC the number is a QP, on NVENC a CQ — and it kept its value
+  through a change of encoder, which is the wrong value: x265's CRF 23 is not VVenC's QP 23 (nearer 28), nor
+  SVT-AV1's CRF 23 (nearer 30). The label now follows the encoder — *CRF*, *CQ* or *QP* — on the Video tab,
+  the Quality tab, in the search window, the log and the queue, and switching encoders converts the number to
+  its rough equivalent on the new scale, using the pairings FFmpeg's own guides and the encoders' defaults
+  suggest: x264 23 ≈ x265 28 ≈ SVT-AV1 / libaom 35 ≈ VP9 34 ≈ VVenC 32, with NVENC's CQ tracking the software
+  encoder of the same codec. Rough is the word — it keeps the *meaning* of the number through a change of
+  encoder, and *Match Source Quality* is still how to get the right one. Output filenames name the knob too:
+  `_cq30` for NVENC and `_qp32` for VVC, `_crf23` as before for the rest.
+
 ## Changes in 3.16
 
 **Two more generations of codec**

config.py

@@ -9,7 +9,7 @@
 
 # Application info
 APP_NAME = "videer"
-APP_VERSION = "3.16"
+APP_VERSION = "3.16.1"
 WINDOW_MIN_WIDTH = 1200
 WINDOW_MIN_HEIGHT = 900
 
@@ -150,6 +150,49 @@
 }
 DEFAULT_CRF_SCALE_MAX = 51
 
+# What the quality number is called on each encoder. One slider drives them all, but "CRF 32" on VVenC is a
+# claim about a control it does not have: x264, x265, the AV1 encoders and VP9 have a CRF, NVENC has a CQ,
+# VVenC has a QP.
+QUALITY_KNOB = {
+    "h264_nvenc": "CQ",
+    "hevc_nvenc": "CQ",
+    "av1_nvenc": "CQ",
+    "libvvenc": "QP",
+}
+
+
+def quality_knob(video_codec) -> str:
+    return QUALITY_KNOB.get(video_codec, "CRF")
+
+
+# Rough equivalence between the encoders' quality scales: for each, the two values that correspond to x265
+# CRF 18 and CRF 28 (about "visually lossless" and "streaming quality"), linear between and beyond. These are
+# the pairings FFmpeg's own guides and the encoders' defaults suggest — the H.265 guide's "x265 CRF 28 looks
+# like x264 CRF 23", SVT-AV1's default 35 and VVenC's default 32 sitting where x265's 28 does — and NVENC's
+# CQ tracks the software encoder of the same codec. Good enough to keep the *meaning* of the number when the
+# encoder changes, which is all it is used for; the right number is still the one Match Source Quality measures.
+QUALITY_SCALE = {
+    "libx264": (15, 23),
+    "libx265": (18, 28),
+    "h264_nvenc": (15, 23),
+    "hevc_nvenc": (18, 28),
+    "av1_nvenc": (25, 35),
+    "libsvtav1": (25, 35),
+    "libaom-av1": (25, 35),
+    "libvpx-vp9": (24, 34),
+    "libvvenc": (24, 32),
+}
+
+
+def convert_quality(value: int, from_codec, to_codec) -> int:
+    """The value on to_codec's scale that means about what `value` meant on from_codec's; clamped to its range"""
+    top = CRF_SCALE_MAX.get(to_codec, DEFAULT_CRF_SCALE_MAX)
+    src, dst = QUALITY_SCALE.get(from_codec), QUALITY_SCALE.get(to_codec)
+    if src and dst and from_codec != to_codec:
+        position = (value - src[0]) / (src[1] - src[0])
+        value = round(dst[0] + position * (dst[1] - dst[0]))
+    return max(0, min(top, int(value)))
+
 # Deinterlacers: display name -> key
 DEINTERLACERS = [
     ("QTGMC (AviSynth+, best quality)", "qtgmc"),

models/file_models.py

@@ -8,6 +8,7 @@
 import logging.handlers
 from collections import deque
 from typing import Optional, List, Dict, Any
+from config import quality_knob
 
 # A damaged source encoded with -err_detect can make FFmpeg emit an error line per packet. Keeping all of them
 # costs gigabytes of RAM per hour and drives the machine into swap, so keep a head (what went wrong first) and
@@ -150,7 +151,8 @@ def set_output_name(self, settings: Dict[str, Any]):
         codec_suffix = f"_{video_codec}_{audio_codec}"
         quality_suffix = ""
         if video_codec in CRF_CODECS:
-            quality_suffix += f"_crf{crf}"
+            # ...and named for what it is: a CQ on NVENC, a QP on VVenC, a CRF elsewhere
+            quality_suffix += f"_{quality_knob(video_codec).lower()}{crf}"
         if audio_codec not in BITRATELESS_AUDIO_CODECS:
             quality_suffix += f"_abr{abr}"
 

modules/process_manager.py

@@ -24,7 +24,7 @@
 from utils.file_utils import FileOperations
 from utils import childproc
 from config import (CONTAINER_VIDEO_CODECS, CONTAINER_AUDIO_CODECS, VIDEO_CODEC_CONTAINERS,
-                    DEFAULT_QUALITY_METRIC)
+                    DEFAULT_QUALITY_METRIC, quality_knob)
 
 
 # FFmpeg run with -progress pipe:1 reports continuously while it is working. Total silence for this long means
@@ -623,7 +623,8 @@ def _match_quality(self, file: VideoFile, index: int) -> Optional[int]:
         # top would be a cycle.
         from modules.quality_analyzer import QualitySearch, format_score
 
-        file.log_info("Quality match: searching for this file's own CRF")
+        knob = quality_knob(self.settings.get('video_codec'))
+        file.log_info(f"Quality match: searching for this file's own {knob}")
         self.info_signal.emit(f"Matching quality for {file.filename}…")
         self._phase_start = time.time()
 
@@ -656,9 +657,9 @@ def on_step(done: int, expected: int):
             if not self.should_stop:
                 reason = search.error or "no result"
                 file.log_info(f"Quality match did not finish ({reason}); "
-                              f"using the queue's CRF {self.settings.get('crf')}")
+                              f"using the queue's {knob} {self.settings.get('crf')}")
                 self.info_signal.emit(f"{file.filename}: quality match failed ({reason}) — "
-                                      f"encoding at CRF {self.settings.get('crf')}")
+                                      f"encoding at {knob} {self.settings.get('crf')}")
             return None
 
         recommended = result.get('recommended')
@@ -668,20 +669,20 @@ def on_step(done: int, expected: int):
             # at it — for a target none of them met — is the opposite of what the search is for.
             probes = result.get('probes') or []
             best = max(probes, key=lambda p: p['score']) if probes else None
-            detail = (f"the best in CRF {search.crf_low}–{search.crf_high} was "
-                      f"{format_score(result['metric'], best['score'])} at CRF {best['crf']}"
+            detail = (f"the best in {knob} {search.crf_low}–{search.crf_high} was "
+                      f"{format_score(result['metric'], best['score'])} at {knob} {best['crf']}"
                       if best else "nothing measurable")
-            file.log_info(f"Quality match: no CRF reached {result['target']:g} ({detail}); "
-                          f"using the queue's CRF {self.settings.get('crf')}")
-            self.info_signal.emit(f"{file.filename}: no CRF reached the target — {detail}; "
-                                  f"encoding at the queue's CRF {self.settings.get('crf')}")
+            file.log_info(f"Quality match: no {knob} reached {result['target']:g} ({detail}); "
+                          f"using the queue's {knob} {self.settings.get('crf')}")
+            self.info_signal.emit(f"{file.filename}: no {knob} reached the target — {detail}; "
+                                  f"encoding at the queue's {knob} {self.settings.get('crf')}")
             for note in result.get('notes', []):
                 file.log_info(f"[quality] {note}")
             return None
 
         crf = int(recommended['crf'])
         file.matched_crf = crf
-        summary = (f"Quality match: CRF {crf} at "
+        summary = (f"Quality match: {knob} {crf} at "
                    f"{format_score(result['metric'], recommended['score'])} "
                    f"(target {result['target']:g}, pooled by {result['pool']})")
         if result.get('estimated_size'):
@@ -1105,7 +1106,7 @@ def validate_settings(settings: Dict[str, Any]) -> List[str]:
                           "the frame count and will make the comparison fail.")
         if settings.get('auto_match_quality'):
             if video_codec not in CRF_ENCODERS:
-                issues.append(f"Automatic CRF matching needs a CRF-based encoder; '{video_codec}' has no CRF, "
+                issues.append(f"Automatic quality matching needs an encoder with a CRF, CQ or QP; '{video_codec}' has none, "
                               f"so every file will use the queue's setting instead.")
             elif settings.get('use_avisynth'):
                 issues.append("Automatic CRF matching samples the source directly, without the AviSynth+ "