Ein Abspann darf aus Stücken bestehen

Zwei Fälle fielen durch, beide am Bestand gesehen. Bei einem Marvel-Film
liegt hinter dem Abspann eine Post-Credit-Szene: die Suche begann am
Dateiende, fand nur den kurzen Rest dahinter und verwarf ihn als zu kurz.
Und ein Abspann, den eine Szene in der Mitte teilt, zerfiel in zwei
Reste, von denen keiner lang genug war. Dieselbe Ursache: der Abspann
musste eine zusammenhängende dunkle Strecke bis zum Dateiende sein.

Jetzt bildet die Suche Läufe, fasst sie über Lücken bis vier Minuten
zusammen — so lang ist die längste bekannte Post-Credit-Szene plus
Reserve — und lässt die **Summe** über die Mindestlänge entscheiden statt
jedes einzelne Stück. Ein Lauf unter fünfzehn Sekunden ist eine Blende
und zählt nicht mit.

Dafür mussten die eindeutigen Indizes über (Titel, Art) weichen; sie
standen mit dem Vermerk „eine Art einmal je Titel" da, und genau das
stimmt nicht mehr. `SchreibenAsync` ersetzt jetzt die Menge, statt eine
Zeile umzuschreiben — das ist der einzige Weg, der in beide Richtungen
stimmt, wenn aus zwei Stücken wieder eines wird.

**Drei Stellen trugen das nicht.** Im Web hiess „Abspann überspringen"
bei einem Film immer Schluss — beim ersten von zwei Stücken bekäme
niemand die Szene je zu sehen; geschlossen wird jetzt nur, wenn nichts
mehr folgt. Auf iOS verwarf der Spieler die Abspannmarke eines Films
ganz; diese Regel gehört nicht dorthin, sondern auf den Server, und ist
ersatzlos weg. Und die Gesehen-Schwelle nahm irgendeine Abspannzeile —
ohne `OrderBy` entschied die Datenbank; gemeint ist immer die früheste.

Dazu der Schalter „Zusätzliche Szenen mit überspringen" (Vorgabe aus) bei
den Geräteeinstellungen, und ein Messwerkzeug: ein Knopf auf der
Filmseite lädt die Kurve je Schlüsselbild als Tabelle — Dunkelanteil des
ganzen Bildes und der beiden Randstreifen. Ob bei Outtakes im Abspann die
Ränder dunkel bleiben, ist eine Vermutung; bevor daraus eine Schwelle
wird, will ich die Zahlen sehen.

Fünf neue Prüfungen, darunter die wichtigste: ein durchgehender Abspann
bleibt ein Stück.

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

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

@@ -15,6 +15,16 @@ public class AbspannkanteTests
 {
     private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
 
+    /// <summary>Der Anfang des ersten Stücks — oder nichts.</summary>
+    ///
+    /// <remarks>
+    /// Die meisten Prüfungen hier fragen nur „wo fängt der Abspann an".
+    /// Seit die Suche Stücke zurückgibt, steht das in <c>[0].Von</c>; ein
+    /// Helfer hält die Erwartungen lesbar, statt überall zu indizieren.
+    /// </remarks>
+    private static double? Anfang(IReadOnlyList<Abspannstück> stücke) =>
+        stücke.Count == 0 ? null : stücke[0].Von;
+
     /// <summary>Eine Reihe von Messpunkten im Abstand von zehn Sekunden.</summary>
     ///
     /// <param name="abspannAb">Ab wann dunkel. <c>null</c> heisst: nie.</param>
@@ -31,7 +41,7 @@ public class AbspannkanteTests
     {
         var proben = Reihe(0, 600, abspannAb: 420);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(420));
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.EqualTo(420));
     }
 
     /// <summary>Ein Film, der hell endet, hat keinen erkennbaren Abspann.</summary>
@@ -44,7 +54,7 @@ public class AbspannkanteTests
     [Test]
     public void Ohne_dunkles_Ende_kein_Fund()
     {
-        Assert.That(Abspannkante.Suchen(Reihe(0, 600, abspannAb: null), Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(Reihe(0, 600, abspannAb: null), Regeln)), Is.Null);
     }
 
     /// <summary>Eine Schwarzblende mitten im Film zählt nicht.</summary>
