Mein Prüfbild war dunkler als jeder echte Abspann

Die Abspannsuche lief gegen eine feste Schwelle von 35. Die stammte aus
einem erzeugten Prüfbild mit 0,8 Prozent weisser Fläche — Helligkeit 18,
weit unter 35, alles schien zu stimmen. Ein echter Abspann hat mehr
Schrift.

Nachgemessen an 1080p mit zwei Spalten Namen, durch dieselbe ffmpeg-Kette
wie im Betrieb:

    Handlung                              126
    Abspann, realistische Schriftdichte     32
    Abspann, dicht gesetzt                  47

Die Fünfunddreissig lag mitten zwischen den beiden Abspannfällen und
schnitt sie auseinander. Dasselbe noch einmal an der erzeugten Prüfdatei,
nachdem ihr Abspann realistische Dichte bekam: 40,2 — und die Prüfung,
die vorher grün war, wurde rot. Das ist der Fehler, lokal reproduziert.

**Dunkel ist keine absolute Grösse.** Entscheidend ist nicht, wie dunkel
der Abspann ist, sondern dass er viel dunkler ist als das, was davor
lief. Gemessen wird jetzt gegen den Grundton des Films — das obere
Viertel der Proben, mal 0,55. Die alte Schwelle bleibt als Boden, damit
ein durchweg dämmriger Film nicht in Fehlalarme rutscht.

**Und die Logotafel.** Die Suche verlangte, dass die allerletzte Probe
dunkel ist. Hinter dem Abspann steht bei vielen Produktionen noch eine
Tafel — Sender, Studio, Förderer —, oft hell. Ein einziges weisses
Schlussbild machte damit den ganzen Abspann unsichtbar. Zwanzig Sekunden
sind jetzt erlaubt, in Sekunden gezählt und nicht in Proben: wie viele
Messpunkte auf eine Tafel fallen, hängt allein an der Schlüsselbilddichte
der Datei.

**Ein Lauf ohne Fund sagt jetzt, warum.** Anzahl Proben, Schwelle,
letzte Probe — ohne diese drei Zahlen ist „kein Abspann erkannt" keine
Auskunft, und man rät wieder.

Sieben neue Prüfungen mit den gemessenen Werten. Die beiden
entscheidenden sind mit der alten Schwelle rot; gegengeprüft, nicht
behauptet.

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

server/tests/Flaro.Core.Tests/AbspannkanteTests.cs

@@ -114,7 +114,7 @@ public class AbspannkanteTests
         const double echteKante = 417.3;
         var sonden = 0;
 
