Scarriffle/Flaro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ein Abspann darf aus Stücken bestehen

Browse Source 
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>
This commit is contained in:
Scarriffle
2026-10-15 16:46:27 +02:00
co-authored by Claude Opus 5
parent 791c00dacc
commit 32f592b83e
18 changed files with 7216 additions and 5343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/Flaro.Core/Media/Abspannkante.cs
+136 -44
View File
@@ -22,6 +22,19 @@ namespace Flaro.Core.Media;
/// <param name="Dunkelanteil">Wie viel Prozent des Bildes dunkel sind, 0 bis 100.</param>
public readonly record struct Bildprobe(double Sekunde, double Dunkelanteil);
/// <summary>Ein Stück Abspann: von wann bis wann.</summary>
///
/// <remarks>
/// <b>Mehrere, weil ein Abspann unterbrochen sein kann.</b> Liegt eine
/// Post-Credit-Szene dazwischen, sind es zwei Stücke mit der Szene als
/// Lücke — und der Überspringen-Knopf bringt den Zuschauer genau dorthin
/// statt an ihr vorbei.
/// </remarks>
public readonly record struct Abspannstück(double Von, double Bis)
{
public double Länge => Math.Max(0, Bis - Von);
}
/// <summary>Die Schwellen, nach denen eine dunkle Strecke ein Abspann ist.</summary>
///
/// <remarks>
@@ -87,6 +100,28 @@ public readonly record struct Abspannregeln
/// </remarks>
public double Schlusstafel { get; init; }
/// <summary>Wie kurz ein einzelnes Stück sein darf, um noch zu zählen.</summary>
///
/// <remarks>
/// Ein Abspann kann aus zwei Stücken bestehen, wenn eine Post-Credit-
/// Szene dazwischenliegt. Zehn Sekunden Schwarz sind aber kein Stück
/// Abspann, sondern eine Blende — die Mindestlänge gilt für die Summe,
/// diese Schranke für das einzelne Stück.
/// </remarks>
public double Mindeststück { get; init; }
/// <summary>Wie lang eine Post-Credit-Szene höchstens sein darf.</summary>
///
/// <remarks>
/// <b>Die Lücke, über die hinweg zusammengefasst wird.</b> Eine
/// Post-Credit-Szene im MCU dauert typischerweise eine Minute; die
/// längste gemessene (Thunderbolts*) 2:54. Vier Minuten sind der
/// längste bekannte Wert plus Reserve — und zugleich die Schranke
/// dagegen, dass die Suche rückwärts durch den halben Film läuft.
/// </remarks>
public double Lückentoleranz { get; init; }
/// <summary>Die Summe aller Stücke, nicht die Länge eines einzelnen.</summary>
public double Mindestlänge { get; init; }
public double Höchstlänge { get; init; }
@@ -95,6 +130,8 @@ public readonly record struct Abspannregeln
Mindestanteil = 60,
Nachsicht = 10,
Schlusstafel = 20,
Mindeststück = 15,
Lückentoleranz = 4 * 60,
Mindestlänge = 45,
Höchstlänge = 12 * 60,
};
@@ -124,13 +161,14 @@ public readonly record struct Abspannregeln
/// </remarks>
public static class Abspannkante
{
/// <summary>Die dunkle Strecke, die bis zum Ende durchhält — oder nichts.</summary>
/// <summary>Die Stücke Abspann am Ende — oder eine leere Liste.</summary>
///
/// <param name="proben">
/// Messpunkte über das Ende des Films, aufsteigend nach Zeit. Sie dürfen
/// ungleichmässig liegen: Schlüsselbilder tun das.
/// </param>
public static double? Suchen(IReadOnlyList<Bildprobe> proben, Abspannregeln regeln) =>
public static IReadOnlyList<Abspannstück> Suchen(
IReadOnlyList<Bildprobe> proben, Abspannregeln regeln) =>
Suchen(proben, regeln, out _);
/// <param name="grund">
@@ -139,68 +177,106 @@ public static class Abspannkante
/// sind drei verschiedene Ursachen mit drei verschiedenen Antworten,
/// und ohne diese Zeile beginnt jede Nachfrage wieder beim Raten.
/// </param>
public static double? Suchen(
public static IReadOnlyList<Abspannstück> Suchen(
IReadOnlyList<Bildprobe> proben, Abspannregeln regeln, out string grund)
{
grund = "gefunden";
if (proben.Count < 2)
{
grund = "zu wenige Proben";
return null;
return [];
}
// **Von hinten.** Der Abspann endet am Dateiende; alles, was davor
// dunkel war und wieder hell wurde, war eine Schwarzblende.
//
// **Das allerletzte Bild muss aber nicht dunkel sein.** Hinter dem
// Abspann steht bei vielen Produktionen noch eine Logotafel —
// Sender, Studio, Förderer —, oft hell und ein paar Sekunden lang.
// Darauf zu bestehen, dass die letzte Probe dunkel ist, hiess: ein
// einziges weisses Schlussbild macht den ganzen Abspann unsichtbar.
var letzte = proben.Count - 1;
var ende = proben[letzte].Sekunde;
while (letzte > 0 && proben[letzte].Dunkelanteil < regeln.Mindestanteil)
var läufe = Läufe(proben, regeln);
if (läufe.Count == 0)
{
if (ende - proben[letzte].Sekunde >= regeln.Schlusstafel)
{
grund = "das Ende ist zu lange hell";
return null;
}
letzte--;
grund = "keine dunkle Strecke im Suchfenster";
return [];
}
if (proben[letzte].Dunkelanteil < regeln.Mindestanteil)
// **Das letzte Stück muss das Ende erreichen.** Ein Abspann endet am
// Dateiende; was davor dunkel war und wieder hell wurde, war eine
// Schwarzblende. Eine helle Logotafel dahinter ist erlaubt — Sender,
// Studio, Förderer stehen bei vielen Produktionen noch hinter dem
// Abspann.
var ende = proben[^1].Sekunde;
if (ende - läufe[^1].Bis >= regeln.Schlusstafel)
{
grund = "das Ende ist hell";
return null;
return [];
}
// **Rückwärts, und helle Stellen in Sekunden verzeihen.** Gezählt
// wurden hier früher Proben, und was das bedeutet, hängt allein an
// der Schlüsselbilddichte der Datei — siehe `Nachsicht`.
var anfang = letzte;
for (var i = letzte - 1; i >= 0; i--)
// **Rückwärts zusammenfassen.** Jede Lücke unter der Toleranz ist
// eine Post-Credit-Szene und kein Abbruch; die erste grössere Lücke
// beendet die Suche.
var stücke = new List<Abspannstück> { läufe[^1] };
for (var i = läufe.Count - 2; i >= 0; i--)
{
if (proben[i].Dunkelanteil >= regeln.Mindestanteil) { anfang = i; continue; }
if (proben[anfang].Sekunde - proben[i].Sekunde > regeln.Nachsicht) break;
if (stücke[^1].Von - läufe[i].Bis >= regeln.Lückentoleranz) break;
stücke.Add(läufe[i]);
}
stücke.Reverse();
// **Die Summe entscheidet, nicht das einzelne Stück.** Ein Abspann
// von vier Minuten, den eine Szene in der Mitte teilt, ist ein
// Abspann von vier Minuten — vorher zerfiel er in zwei Reste, von
// denen keiner lang genug war, und der Film bekam gar nichts.
var summe = stücke.Sum(t => t.Länge);
if (summe < regeln.Mindestlänge)
{
grund = $"die dunklen Strecken ergeben zusammen nur {summe:0} s";
return [];
}
if (summe > regeln.Höchstlänge)
{
grund = $"die dunklen Strecken ergeben zusammen {summe:0} s und damit zu viel";
return [];
}
var länge = proben[letzte].Sekunde - proben[anfang].Sekunde;
if (länge < regeln.Mindestlänge)
// Das letzte Stück reicht bis ans Dateiende: eine Logotafel dahinter
// gehört zum Abspann, nicht zum Film.
stücke[^1] = stücke[^1] with { Bis = ende };
return stücke;
}
/// <summary>Zusammenhängende dunkle Strecken, kurze Helligkeiten verziehen.</summary>
///
/// <remarks>
/// <b>Die Nachsicht zählt Sekunden, nicht Proben.</b> Eine Schrifttafel
/// blitzt auf, ein Logo steht zwei Sekunden im Bild; wie viele
/// Messpunkte darauf fallen, hängt allein an der Schlüsselbilddichte
/// der Datei und schwankt um eine Zehnerpotenz.
/// </remarks>
private static List<Abspannstück> Läufe(
IReadOnlyList<Bildprobe> proben, Abspannregeln regeln)
{
var läufe = new List<Abspannstück>();
double? von = null;
double bis = 0;
foreach (var probe in proben)
{
grund = $"die dunkle Strecke ist mit {länge:0} s zu kurz";
return null;
}
if (länge > regeln.Höchstlänge)
{
grund = $"die dunkle Strecke ist mit {länge:0} s zu lang";
return null;
if (probe.Dunkelanteil >= regeln.Mindestanteil)
{
von ??= probe.Sekunde;
bis = probe.Sekunde;
continue;
}
// Hell: der Lauf endet erst, wenn die Helligkeit lange genug
// anhält.
if (von is not null && probe.Sekunde - bis > regeln.Nachsicht)
{
läufe.Add(new Abspannstück(von.Value, bis));
von = null;
}
}
// **Die erste dunkle Probe ist nicht der Anfang.** Zwischen ihr und
// der letzten hellen davor liegt die Kante irgendwo; wo genau, sagt
// erst das Nachmessen. Hier steht die späteste Stelle, an der sie
// liegen kann — und die ist als Marke schon brauchbar.
return proben[anfang].Sekunde;
if (von is not null) läufe.Add(new Abspannstück(von.Value, bis));
// Zehn Sekunden Schwarz sind eine Blende, kein Stück Abspann.
läufe.RemoveAll(l => l.Länge < regeln.Mindeststück);
return läufe;
}
/// <summary>Die letzte helle Probe vor dem Fund — der Suchbereich fürs Nachmessen.</summary>
@@ -254,3 +330,19 @@ public static class Abspannkante
return dunkel;
}
}
/// <summary>Ein Messpunkt des Werkzeugs: das ganze Bild und die Ränder.</summary>
///
/// <remarks>
/// <b>Nur zum Nachsehen, nicht für die Erkennung.</b> Ob die Ränder bei
/// Outtakes im Abspann dunkel bleiben, ist eine Vermutung — und eine, die
/// sich nur an echten Dateien beantworten lässt. Diese Reihe ist die
/// Grundlage dafür.
/// </remarks>
///
/// <param name="Sekunde">Die Stelle im Film.</param>
/// <param name="Gesamt">Dunkelanteil des ganzen Bildes, 0 bis 100.</param>
/// <param name="Links">Dunkelanteil der linken fünftel Breite.</param>
/// <param name="Rechts">Dunkelanteil der rechten fünftel Breite.</param>
public readonly record struct Kurvenpunkt(
double Sekunde, double Gesamt, double Links, double Rechts);