@@ -54,7 +64,7 @@ public class AbspannkanteTests
         var proben = Reihe(0, 600, abspannAb: null);
         for (var i = 20; i < 30; i++) proben[i] = proben[i] with { Dunkelanteil = 92 };
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null,
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.Null,
             "sie hält nicht bis zum Ende durch");
     }
 
@@ -70,7 +80,7 @@ public class AbspannkanteTests
         for (var i = proben.Count - 5; i < proben.Count; i++)
             proben[i] = proben[i] with { Dunkelanteil = 0 };
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.Null);
     }
 
     /// <summary>Eine helle Schrifttafel mittendrin bricht die Strecke nicht.</summary>
@@ -89,21 +99,21 @@ public class AbspannkanteTests
         var proben = Reihe(0, 600, abspannAb: 420);
         proben[50] = proben[50] with { Dunkelanteil = 0 };
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(420));
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.EqualTo(420));
     }
 
     /// <summary>Zwanzig Sekunden Dunkelheit sind kein Abspann.</summary>
     [Test]
     public void Zu_kurz_zaehlt_nicht()
     {
-        Assert.That(Abspannkante.Suchen(Reihe(0, 600, abspannAb: 580), Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(Reihe(0, 600, abspannAb: 580), Regeln)), Is.Null);
     }
 
     /// <summary>Ein halber Film im Dunkeln ist ein Fehlfund.</summary>
     [Test]
     public void Zu_lang_zaehlt_auch_nicht()
     {
-        Assert.That(Abspannkante.Suchen(Reihe(0, 3600, abspannAb: 600), Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(Reihe(0, 3600, abspannAb: 600), Regeln)), Is.Null);
     }
 
     [Test]
@@ -199,6 +209,16 @@ public class AbspannAnteilTests
 {
     private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
 
+    /// <summary>Der Anfang des ersten Stücks — oder nichts.</summary>
+    ///
+    /// <remarks>
+    /// Die meisten Prüfungen hier fragen nur „wo fängt der Abspann an".
+    /// Seit die Suche Stücke zurückgibt, steht das in <c>[0].Von</c>; ein
+    /// Helfer hält die Erwartungen lesbar, statt überall zu indizieren.
+    /// </remarks>
+    private static double? Anfang(IReadOnlyList<Abspannstück> stücke) =>
+        stücke.Count == 0 ? null : stücke[0].Von;
+
     /// <summary>Ein Suchfenster, wie es im Betrieb entsteht.</summary>
     ///
     /// <remarks>
@@ -220,7 +240,7 @@ public class AbspannAnteilTests
     {
         var proben = Fenster(abspannAb: 2340, imAbspann: 84);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2340.0).Within(5));
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.EqualTo(2340.0).Within(5));
     }
 
     [Test]
@@ -228,7 +248,7 @@ public class AbspannAnteilTests
     {
         var proben = Fenster(abspannAb: 2340, imAbspann: 87);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2340.0).Within(5));
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.EqualTo(2340.0).Within(5));
     }
 
     /// <summary>**Eine dunkle Nachtszene ist kein Abspann.**</summary>
@@ -244,7 +264,7 @@ public class AbspannAnteilTests
     {
         var proben = Fenster(abspannAb: 2340, imAbspann: 37, imInhalt: 12);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.Null);
     }
 
     /// <summary>Und ein heller Film bis zum Ende bleibt Handlung.</summary>
@@ -253,7 +273,7 @@ public class AbspannAnteilTests
     {
         var proben = Fenster(abspannAb: double.MaxValue, imAbspann: 99);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.Null);
     }
 }
 
