The target belongs to the metric, not to the search

A quality search on a machine without libvmaf recommended the bottom of
the CRF range on every file and reported the target as never reached.

The settings said VMAF >= 95. The FFmpeg in use had no libvmaf, so the
search quietly measured with SSIM instead — and kept the 95. SSIM counts
to 1.0. Every probe read below target, the bisection walked to the bottom
of the range and recommended it, file after file, for a reason nothing on
screen explained. The ordinary Windows 'essentials' FFmpeg build has no
libvmaf, so this was the common case, not the exotic one.

A number outside a metric's own range is no longer treated as a target:
the metric's default is used instead, in the search, in the Quality tab
and in loaded presets. The tab no longer selects a metric this build
cannot compute and says why when it substitutes; a search that has to
substitute reports it in its progress and in its result. And a search that
reaches nothing now names what it did reach, rather than leaving the
unreachable number unstated.

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

Author: hclivess

README.md

@@ -15,6 +15,26 @@ and a grainy film print never wanted the same one.
 
 ![videer processing a queue](thumb.png)
 
+## Changes in 3.13.4
+
+- **The quality search recommended the bottom of the CRF range on every file, and said the target was never
+  reached.** A target belongs to the metric it was set for: VMAF counts to 100, SSIM to 1.0, XPSNR in
+  decibels. When the FFmpeg in use has no `libvmaf` — the ordinary Windows "essentials" build has none —
+  videer quietly measured with SSIM instead but kept the number 95 that had been set for VMAF. SSIM cannot
+  reach 95; nothing can. So every probe read *below target*, the search walked to the bottom of the range and
+  recommended it, on file after file, for a reason nothing on screen explained.
+- A target from another metric's scale is now refused outright and that metric's own default used instead —
+  in the search, in the Quality tab and in loaded presets alike. The Quality tab no longer selects a metric
+  this build cannot compute, and says why when it has to choose another one. A search that has to substitute
+  says so in its progress and in its result.
+- **"No CRF reached the target" now says what *was* reachable** — "the best anything in that range managed was
+  SSIM 0.9721 at CRF 16, so a target above that is out of reach for this source" — instead of leaving the
+  number that could not be met unstated.
+
+For VMAF specifically: it needs an FFmpeg built with `libvmaf`. On Windows the gyan.dev *full* builds and the
+BtbN builds have it; the *essentials* build does not.
+
+
 ## Changes in 3.13.3
 
 - **A subtitle track no longer takes the whole file down with it.** Encoding a subtitled MP4 to MKV failed

config.py

@@ -9,7 +9,7 @@
 
 # Application info
 APP_NAME = "videer"
-APP_VERSION = "3.13.3"
+APP_VERSION = "3.13.4"
 WINDOW_MIN_WIDTH = 1200
 WINDOW_MIN_HEIGHT = 900
 

modules/preset_manager.py

@@ -238,7 +238,8 @@ def apply_settings(self, settings: Dict[str, Any]):
         if 'quality_metric' in settings:
             ui._select_quality_metric(settings['quality_metric'])
         if 'quality_target' in settings:
-            ui.controls['quality_target'].setValue(float(settings['quality_target']))
+            # After the metric, and through the guard: a target saved for VMAF is not a target for SSIM
+            ui.set_quality_target(settings['quality_target'])
         if 'quality_pool' in settings:
             index = ui.controls['quality_pool'].findData(settings['quality_pool'])
             if index >= 0:

modules/quality_analyzer.py

@@ -124,6 +124,33 @@ def choose_metric(preferred: str = DEFAULT_QUALITY_METRIC) -> str:
     return DEFAULT_QUALITY_METRIC
 
 
+def metric_target(metric: str, value: Any = None) -> float:
+    """
+    A target that means something on this metric's scale.
+
+    VMAF counts to 100, SSIM to 1.0, XPSNR in decibels. A number carried over from another metric is not a
+    demanding target, it is an impossible one: 95 asked of SSIM can never be met, so every probe reads "below
+    target", the search walks to the bottom of the CRF range and recommends it — on every file, for a reason
+    nothing on screen explains. Anything outside the metric's own range is therefore not a target at all, and
+    the metric's default is used instead.
+    """
+    spec = metric_spec(metric)
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        return float(spec['default_target'])
+    low, high = spec['range']
+    return number if low <= number <= high else float(spec['default_target'])
+
+
+def substitution_note(requested: str, used: str, target: float) -> str:
+    """Why the search is not measuring what it was asked to measure"""
+    asked, actual = metric_spec(requested), metric_spec(used)
+    return (f"This FFmpeg has no {asked['filter']} filter, so {asked['label']} cannot be measured — "
+            f"searching on {actual['label']} \u2265 {target:g}{actual['unit']} instead. VMAF and MS-SSIM need "
+            f"an FFmpeg built with libvmaf; SSIM, PSNR and XPSNR are in every build.")
+
+
 def format_score(metric: str, value: Optional[float]) -> str:
     """'VMAF 95.2' / 'PSNR 42.10 dB' — the number with enough context to be read on its own"""
     if value is None:
