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>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
791c00dacc
commit
32f592b83e
@@ -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
|
||||
|
||||
@@ -100,14 +100,21 @@ public static class PlaybackEndpoints
|
||||
|
||||
// **Der Abspann, wenn er erkannt wurde.** Er zieht die Schwelle
|
||||
// fürs Häkchen nach vorn — siehe `ProgressRule.Apply`.
|
||||
//
|
||||
// **Das früheste Stück, nicht irgendeines.** Teilt eine
|
||||
// Post-Credit-Szene den Abspann, gibt es zwei Zeilen; ohne
|
||||
// `OrderBy` entschied die Datenbank, welche gilt. Gemeint ist
|
||||
// immer die erste — dort ist die Handlung vorbei.
|
||||
var abspannAb = zustand.EpisodeId is { } folge
|
||||
? await db.Marken.AsNoTracking()
|
||||
.Where(m => m.EpisodeId == folge && m.Art == Markenart.Abspann)
|
||||
.OrderBy(m => m.VonSekunden)
|
||||
.Select(m => (double?)m.VonSekunden)
|
||||
.FirstOrDefaultAsync()
|
||||
: zustand.MovieId is { } film
|
||||
? await db.Marken.AsNoTracking()
|
||||
.Where(m => m.MovieId == film && m.Art == Markenart.Abspann)
|
||||
.OrderBy(m => m.VonSekunden)
|
||||
.Select(m => (double?)m.VonSekunden)
|
||||
.FirstOrDefaultAsync()
|
||||
: null;
|
||||
|
||||
@@ -503,7 +503,8 @@ public sealed class Markenerkennung(
|
||||
// allein ist keine Auskunft: ob die Datei zu wenige Schlüsselbilder
|
||||
// hat, ob der Abspann zu hell war oder ob am Schluss eine Tafel
|
||||
// steht, sieht man nur an diesen drei Zahlen — und sonst gar nicht.
|
||||
if (Abspannkante.Suchen(proben, regeln, out var grund) is not { } stelle)
|
||||
var stücke = Abspannkante.Suchen(proben, regeln, out var grund);
|
||||
if (stücke.Count == 0)
|
||||
{
|
||||
// **Mit der Kapitellage.** Ob eine Datei gar keine Kapitel hat
|
||||
// oder nur namenlose, entscheidet, ob sich an diesem Weg
|
||||
@@ -517,16 +518,34 @@ public sealed class Markenerkennung(
|
||||
return false;
|
||||
}
|
||||
|
||||
var hell = Abspannkante.HellDavor(proben, stelle, regeln) ?? ab;
|
||||
// **Nur die erste Kante wird nachgemessen.** Sie ist die, die der
|
||||
// Zuschauer zuerst sieht, und die, an der „gilt als gesehen" hängt.
|
||||
// Die übrigen Grenzen liegen an Schlüsselbildern und sind damit auf
|
||||
// fünf bis zehn Sekunden genau — dafür lohnt keine Sonde.
|
||||
var hell = Abspannkante.HellDavor(proben, stücke[0].Von, regeln) ?? ab;
|
||||
var kante = await Abspannkante.VerfeinernAsync(
|
||||
hell, stelle, regeln.Mindestanteil,
|
||||
hell, stücke[0].Von, regeln.Mindestanteil,
|
||||
wo => abtaster.DunkelanteilAsync(pfad, wo, ct));
|
||||
|
||||
log.LogInformation("„{Titel}“: Abspann im Bild ab {Stelle:h\\:mm\\:ss}.",
|
||||
name, TimeSpan.FromSeconds(kante));
|
||||
var fein = stücke.ToList();
|
||||
fein[0] = fein[0] with { Von = kante };
|
||||
|
||||
return await SchreibenAsync(db, titelId, istFilm, Markenart.Abspann,
|
||||
kante, laufzeit, ct);
|
||||
if (fein.Count == 1)
|
||||
{
|
||||
log.LogInformation("„{Titel}“: Abspann im Bild ab {Stelle:h\\:mm\\:ss}.",
|
||||
name, TimeSpan.FromSeconds(kante));
|
||||
}
|
||||
else
|
||||
{
|
||||
log.LogInformation(
|
||||
"„{Titel}“: Abspann im Bild in {Stücke} Stücken ab {Stelle:h\\:mm\\:ss} "
|
||||
+ "— dazwischen {Lücken}.",
|
||||
name, fein.Count, TimeSpan.FromSeconds(kante),
|
||||
string.Join(", ", fein.Zip(fein.Skip(1),
|
||||
(a, b) => $"{Zeit(a.Bis)}–{Zeit(b.Von)}")));
|
||||
}
|
||||
|
||||
return await SchreibenAsync(db, titelId, istFilm, Markenart.Abspann, fein, ct);
|
||||
}
|
||||
|
||||
/// <summary>Was ein Serienlauf ergeben hat — für die Zusammenfassung.</summary>
|
||||
@@ -917,31 +936,53 @@ public sealed class Markenerkennung(
|
||||
});
|
||||
}
|
||||
|
||||
private Task<bool> SchreibenAsync(
|
||||
FlaroContext db, Guid titelId, bool istFilm, Markenart art,
|
||||
double von, double bis, CancellationToken ct) =>
|
||||
SchreibenAsync(db, titelId, istFilm, art, [new Abspannstück(von, bis)], ct);
|
||||
|
||||
/// <summary>Setzt die Marken einer Art auf genau diese Stücke.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Ersetzen, nicht umschreiben.</b> Hier stand ein Abgleich auf
|
||||
/// genau eine Zeile je Titel und Art — das ging, solange ein Abspann
|
||||
/// eine zusammenhängende Strecke war. Seit eine Post-Credit-Szene ihn
|
||||
/// teilen darf, sind es ein bis zwei Zeilen, und beim nächsten Lauf
|
||||
/// vielleicht wieder eine. Die alten zu löschen und die neuen
|
||||
/// anzulegen ist der einzige Weg, der in beide Richtungen stimmt.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>In derselben Transaktion</b> — gespeichert wird weiter oben, und
|
||||
/// bis dahin stehen Löschung und Anlage zusammen. Dazwischen gibt es
|
||||
/// keinen Augenblick, in dem der Titel gar keine Marke hätte.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
private async Task<bool> SchreibenAsync(
|
||||
FlaroContext db, Guid titelId, bool istFilm, Markenart art,
|
||||
double von, double bis, CancellationToken ct)
|
||||
IReadOnlyList<Abspannstück> stücke, CancellationToken ct)
|
||||
{
|
||||
var alt = istFilm
|
||||
? await db.Marken.FirstOrDefaultAsync(m => m.MovieId == titelId && m.Art == art, ct)
|
||||
: await db.Marken.FirstOrDefaultAsync(m => m.EpisodeId == titelId && m.Art == art, ct);
|
||||
if (stücke.Count == 0) return false;
|
||||
|
||||
if (alt is not null)
|
||||
var alte = istFilm
|
||||
? await db.Marken.Where(m => m.MovieId == titelId && m.Art == art).ToListAsync(ct)
|
||||
: await db.Marken.Where(m => m.EpisodeId == titelId && m.Art == art).ToListAsync(ct);
|
||||
|
||||
db.Marken.RemoveRange(alte);
|
||||
|
||||
foreach (var stück in stücke)
|
||||
{
|
||||
alt.VonSekunden = von;
|
||||
alt.BisSekunden = bis;
|
||||
alt.ErkanntAm = clock.GetUtcNow();
|
||||
return true;
|
||||
db.Marken.Add(new Marke
|
||||
{
|
||||
EpisodeId = istFilm ? null : titelId,
|
||||
MovieId = istFilm ? titelId : null,
|
||||
Art = art,
|
||||
VonSekunden = stück.Von,
|
||||
BisSekunden = stück.Bis,
|
||||
ErkanntAm = clock.GetUtcNow(),
|
||||
});
|
||||
}
|
||||
|
||||
db.Marken.Add(new Marke
|
||||
{
|
||||
EpisodeId = istFilm ? null : titelId,
|
||||
MovieId = istFilm ? titelId : null,
|
||||
Art = art,
|
||||
VonSekunden = von,
|
||||
BisSekunden = bis,
|
||||
ErkanntAm = clock.GetUtcNow(),
|
||||
});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -311,10 +311,14 @@ public sealed class FlaroContext(DbContextOptions<FlaroContext> options) : DbCon
|
||||
b.Entity<Marke>(e =>
|
||||
{
|
||||
e.HasKey(x => x.Id);
|
||||
// Eine Art einmal je Titel: ein zweiter Lauf schreibt um, statt
|
||||
// eine zweite Zeile anzulegen.
|
||||
e.HasIndex(x => new { x.EpisodeId, x.Art }).IsUnique().HasFilter("\"EpisodeId\" IS NOT NULL");
|
||||
e.HasIndex(x => new { x.MovieId, x.Art }).IsUnique().HasFilter("\"MovieId\" IS NOT NULL");
|
||||
// **Mehrere Stücke je Art, und das ist der ganze Zweck.** Hier
|
||||
// stand ein eindeutiger Index mit dem Vermerk „eine Art einmal
|
||||
// je Titel" — richtig, solange ein Abspann eine
|
||||
// zusammenhängende Strecke war. Teilt ihn eine Post-Credit-
|
||||
// Szene, sind es zwei Zeilen, und der Index wies die zweite ab.
|
||||
// Zum Nachschlagen bleiben die Indizes, nur ohne `IsUnique`.
|
||||
e.HasIndex(x => new { x.EpisodeId, x.Art });
|
||||
e.HasIndex(x => new { x.MovieId, x.Art });
|
||||
e.HasOne<Episode>().WithMany().HasForeignKey(x => x.EpisodeId).OnDelete(DeleteBehavior.Cascade);
|
||||
e.HasOne<Movie>().WithMany().HasForeignKey(x => x.MovieId).OnDelete(DeleteBehavior.Cascade);
|
||||
// Als Zahl, nicht als Text: die Namen stehen im Quelltext und
|
||||
|
||||
+1357
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,58 @@
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Flaro.Data.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class Abspannstuecke : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropIndex(
|
||||
name: "IX_Marken_EpisodeId_Art",
|
||||
table: "Marken");
|
||||
|
||||
migrationBuilder.DropIndex(
|
||||
name: "IX_Marken_MovieId_Art",
|
||||
table: "Marken");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Marken_EpisodeId_Art",
|
||||
table: "Marken",
|
||||
columns: new[] { "EpisodeId", "Art" });
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Marken_MovieId_Art",
|
||||
table: "Marken",
|
||||
columns: new[] { "MovieId", "Art" });
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropIndex(
|
||||
name: "IX_Marken_EpisodeId_Art",
|
||||
table: "Marken");
|
||||
|
||||
migrationBuilder.DropIndex(
|
||||
name: "IX_Marken_MovieId_Art",
|
||||
table: "Marken");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Marken_EpisodeId_Art",
|
||||
table: "Marken",
|
||||
columns: new[] { "EpisodeId", "Art" },
|
||||
unique: true,
|
||||
filter: "\"EpisodeId\" IS NOT NULL");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_Marken_MovieId_Art",
|
||||
table: "Marken",
|
||||
columns: new[] { "MovieId", "Art" },
|
||||
unique: true,
|
||||
filter: "\"MovieId\" IS NOT NULL");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -432,13 +432,9 @@ namespace Flaro.Data.Migrations
|
||||
|
||||
b.HasKey("Id");
|
||||
|
||||
b.HasIndex("EpisodeId", "Art")
|
||||
.IsUnique()
|
||||
.HasFilter("\"EpisodeId\" IS NOT NULL");
|
||||
b.HasIndex("EpisodeId", "Art");
|
||||
|
||||
b.HasIndex("MovieId", "Art")
|
||||
.IsUnique()
|
||||
.HasFilter("\"MovieId\" IS NOT NULL");
|
||||
b.HasIndex("MovieId", "Art");
|
||||
|
||||
b.ToTable("Marken");
|
||||
});
|
||||
|
||||
@@ -92,9 +92,56 @@ public sealed partial class Bildabtaster(FfmpegOptions optionen, ILogger<Bildabt
|
||||
return proben.Average(p => p.Dunkelanteil);
|
||||
}
|
||||
|
||||
/// <param name="zuschnitt">
|
||||
/// Ein <c>crop</c>-Ausdruck vor der Messung, oder <c>null</c> für das
|
||||
/// ganze Bild. Nur das Messwerkzeug benutzt das.
|
||||
/// </param>
|
||||
/// <summary>Drei Kurven über denselben Abschnitt — zum Nachsehen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Ein Werkzeug, keine Erkennung.</b> Die Randstreifen sind eine
|
||||
/// Vermutung: bei Outtakes im Abspann läuft das Bild vielleicht in der
|
||||
/// Mitte und die Ränder bleiben schwarz. Ob das trägt, sieht man nur an
|
||||
/// echten Dateien — und dafür braucht es die Zahlen, bevor eine Schwelle
|
||||
/// gesetzt wird.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Drei Durchläufe, nicht einer.</b> Zwei <c>blackframe</c> in einer
|
||||
/// Kette schrieben denselben Metadatenschlüssel und überschrieben
|
||||
/// einander; mit <c>split</c> ginge es, kostete aber drei Ausgabewege
|
||||
/// und eine Zusammenführung. Für etwas, das jemand einmal je Film von
|
||||
/// Hand anstösst, sind drei Läufe über Schlüsselbilder das günstigere
|
||||
/// Geschäft.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public async Task<IReadOnlyList<Kurvenpunkt>> KurveAsync(
|
||||
string pfad, double ab, double dauer, CancellationToken ct = default)
|
||||
{
|
||||
async Task<IReadOnlyList<Bildprobe>> Lauf(string? zuschnitt) => Lesen(
|
||||
await LaufenAsync(pfad, ab, dauer, nurSchluesselbilder: true,
|
||||
TimeSpan.FromMinutes(10), ct, zuschnitt),
|
||||
ab);
|
||||
|
||||
var gesamt = await Lauf(null);
|
||||
var links = await Lauf("crop=iw*0.2:ih:0:0");
|
||||
var rechts = await Lauf("crop=iw*0.2:ih:iw*0.8:0");
|
||||
|
||||
// Nach Zeit zusammenführen: die drei Läufe sehen dieselben
|
||||
// Schlüsselbilder, aber darauf zu bauen wäre eine Annahme.
|
||||
double BeiZeit(IReadOnlyList<Bildprobe> reihe, double sekunde) =>
|
||||
reihe.Count == 0 ? double.NaN
|
||||
: reihe.MinBy(p => Math.Abs(p.Sekunde - sekunde)).Dunkelanteil;
|
||||
|
||||
return gesamt
|
||||
.Select(p => new Kurvenpunkt(
|
||||
p.Sekunde, p.Dunkelanteil, BeiZeit(links, p.Sekunde), BeiZeit(rechts, p.Sekunde)))
|
||||
.ToList();
|
||||
}
|
||||
|
||||
private async Task<string> LaufenAsync(
|
||||
string pfad, double ab, double dauer, bool nurSchluesselbilder,
|
||||
TimeSpan frist, CancellationToken ct)
|
||||
TimeSpan frist, CancellationToken ct, string? zuschnitt = null)
|
||||
{
|
||||
var start = new ProcessStartInfo(optionen.Ffmpeg)
|
||||
{
|
||||
@@ -135,7 +182,8 @@ public sealed partial class Bildabtaster(FfmpegOptions optionen, ILogger<Bildabt
|
||||
// dieselbe Schwelle bei der einen Datei etwas anderes als bei der
|
||||
// nächsten — „Schwelle 247,6" im Protokoll war der Hinweis darauf.
|
||||
start.ArgumentList.Add(
|
||||
$"scale={Breite}:-2,format=gray,"
|
||||
(zuschnitt is null ? "" : zuschnitt + ",")
|
||||
+ $"scale={Breite}:-2,format=gray,"
|
||||
+ $"blackframe=amount=0:threshold={Dunkelschwelle},"
|
||||
+ "metadata=print:key=lavfi.blackframe.pblack:file=-");
|
||||
start.ArgumentList.Add("-f");
|
||||
|
||||
Reference in New Issue
Block a user