@@ -270,6 +290,16 @@ public class AbspannSchlusstafelTests
 {
     private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
 
+    /// <summary>Der Anfang des ersten Stücks — oder nichts.</summary>
+    ///
+    /// <remarks>
+    /// Die meisten Prüfungen hier fragen nur „wo fängt der Abspann an".
+    /// Seit die Suche Stücke zurückgibt, steht das in <c>[0].Von</c>; ein
+    /// Helfer hält die Erwartungen lesbar, statt überall zu indizieren.
+    /// </remarks>
+    private static double? Anfang(IReadOnlyList<Abspannstück> stücke) =>
+        stücke.Count == 0 ? null : stücke[0].Von;
+
     private static List<Bildprobe> Fenster(double abspannAb, double tafelAb = double.MaxValue)
     {
         var proben = new List<Bildprobe>();
@@ -288,7 +318,7 @@ public class AbspannSchlusstafelTests
         // 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));
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.EqualTo(2340).Within(5));
     }
 
     /// <summary>Eine lange helle Strecke am Ende schon.</summary>
@@ -302,7 +332,7 @@ public class AbspannSchlusstafelTests
     {
         var proben = Fenster(abspannAb: 2340, tafelAb: 2600);
 
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
+        Assert.That(Anfang(Abspannkante.Suchen(proben, Regeln)), Is.Null);
     }
 }
 
@@ -329,6 +359,16 @@ public class AbspannNachsichtTests
 {
     private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
 
+    /// <summary>Der Anfang des ersten Stücks — oder nichts.</summary>
+    ///
+    /// <remarks>
+    /// Die meisten Prüfungen hier fragen nur „wo fängt der Abspann an".
+    /// Seit die Suche Stücke zurückgibt, steht das in <c>[0].Von</c>; ein
+    /// Helfer hält die Erwartungen lesbar, statt überall zu indizieren.
+    /// </remarks>
+    private static double? Anfang(IReadOnlyList<Abspannstück> stücke) =>
+        stücke.Count == 0 ? null : stücke[0].Von;
+
     /// <summary>Abspann ab 2340 s, darin fünf Sekunden helles Logo.</summary>
     private static List<Bildprobe> Fenster(double takt)
     {
@@ -345,7 +385,7 @@ public class AbspannNachsichtTests
     [Test]
     public void Ein_Logo_zerreisst_den_Abspann_nicht_bei_dichten_Proben()
     {
-        Assert.That(Abspannkante.Suchen(Fenster(takt: 0.9), Regeln),
+        Assert.That(Anfang(Abspannkante.Suchen(Fenster(takt: 0.9), Regeln)),
             Is.EqualTo(2340.0).Within(2));
     }
 
@@ -353,18 +393,20 @@ public class AbspannNachsichtTests
     [Test]
     public void Und_auch_nicht_bei_duennen_Proben()
     {
-        Assert.That(Abspannkante.Suchen(Fenster(takt: 10), Regeln),
+        Assert.That(Anfang(Abspannkante.Suchen(Fenster(takt: 10), Regeln)),
             Is.EqualTo(2340.0).Within(11));
     }
 
-    /// <summary>Eine lange helle Strecke bricht weiterhin ab.</summary>
+    /// <summary>Eine Minute helles Bild mitten im Abspann ist eine Szene.</summary>
     ///
     /// <remarks>
-    /// Sonst liefe die Suche rückwärts durch jede Nachtszene und meldete
-    /// den halben Film als Abspann.
+    /// <b>Früher brach die Suche hier ab</b> und meldete nur das Stück
+    /// dahinter. Genau daran scheiterten Marvel-Filme: hinter dem Abspann
+    /// eine Post-Credit-Szene, davor der eigentliche Abspann — und
+    /// gefunden wurde nur der kurze Rest, der dann als zu kurz durchfiel.
     /// </remarks>
     [Test]
-    public void Eine_lange_helle_Strecke_bricht_die_Suche()
+    public void Eine_Minute_hell_mittendrin_teilt_den_Abspann_in_zwei_Stuecke()
     {
         var proben = new List<Bildprobe>();
         for (var t = 1500.0; t <= 2700; t += 1)
@@ -374,8 +416,17 @@ public class AbspannNachsichtTests
             proben.Add(new Bildprobe(t, hell ? 0 : 85));
         }
 
-        // Gefunden wird nur das Stück hinter der hellen Minute.
-        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2460.0).Within(2));
+        var stücke = Abspannkante.Suchen(proben, Regeln);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(stücke, Has.Count.EqualTo(2));
+            Assert.That(stücke[0].Von, Is.EqualTo(2340.0).Within(2));
+            Assert.That(stücke[0].Bis, Is.EqualTo(2399.0).Within(2));
+            Assert.That(stücke[1].Von, Is.EqualTo(2460.0).Within(2));
+            Assert.That(stücke[1].Bis, Is.EqualTo(2700.0).Within(2),
+                "das letzte Stück reicht bis ans Dateiende");
+        });
     }
 
     /// <summary>Und der Grund steht für das Protokoll bereit.</summary>
