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/src/Flaro.Api/Endpoints/LibraryContentEndpoints.cs

@@ -1,5 +1,8 @@
+using System.Globalization;
+using System.Text;
 using Flaro.Api.Auth;
 using Flaro.Core.Library;
+using Flaro.Media;
 using Flaro.Core.Media;
 using System.Security.Claims;
 using Flaro.Core.Playback;
@@ -152,6 +155,9 @@ public static class LibraryContentEndpoints
 
         var roh = await db.Marken.AsNoTracking()
             .Where(m => m.EpisodeId != null && folgen.Contains(m.EpisodeId!.Value))
+            // In Zeitfolge: ein geteilter Abspann kommt als zwei Marken, und
+            // die Spieler nehmen die erste passende.
+            .OrderBy(m => m.VonSekunden)
             .Select(m => new { Id = m.EpisodeId!.Value, m.Art, m.VonSekunden, m.BisSekunden })
             .ToListAsync();
 
@@ -177,6 +183,7 @@ public static class LibraryContentEndpoints
 
         var roh = await db.Marken.AsNoTracking()
             .Where(m => m.MovieId != null && filme.Contains(m.MovieId!.Value))
+            .OrderBy(m => m.VonSekunden)
             .Select(m => new { Id = m.MovieId!.Value, m.Art, m.VonSekunden, m.BisSekunden })
             .ToListAsync();
 
@@ -902,6 +909,42 @@ public static class LibraryContentEndpoints
             return Results.Accepted();
         }).RequireAuthorization(FlaroPolicies.Administrator);
 
+        // **Die Messkurve eines Films — zum Nachsehen, nicht zum Erkennen.**
+        //
+        // Die Erkennung sagt „kein Abspann" und nennt die Gründe; was sie
+        // nicht sagen kann, ist, wie die Kurve aussieht. Genau die braucht
+        // es, bevor eine neue Schwelle gesetzt wird — zum Beispiel für die
+        // Frage, ob bei Outtakes im Abspann wenigstens die Ränder dunkel
+        // bleiben.
+        app.MapGet("/api/v1/movies/{id:guid}/markenkurve", async (
+            Guid id, FlaroContext db, Bildabtaster abtaster, CancellationToken ct) =>
+        {
+            var film = await db.Movies.AsNoTracking()
+                .Where(m => m.Id == id)
+                .Join(db.MediaFiles.AsNoTracking(), m => m.Id, d => d.MovieId,
+                    (m, d) => new { m.Title, d.Path, d.Duration })
+                .FirstOrDefaultAsync(ct);
+
+            if (film?.Duration is not { TotalSeconds: > 0 } laufzeit)
+                return Einwand.Bitte("Zu diesem Film gibt es keine Datei mit Laufzeit.");
+
+            var ab = Math.Max(0, laufzeit.TotalSeconds - Markenerkennung.Suchbereich);
+            var kurve = await abtaster.KurveAsync(film.Path, ab, laufzeit.TotalSeconds - ab, ct);
+
+            var text = new StringBuilder("sekunde;gesamt;links;rechts\n");
+            foreach (var punkt in kurve)
+            {
+                text.Append(CultureInfo.InvariantCulture,
+                    $"{punkt.Sekunde:0.###};{punkt.Gesamt:0.#};{punkt.Links:0.#};{punkt.Rechts:0.#}\n");
+            }
+
+            var name = string.Concat((film.Title ?? "film")
+                .Select(c => char.IsLetterOrDigit(c) ? c : '-'));
+
+            return Results.File(Encoding.UTF8.GetBytes(text.ToString()),
+                "text/csv", $"markenkurve-{name}.csv");
+        }).RequireAuthorization(FlaroPolicies.Administrator);
+
         // **Eine Marke wieder wegnehmen.**
         //
         // Ohne diesen Weg wäre die Erkennung eine Blackbox, die manchmal