@@ -299,9 +326,12 @@ def __init__(self, filepath: str, settings: Dict[str, Any],
         self._should_stop = should_stop or (lambda: False)
         self._on_process = on_process
 
-        self.metric = choose_metric(self.settings.get('quality_metric', DEFAULT_QUALITY_METRIC))
-        self.target = float(self.settings.get('quality_target')
-                            or metric_spec(self.metric)['default_target'])
+        requested = self.settings.get('quality_metric', DEFAULT_QUALITY_METRIC)
+        self.metric = choose_metric(requested)
+        # A target set for a metric this build cannot compute belongs to that metric, not to the stand-in
+        self.substituted_for = requested if (requested != self.metric and requested in QUALITY_METRICS) else None
+        self.target = metric_target(self.metric,
+                                    None if self.substituted_for else self.settings.get('quality_target'))
         self.pool = self.settings.get('quality_pool', DEFAULT_QUALITY_POOL)
         self.sample_count = int(self.settings.get('quality_samples') or QUALITY_SAMPLE_COUNT)
         self.sample_seconds = float(self.settings.get('quality_sample_seconds') or QUALITY_SAMPLE_SECONDS)
@@ -377,6 +407,8 @@ def _search(self) -> Optional[Dict[str, Any]]:
             f"{metric_spec(self.metric)['label']} ≥ {self.target:g} "
             f"({pool_label(self.pool).lower()}), CRF {self.crf_low}–{self.crf_high} "
             f"— about {probes_expected} probes.")
+        if self.substituted_for:
+            self._progress(substitution_note(self.substituted_for, self.metric, self.target))
 
         self._workdir = tempfile.mkdtemp(prefix=WORKDIR_PREFIX)
 
@@ -542,15 +574,21 @@ def _summarize(self, best: Optional[Dict[str, Any]], results: Dict[int, Dict[str
         """Turn the probes into a recommendation plus the caveats that go with it"""
         source_size = info.get('size')
         notes: List[str] = []
+        if self.substituted_for:
+            notes.append(substitution_note(self.substituted_for, self.metric, self.target))
 
         if best is None:
             # Nothing in the range held the target. The closest attempt is the honest recommendation, and the
             # reason is almost always grain or noise: detail that costs a great many bits to reproduce.
             closest = max(results.values(), key=lambda p: p['score']) if results else None
+            best_line = (f" The best anything in that range managed was "
+                         f"{format_score(self.metric, closest['score'])} at CRF {closest['crf']}, so a target "
+                         f"above that is out of reach for this source." if closest else "")
             notes.append(
-                f"No CRF in {self.crf_low}–{self.crf_high} reached the target. The source is probably grainy, "
-                f"noisy or already heavily compressed — quality that expensive to keep is a sign that "
-                f"re-encoding it will not save much.")
+                f"No CRF in {self.crf_low}–{self.crf_high} reached "
+                f"{format_score(self.metric, self.target)}.{best_line} A grainy, noisy or already heavily "
+                f"compressed source is the usual reason — detail that expensive to keep is also a sign "
+                f"that re-encoding it will not save much.")
             recommended = closest
         else:
             recommended = best
@@ -847,8 +885,7 @@ def _load_from_settings(self, settings: Dict[str, Any]):
         """Start from the Quality tab, so the dialog and the batch matcher agree until told otherwise"""
         index = self.metric_combo.findData(self.metric_key)
         self.metric_combo.setCurrentIndex(index if index >= 0 else 0)
-        self._configure_target(float(settings.get('quality_target')
-                                     or metric_spec(self.metric_key)['default_target']))
+        self._configure_target(metric_target(self.metric_key, settings.get('quality_target')))
 
         pool_index = self.pool_combo.findData(settings.get('quality_pool', DEFAULT_QUALITY_POOL))
         self.pool_combo.setCurrentIndex(pool_index if pool_index >= 0 else 0)

modules/ui_manager.py

@@ -24,7 +24,9 @@
                    DEFAULT_QUALITY_POOL)
 from modules.process_manager import format_duration, format_size
 from modules.quality_analyzer import (QualityMatchDialog, choose_metric, fill_metric_combo,
-                                      format_score, metric_spec, resolved_search_range)
+                                      metric_target, format_score, metric_spec,
+                                      resolved_search_range)
+from config import QUALITY_METRICS
 from modules.repair_manager import RepairDialog
 
 
@@ -908,6 +910,10 @@ def _select_quality_metric(self, metric: str):
         well would re-run it with no remembered value and overwrite the target the user last set for this
         metric with the factory one.
         """
+        # A metric this build cannot compute is in the list but greyed out; selecting it anyway would leave
+        # the tab showing a target that nothing measures against. Settle for one that can be measured.
+        requested = metric
+        metric = choose_metric(metric)
         combo = self.controls['quality_metric']
         index = combo.findData(metric)
         if index < 0:
@@ -919,6 +925,18 @@ def _select_quality_metric(self, metric: str):
             self._current_quality_metric = metric
             self._configure_quality_target(metric, self._quality_targets_seen.get(metric))
 
+        if metric != requested and requested in QUALITY_METRICS:
+            # Say it where the choice is made, rather than leaving a greyed-out entry to explain itself
+            self.quality_metric_note.setText(
+                f"{metric_spec(requested)['label']} needs an FFmpeg built with "
+                f"{metric_spec(requested)['filter']}, and this one has no such filter — "
+                f"{metric_spec(metric)['label']} selected instead.")
+
+    def set_quality_target(self, value: Any):
+        """Set the target the Quality tab shows, but only if it is a score the current metric can produce"""
+        metric = self.controls['quality_metric'].currentData() or DEFAULT_QUALITY_METRIC
+        self.controls['quality_target'].setValue(metric_target(metric, value))
+
     def _configure_quality_target(self, metric: str, value: Optional[float] = None):
         """0-100, 0-1 and decibels share no numbers: the target control is rebuilt per metric"""
         spec = metric_spec(metric)