@@ -386,13 +437,125 @@ public class AbspannNachsichtTests
         for (var t = 1500.0; t <= 2700; t += 5) hell.Add(new Bildprobe(t, 0));
 
         Abspannkante.Suchen(hell, Regeln, out var grund);
-        Assert.That(grund, Does.Contain("hell"));
+        Assert.That(grund, Does.Contain("keine dunkle Strecke"));
 
         var kurz = new List<Bildprobe>();
         for (var t = 1500.0; t <= 2700; t += 5)
             kurz.Add(new Bildprobe(t, t < 2680 ? 0 : 85));
 
         Abspannkante.Suchen(kurz, Regeln, out var zuKurz);
-        Assert.That(zuKurz, Does.Contain("kurz"));
+        Assert.That(zuKurz, Does.Contain("zusammen nur"));
+    }
+}
+
+/// <summary>Ein Abspann darf aus Stücken bestehen.</summary>
+///
+/// <remarks>
+/// <para>
+/// <b>Wofür diese Prüfungen stehen.</b> Zwei Fälle fielen durch, beide am
+/// Bestand gesehen. Bei einem Marvel-Film liegt hinter dem Abspann eine
+/// Post-Credit-Szene: die Suche begann am Dateiende, fand nur den kurzen
+/// Rest dahinter und verwarf ihn als zu kurz. Und ein Abspann, den eine
+/// Szene in der Mitte teilt, zerfiel in zwei Reste, von denen keiner lang
+/// genug war.
+/// </para>
+/// <para>
+/// Die Antwort ist dieselbe: Stücke über die Lücke hinweg zusammenfassen
+/// und die <b>Summe</b> über die Mindestlänge entscheiden lassen.
+/// </para>
+/// </remarks>
+public class AbspannstueckeTests
+{
+    private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
+
+    /// <summary>Eine Reihe im Sekundentakt, dunkel in den angegebenen Spannen.</summary>
+    private static List<Bildprobe> Reihe(double bis, params (double Von, double Bis)[] dunkel)
+    {
+        var proben = new List<Bildprobe>();
+        for (var t = 0.0; t <= bis; t += 1)
+        {
+            var istDunkel = Array.Exists(dunkel, d => t >= d.Von && t < d.Bis);
+            proben.Add(new Bildprobe(t, istDunkel ? 85 : 0));
+        }
+        return proben;
+    }
+
+    /// <summary>Der Marvel-Fall: Abspann, Szene, Abspann.</summary>
+    [Test]
+    public void Zwei_Stuecke_mit_einer_Szene_dazwischen()
+    {
+        // 180 s Abspann, 90 s Szene, 60 s Abspann bis zum Ende.
+        var stücke = Abspannkante.Suchen(Reihe(600, (330, 510), (540, 601)), Regeln);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(stücke, Has.Count.EqualTo(2));
+            Assert.That(stücke[0].Von, Is.EqualTo(330.0).Within(2));
+            Assert.That(stücke[1].Von, Is.EqualTo(540.0).Within(2));
+            Assert.That(stücke[1].Bis, Is.EqualTo(600.0).Within(2));
+        });
+    }
+
+    /// <summary>**Die Summe entscheidet, nicht das einzelne Stück.**</summary>
+    ///
+    /// <remarks>
+    /// Genau hier scheiterte es vorher: 30 s plus 30 s sind zusammen 60 s
+    /// und damit ein Abspann, einzeln aber zweimal zu wenig.
+    /// </remarks>
+    [Test]
+    public void Zwei_kurze_Stuecke_ergeben_zusammen_einen_Abspann()
+    {
+        var stücke = Abspannkante.Suchen(Reihe(600, (450, 480), (570, 601)), Regeln);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(stücke, Has.Count.EqualTo(2));
+            Assert.That(stücke.Sum(t => t.Länge), Is.GreaterThanOrEqualTo(Regeln.Mindestlänge));
+        });
+    }
+
+    /// <summary>Eine zu lange Lücke trennt — dann zählt nur das letzte Stück.</summary>
+    ///
+    /// <remarks>
+    /// Sonst liefe die Suche rückwärts durch jede Nachtszene und hinge den
+    /// halben Film an den Abspann. Hinter einer Lücke von fünf Minuten
+    /// bleibt hier ein Stück von 30 s übrig, und das ist zu kurz.
+    /// </remarks>
+    [Test]
+    public void Eine_zu_lange_Luecke_trennt()
+    {
+        var stücke = Abspannkante.Suchen(Reihe(900, (200, 400), (870, 901)), Regeln);
+
+        Assert.That(stücke, Is.Empty);
+    }
+
+    /// <summary>Ein zu kurzes Stück zwischen zwei gültigen zählt nicht mit.</summary>
+    [Test]
+    public void Ein_Stueck_von_zehn_Sekunden_faellt_heraus()
+    {
+        // Das mittlere Stück ist 10 s lang und damit unter `Mindeststück`.
+        var stücke = Abspannkante.Suchen(
+            Reihe(600, (300, 360), (450, 460), (540, 601)), Regeln);
+
+        Assert.That(stücke, Has.Count.EqualTo(2), "das Zehnsekundenstück gehört nicht dazu");
+    }
+
+    /// <summary>Und ein durchgehender Abspann bleibt ein Stück.</summary>
+    ///
+    /// <remarks>
+    /// Die wichtigste Prüfung dieser Gruppe: der Normalfall darf sich durch
+    /// die Stückelung nicht verändern.
+    /// </remarks>
+    [Test]
+    public void Ein_durchgehender_Abspann_bleibt_ein_Stueck()
+    {
+        var stücke = Abspannkante.Suchen(Reihe(600, (420, 601)), Regeln);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(stücke, Has.Count.EqualTo(1));
+            Assert.That(stücke[0].Von, Is.EqualTo(420.0).Within(2));
+            Assert.That(stücke[0].Bis, Is.EqualTo(600.0).Within(2));
+        });
     }
 }

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