-        var kante = await Abspannkante.VerfeinernAsync(410, 420, Regeln, stelle =>
+        var kante = await Abspannkante.VerfeinernAsync(410, 420, Regeln.Dunkelschwelle, stelle =>
         {
             sonden++;
             return Task.FromResult<double?>(stelle >= echteKante ? 18 : 125);
@@ -134,7 +134,7 @@ public class AbspannkanteTests
     public async Task Ohne_Antwort_bleibt_es_beim_groben_Fund()
     {
         var kante = await Abspannkante.VerfeinernAsync(
-            410, 420, Regeln, _ => Task.FromResult<double?>(null));
+            410, 420, Regeln.Dunkelschwelle, _ => Task.FromResult<double?>(null));
 
         Assert.That(kante, Is.EqualTo(420));
     }
@@ -144,7 +144,7 @@ public class AbspannkanteTests
     public async Task Ein_enger_Bereich_wird_nicht_angefasst()
     {
         var sonden = 0;
-        var kante = await Abspannkante.VerfeinernAsync(418, 420, Regeln, _ =>
+        var kante = await Abspannkante.VerfeinernAsync(418, 420, Regeln.Dunkelschwelle, _ =>
         {
             sonden++;
             return Task.FromResult<double?>(18);
@@ -157,3 +157,156 @@ public class AbspannkanteTests
         });
     }
 }
+
+/// <summary>Die Schwelle an gemessenen Abspannwerten, nicht an erfundenen.</summary>
+///
+/// <remarks>
+/// <para>
+/// <b>Der Fehler, für den diese Prüfungen stehen.</b> Die Erkennung lief
+/// gegen eine feste Schwelle von 35, und die stammte aus einem Prüfbild
+/// mit 0,8 Prozent weisser Fläche — Helligkeit 18. Ein echter Abspann hat
+/// mehr Schrift.
+/// </para>
+/// <para>
+/// <b>Nachgemessen</b> an erzeugtem 1080p-Material mit zwei Spalten Namen,
+/// durch dieselbe ffmpeg-Kette wie im Betrieb
+/// (<c>scale=160:-2,signalstats</c>):
+/// </para>
+/// <list type="table">
+///   <item><description>Handlung: <b>126</b></description></item>
+///   <item><description>Abspann, realistische Schriftdichte (1,3 % Weiss): <b>32</b></description></item>
+///   <item><description>Abspann, dicht gesetzt (9,5 % Weiss): <b>47</b></description></item>
+/// </list>
+/// <para>
+/// Die Fünfunddreissig lag also mitten zwischen den beiden Abspannfällen.
+/// Seitdem ist sie nur noch der Boden; gemessen wird gegen den Grundton
+/// des Films.
+/// </para>
+/// </remarks>
+public class AbspannSchwellenTests
+{
+    private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
+
+    /// <summary>Ein Suchfenster, wie es im Betrieb entsteht.</summary>
+    ///
+    /// <remarks>
+    /// Zwanzig Minuten vor dem Ende einer Folge von fünfundvierzig, an den
+    /// Schlüsselbildern abgetastet — also alle fünf Sekunden eine Probe.
+    /// </remarks>
+    private static List<Bildprobe> Fenster(double abspannAb, double imAbspann, double imInhalt = 126)
+    {
+        var proben = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += 5)
+            proben.Add(new Bildprobe(t, t < abspannAb ? imInhalt : imAbspann));
+        return proben;
+    }
+
+    /// <summary>Der Fall, an dem es scheiterte: ein schriftreicher Abspann.</summary>
+    ///
+    /// <remarks>
+    /// Mit der alten festen Schwelle von 35 ist diese Prüfung rot: 47 gilt
+    /// dort als hell, und die Folge bekam keine Marke.
+    /// </remarks>
+    [Test]
+    public void Ein_dichter_Abspann_bei_siebenundvierzig_wird_gefunden()
+    {
+        var proben = Fenster(abspannAb: 2340, imAbspann: 47);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2340).Within(5));
+    }
+
+    [Test]
+    public void Ein_schlanker_Abspann_bei_zweiunddreissig_wird_gefunden()
+    {
+        var proben = Fenster(abspannAb: 2340, imAbspann: 32);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2340).Within(5));
+    }
+
+    /// <summary>Und die Schwelle liegt zwischen beidem, nicht daneben.</summary>
+    [Test]
+    public void Die_Schwelle_liegt_zwischen_Handlung_und_Abspann()
+    {
+        var schwelle = Abspannkante.Schwelle(Fenster(2340, 47), Regeln);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(schwelle, Is.GreaterThan(47), "ein dichter Abspann muss darunter liegen");
+            Assert.That(schwelle, Is.LessThan(126), "die Handlung muss darüber liegen");
+        });
+    }
+
+    /// <summary>**Ein dunkler Film wird dadurch nicht zum Dauerabspann.**</summary>
+    ///
+    /// <remarks>
+    /// Eine relative Schwelle kann nach unten entgleisen: bei einem Film,
+    /// der durchweg dämmrig ist, wäre „etwas mehr als halb so hell" bald
+    /// jede Nachtszene. Deshalb bleibt <c>Dunkelschwelle</c> als Boden —
+    /// hier sorgt sie dafür, dass eine Schlussszene bei 40 nichts auslöst.
+    /// </remarks>
+    [Test]
+    public void Eine_duestere_Schlussszene_ist_kein_Abspann()
+    {
+        var proben = Fenster(abspannAb: 2340, imAbspann: 40, imInhalt: 55);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+    }
+
+    /// <summary>Helle Handlung bis zum Ende bleibt Handlung.</summary>
+    [Test]
+    public void Ohne_dunkles_Ende_kein_Fund()
+    {
+        var proben = Fenster(abspannAb: double.MaxValue, imAbspann: 0);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+    }
+}
+
+/// <summary>Was hinter dem Abspann noch kommt.</summary>
+///
+/// <remarks>
+/// <b>Der Fehler, für den diese Prüfungen stehen.</b> Die Suche verlangte,
+/// dass die allerletzte Probe dunkel ist. Hinter dem Abspann steht bei
+/// vielen Produktionen aber noch eine Logotafel — Sender, Studio,
+/// Förderer —, oft hell. Ein einziges weisses Schlussbild machte damit den
+/// ganzen Abspann unsichtbar.
+/// </remarks>
+public class AbspannSchlusstafelTests
+{
+    private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
+
+    private static List<Bildprobe> Fenster(double abspannAb, double tafelAb = double.MaxValue)
+    {
+        var proben = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += 5)
+        {
+            var hell = t >= tafelAb ? 210 : t < abspannAb ? 126 : 32;
+            proben.Add(new Bildprobe(t, hell));
+        }
+        return proben;
+    }
+
+    /// <summary>Eine helle Tafel am Schluss verdeckt den Abspann nicht.</summary>
+    [Test]
+    public void Eine_Logotafel_am_Ende_zaehlt_nicht_dagegen()
+    {
+        // Fünfzehn Sekunden weiss hinter dem Abspann.
+        var proben = Fenster(abspannAb: 2340, tafelAb: 2690);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2340).Within(5));
+    }
+
+    /// <summary>Eine lange helle Strecke am Ende schon.</summary>
+    ///
+    /// <remarks>
+    /// Die Nachsicht hat eine Grenze, sonst fände die Suche hinter jeder
+    /// Schwarzblende einen Abspann und hinge die halbe Handlung daran.
+    /// </remarks>
+    [Test]
+    public void Eine_lange_helle_Strecke_am_Ende_bricht_ab()
+    {
+        var proben = Fenster(abspannAb: 2340, tafelAb: 2600);
+
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+    }
+}

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

