Eine Sekunde ist kein Anfang

Drei Zahlen standen als Konstante im Quelltext und bestimmten, wie sich
der Server anfühlt. Jetzt stehen sie in der Verwaltung, unter
„Wiedergabe".

**Weiterschauen ab.** Gemessen: `BelongsInContinueWatching` verlangte nur
`Position.Ticks > 0` — ein Tick genügte. Wer im Aufmacher eine Sekunde
hineinschaute, fand den Titel danach in „Fortsetzen". Jetzt gibt es eine
Untergrenze, voreingestellt auf 1½ Minuten.

Was sich dabei **nicht** ändert: die Stelle wird weiter gemerkt. Das ist
der Unterschied zu Jellyfin, um dessentwillen es diesen Server gibt — die
Schwelle entscheidet, ob der Titel in der Reihe steht, nicht ob man ihn
wiederfindet. Nachgemessen: nach dem Umstellen ist „Heat" aus der Reihe
verschwunden und steht weiterhin bei Sekunde 1.

**Gesehen ab.** War 90 % als `const`, ist jetzt 85/90/95.

**Umkodieren.** `-preset veryfast -crf 21` und VAAPI `-qp 23` waren fest
verdrahtet, ohne Einstellung und ohne Umgebungsvariable. Drei Stufen:
Qualität (medium/19, qp 21), Ausgewogen (wie bisher), Tempo
(ultrafast/23, qp 26). Mit dem Warnsatz daneben, und der ist ernst
gemeint: was in Echtzeit laufen muss, darf nicht langsamer rechnen als es
abspielt.

**Und das Vorhandene wird neu bewertet.** `InProgress` ist eine
gespeicherte Spalte — die Bruchrechnung lässt sich nicht nach SQL
übersetzen. Eine neue Schwelle wirkte sonst nur auf künftige Meldungen.
Der Endpunkt läuft deshalb einmal in Stapeln durch und meldet zurück, wie
viele Zeilen das umgeworfen hat: „Übernommen — 2 Einträge wurden neu
bewertet." Ohne diesen Satz änderte sich die Startseite scheinbar von
selbst.

`ProgressRule` bleibt ein reiner Typ: die Regeln kommen als Wert herein.
Nebenbei zieht der doppelte `zeile()`-Bauer nach `teile.ts` — er stand
zweimal wortgleich da.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/tests/Flaro.Media.Tests/HlsArgumenteTests.cs

@@ -24,11 +24,12 @@ public class HlsArgumenteTests
     private static string Zeile(
         IReadOnlyList<ProbedStream> spuren, string schachtel = "mkv",
         int? hoehe = null, int? tonspur = null, double ab = 0,
-        Beschleunigung hardware = Beschleunigung.Software)
+        Beschleunigung hardware = Beschleunigung.Software,
+        Kodierstufe stufe = Kodierstufe.Ausgewogen)
     {
         var plan = Stromentscheid.Fuer(schachtel, spuren, Browser, hoehe);
         return string.Join(' ', HlsArgumente.Fuer(new Stromanfrage(
-            "/medien/film.mkv", "/kratz/sitzung", spuren, plan, tonspur, ab, hardware)));
+            "/medien/film.mkv", "/kratz/sitzung", spuren, plan, tonspur, ab, hardware, stufe)));
     }
 
     // ------------------------------------------------------------------
@@ -264,4 +265,65 @@ public class HlsArgumenteTests
             Assert.That(zeile, Does.Not.Contain("-c:a aac"));
         });
     }
+
+    // ------------------------------------------------------------------
+    // Die Stufe: Bild gegen Tempo
+    // ------------------------------------------------------------------
+
+    /// <summary>Jede Stufe rechnet anders — und „ausgewogen" wie bisher.</summary>
+    ///
+    /// <remarks>
+    /// <b>Preset und CRF gehören zusammen.</b> Ein langsameres Preset holt bei
+    /// demselben CRF Bild heraus; ein schnelleres braucht einen höheren, sonst
+    /// wächst nur die Datei. Deshalb wird hier beides geprüft und nicht eines.
+    /// </remarks>
+    [TestCase(Kodierstufe.Qualitaet, "-preset medium", "-crf 19")]
+    [TestCase(Kodierstufe.Ausgewogen, "-preset veryfast", "-crf 21")]
+    [TestCase(Kodierstufe.Tempo, "-preset ultrafast", "-crf 23")]
+    public void Die_Stufe_entscheidet_ueber_Preset_und_Crf(
+        Kodierstufe stufe, string preset, string crf)
+    {
+        var zeile = Zeile([Bild("hevc"), Ton(1)], stufe: stufe);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zeile, Does.Contain(preset));
+            Assert.That(zeile, Does.Contain(crf));
+        });
+    }
+
+    /// <summary>Die Grafikeinheit kennt kein Preset, nur den Quantisierer.</summary>
+    [TestCase(Kodierstufe.Qualitaet, "-qp 21")]
+    [TestCase(Kodierstufe.Ausgewogen, "-qp 23")]
+    [TestCase(Kodierstufe.Tempo, "-qp 26")]
+    public void Die_Stufe_entscheidet_auch_bei_Vaapi(Kodierstufe stufe, string qp)
+    {
+        var zeile = Zeile([Bild("hevc"), Ton(1)],
+            hardware: Beschleunigung.Vaapi, stufe: stufe);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zeile, Does.Contain("-c:v h264_vaapi"));
+            Assert.That(zeile, Does.Contain(qp));
+        });
+    }
+
+    /// <summary>Beim Umpacken ist die Stufe gegenstandslos.</summary>
+    ///
+    /// <remarks>
+    /// Wird das Bild kopiert, gibt es nichts zu kodieren — dann darf auch kein
+    /// Preset in der Zeile stehen, sonst lehnt ffmpeg sie ab.
+    /// </remarks>
+    [Test]
+    public void Wer_nur_umpackt_bekommt_kein_Preset()
+    {
+        var zeile = Zeile([Bild(), Ton(1)], stufe: Kodierstufe.Qualitaet);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zeile, Does.Contain("-c:v copy"));
+            Assert.That(zeile, Does.Not.Contain("-preset"));
+            Assert.That(zeile, Does.Not.Contain("-crf"));
+        });
+    }
 }