@@ -127,13 +127,14 @@ public class BildabtasterLaufTests
         var proben = await Abtaster().UeberblickAsync(_datei, ab: 30, dauer: 120);
         Assert.That(proben, Is.Not.Empty, "der Filtergraph muss Zahlen liefern");
 
-        var grob = Abspannkante.Suchen(proben, Abspannregeln.Vorgabe);
-        Assert.That(grob, Is.Not.Null, "eine dunkle Strecke bis zum Ende muss auffallen");
+        var stücke = Abspannkante.Suchen(proben, Abspannregeln.Vorgabe);
+        Assert.That(stücke, Is.Not.Empty, "eine dunkle Strecke bis zum Ende muss auffallen");
 
-        var hell = Abspannkante.HellDavor(proben, grob!.Value, Abspannregeln.Vorgabe) ?? 0;
+        var grob = stücke[0].Von;
+        var hell = Abspannkante.HellDavor(proben, grob, Abspannregeln.Vorgabe) ?? 0;
         var abtaster = Abtaster();
         var kante = await Abspannkante.VerfeinernAsync(
-            hell, grob.Value, Abspannregeln.Vorgabe.Mindestanteil,
+            hell, grob, Abspannregeln.Vorgabe.Mindestanteil,
             stelle => abtaster.DunkelanteilAsync(_datei, stelle));
 
         Assert.That(kante, Is.EqualTo(90).Within(4),
@@ -146,7 +147,7 @@ public class BildabtasterLaufTests
     {
         var proben = await Abtaster().UeberblickAsync(_datei, ab: 0, dauer: 80);
 
-        Assert.That(Abspannkante.Suchen(proben, Abspannregeln.Vorgabe), Is.Null);
+        Assert.That(Abspannkante.Suchen(proben, Abspannregeln.Vorgabe), Is.Empty);
     }
 
     /// <summary>Eine einzelne Sekunde lässt sich messen — und liegt richtig.</summary>