@@ -82,7 +82,13 @@ public class BildabtasterLaufTests
                 "-hide_banner", "-loglevel", "error", "-y",
                 "-f", "lavfi", "-i", "testsrc2=size=640x360:rate=24:duration=90",
                 "-f", "lavfi", "-i", "color=c=black:s=640x360:r=24:d=60",
-                "-f", "lavfi", "-i", "color=c=white:s=180x14:r=24:d=60",
+                // **So viel weisse Fläche hat ein echter Abspann.**
+                // Nachgemessen an 1080p mit zwei Spalten Namen: rund ein
+                // Zehntel der Fläche, und damit YAVG um 45 statt um 18.
+                // Mit dem schmalen Balken von vorher war dieses Prüfbild
+                // dunkler als jeder wirkliche Abspann — und genau deshalb
+                // blieb die zu enge Schwelle so lange unbemerkt.
+                "-f", "lavfi", "-i", "color=c=white:s=400x76:r=24:d=60",
                 "-filter_complex",
                 "[1][2]overlay=x=230:y='H-mod(t*45,H+h)'[cr];[0][cr]concat=n=2:v=1:a=0[v]",
                 "-map", "[v]", "-c:v", "libx264", "-preset", "ultrafast",
@@ -127,7 +133,7 @@ public class BildabtasterLaufTests
         var hell = Abspannkante.HellDavor(proben, grob!.Value, Abspannregeln.Vorgabe) ?? 0;
         var abtaster = Abtaster();
         var kante = await Abspannkante.VerfeinernAsync(
-            hell, grob.Value, Abspannregeln.Vorgabe,
+            hell, grob.Value, Abspannkante.Schwelle(proben, Abspannregeln.Vorgabe),
             stelle => abtaster.HelligkeitAsync(_datei, stelle));
 
         Assert.That(kante, Is.EqualTo(90).Within(4),
@@ -143,17 +149,38 @@ public class BildabtasterLaufTests
         Assert.That(Abspannkante.Suchen(proben, Abspannregeln.Vorgabe), Is.Null);
     }
 
-    /// <summary>Eine einzelne Sekunde lässt sich messen.</summary>
+    /// <summary>Eine einzelne Sekunde lässt sich messen — und liegt richtig.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>Hier stand der Fehler, und hier wurde er sichtbar.</b> Diese
+    /// Prüfung verlangte früher, dass der Abspann unter der festen
+    /// Schwelle von 35 liegt — mit dem schmalen Balken von damals lag er
+    /// bei 18, und alles schien zu stimmen. Mit realistischer
+    /// Schriftdichte misst dieselbe Stelle <b>40</b>. Die feste Schwelle
+    /// hätte diesen Abspann also für Handlung gehalten, und genau das
+    /// geschah im Bestand.
+    /// </para>
+    /// <para>
+    /// Gemessen wird deshalb gegen die Schwelle, die der Film selbst
+    /// vorgibt — und die liegt hier zwischen 40 und der Handlung.
+    /// </para>
+    /// </remarks>
     [Test]
-    public async Task Eine_Sekunde_im_Abspann_ist_dunkel()
+    public async Task Eine_Sekunde_im_Abspann_liegt_unter_der_Schwelle()
     {
+        var proben = await Abtaster().UeberblickAsync(_datei, ab: 30, dauer: 120);
+        var schwelle = Abspannkante.Schwelle(proben, Abspannregeln.Vorgabe);
+
         var dunkel = await Abtaster().HelligkeitAsync(_datei, bei: 120);
         var hell = await Abtaster().HelligkeitAsync(_datei, bei: 40);
 
         Assert.Multiple(() =>
         {
-            Assert.That(dunkel, Is.Not.Null.And.LessThan(Abspannregeln.Vorgabe.Dunkelschwelle));
-            Assert.That(hell, Is.Not.Null.And.GreaterThan(Abspannregeln.Vorgabe.Dunkelschwelle));
+            Assert.That(dunkel, Is.Not.Null.And.LessThan(schwelle));
+            Assert.That(hell, Is.Not.Null.And.GreaterThan(schwelle));
+            Assert.That(dunkel, Is.GreaterThan(Abspannregeln.Vorgabe.Dunkelschwelle),
+                "dieser Abspann ist heller als der alte feste Wert — darum ging es");
         });
     }
 }