Er packte um, was gar nicht am Umpacken lag
Der Browser bekam stillschweigend Apples Geräteprofil — und mit ihm HEVC, AC3 und EAC3, von denen er keines öffnet. Der Server packte die Datei pflichtschuldig nach MP4 um, liess Bild und Ton dabei unberührt, und heraus kam eine tadellose Datei, mit der Chrome nichts anfangen konnte. Umpacken fasst das Bild nun einmal nicht an. Jetzt sagt das Gerät selbst, was es kann, und es gibt einen zweiten Weg neben der fertigen Datei: HLS, das nach Sekunden anfängt statt nach Minuten. Dasselbe Rohr erledigt beides — mkv nach fMP4 mit „-c:v copy", 4K nach 480p mit libx264 — und eine MP4, die der Browser ohnehin öffnet, geht ganz ohne ffmpeg hinaus. Dazu eine eigene Steuerleiste: Tonspur und Untertitel während der Wiedergabe umschaltbar, vier Auflösungsstufen, Tastenkürzel, und bei einem Fehler ein deutscher Satz statt eines schwarzen Bildes. Gemessen statt vermutet: Chromium antwortet auf canPlayType für HLS mit "maybe" und kann es dann doch nicht — deshalb entscheidet Hls.isSupported(). hls.js wiegt 372 KB und wird erst beim Abspielen geholt; die Oberfläche bleibt bei 109. 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
557708b769
commit
4853200d5c
@@ -430,6 +430,47 @@ public sealed record BulkWatchedResponse(int Changed, IReadOnlyList<Guid> Unknow
|
||||
|
||||
/// <summary>Welche Titel neu geholt werden sollen — leer heisst: alle.</summary>
|
||||
public sealed record RefreshRequest(IReadOnlyList<Guid>? Ids);
|
||||
|
||||
/// <summary>Was ein Spieler kann und was er sehen will.</summary>
|
||||
///
|
||||
/// <param name="Containers">Schachteln, die das Gerät öffnet — „mp4", „webm".</param>
|
||||
/// <param name="Height">
|
||||
/// Die gewünschte Stufe: 1080, 720 oder 480. <c>null</c> heisst Originalauflösung.
|
||||
/// </param>
|
||||
/// <param name="AudioStream">
|
||||
/// Welche Tonspur — die Nummer aus der Datei. <c>null</c> nimmt die erste.
|
||||
/// </param>
|
||||
/// <param name="StartSeconds">Ab welcher Sekunde des Films.</param>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Das Gerät sagt, was es kann, statt dass der Server es rät.</b> Vorher
|
||||
/// bekam jeder Browser Apples Profil — und mit ihm HEVC, AC3 und EAC3, von
|
||||
/// denen er keines öffnen kann.
|
||||
/// </remarks>
|
||||
public sealed record StreamRequest(
|
||||
IReadOnlyList<string>? Containers,
|
||||
IReadOnlyList<string>? VideoCodecs,
|
||||
IReadOnlyList<string>? AudioCodecs,
|
||||
int? Height = null,
|
||||
int? AudioStream = null,
|
||||
double? StartSeconds = null);
|
||||
|
||||
/// <summary>Eine wählbare Spur, so wie sie im Menü steht.</summary>
|
||||
public sealed record SpurAuskunft(int Index, string Label, string? Language, bool IsDefault);
|
||||
|
||||
/// <param name="StartSeconds">
|
||||
/// Ab welcher Sekunde des Films dieser Strom beginnt. <b>Der Spieler zählt ab
|
||||
/// null</b> — ohne diesen Wert ginge jeder gemeldete Stand um den Vorlauf daneben.
|
||||
/// </param>
|
||||
public sealed record StreamResponse(
|
||||
Guid SessionId,
|
||||
string Url,
|
||||
string Method,
|
||||
double StartSeconds,
|
||||
int? Height,
|
||||
int? AudioStream,
|
||||
IReadOnlyList<SpurAuskunft> AudioStreams,
|
||||
IReadOnlyList<SpurAuskunft> SubtitleStreams);
|
||||
public sealed record RatingRequest(int? Rating);
|
||||
|
||||
/// <summary>Was ein Benutzer mit einem Titel zu tun hatte.</summary>
|
||||
|
||||
@@ -0,0 +1,336 @@
|
||||
using System.Security.Claims;
|
||||
using System.Text;
|
||||
using Flaro.Core.Delivery;
|
||||
using Flaro.Core.Library;
|
||||
using Flaro.Data;
|
||||
using Flaro.Media;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Flaro.Api.Endpoints;
|
||||
|
||||
/// <summary>Wiedergabe, die sofort anfängt — statt auf eine fertige Datei zu warten.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Warum es diesen zweiten Weg gibt.</b> <see cref="DeliveryEndpoints"/>
|
||||
/// baut eine fertige MP4 und antwortet solange mit 202. Für eine App, die den
|
||||
/// Film mitnehmen will, ist das richtig. Im Browser heisst es: Minuten vor dem
|
||||
/// ersten Bild — und bei einem Bildcodec, den der Browser nicht kennt, ein
|
||||
/// Umpacken, das nichts nützt, weil es das Bild gar nicht anfasst.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Der Browser sagt, was er kann.</b> Vorher bekam er stillschweigend
|
||||
/// Apples Geräteprofil, das HEVC, AC3 und EAC3 erlaubt — und stand dann vor
|
||||
/// einer Datei, von der er nichts öffnen konnte.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class StreamEndpoints
|
||||
{
|
||||
public static void MapStream(this IEndpointRouteBuilder app)
|
||||
{
|
||||
// **Eine Sitzung anlegen.** Der Rumpf trägt, was das Gerät kann und
|
||||
// was der Benutzer gewählt hat.
|
||||
app.MapPost("/api/v1/files/{id:guid}/stream", async (
|
||||
Guid id, StreamRequest anfrage, ClaimsPrincipal wer,
|
||||
Streamkoordinator koordinator, FlaroContext db) =>
|
||||
{
|
||||
if (PlaybackEndpoints.Benutzer(wer) is not { } benutzer) return Results.Unauthorized();
|
||||
|
||||
var profil = Profil(anfrage);
|
||||
var hoehe = anfrage.Height is { } gewuenscht
|
||||
&& Stromentscheid.Stufen.Contains(gewuenscht) ? gewuenscht : (int?)null;
|
||||
|
||||
try
|
||||
{
|
||||
// **Was der Browser ohnehin öffnet, geht unverändert hinaus.**
|
||||
//
|
||||
// Eine MP4 mit H.264 und AAC durch ffmpeg zu schicken wäre ein
|
||||
// Prozess und ein Kratzplatzordner für nichts — und der
|
||||
// Browser verlöre dabei das, was er von sich aus am besten
|
||||
// kann: springen über Bereichsanfragen, ohne dass irgendwo
|
||||
// etwas neu gerechnet wird.
|
||||
//
|
||||
// **Nur ohne Wünsche.** Wer eine Tonspur oder eine Stufe
|
||||
// wählt, bekommt eine Sitzung: beides lässt sich an einer
|
||||
// durchgereichten Datei nicht einstellen.
|
||||
if (hoehe is null && anfrage.AudioStream is null
|
||||
&& await Durchreichbar(db, id, profil) is { } datei)
|
||||
{
|
||||
return Results.Ok(await Direktauskunft(db, datei, anfrage.StartSeconds ?? 0));
|
||||
}
|
||||
|
||||
var sitzung = await koordinator.StartenAsync(
|
||||
id, benutzer, profil, hoehe, anfrage.AudioStream, anfrage.StartSeconds ?? 0);
|
||||
|
||||
return Results.Ok(await Auskunft(db, sitzung));
|
||||
}
|
||||
catch (InvalidOperationException fehler)
|
||||
{
|
||||
// Ein deutscher Satz, kein Fehlercode — hier wird gelesen,
|
||||
// nicht gesucht. Die Einzelheiten stehen im Protokoll.
|
||||
return Results.Problem(fehler.Message, statusCode: StatusCodes.Status409Conflict);
|
||||
}
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Die Playlist.** Sie wächst, während ffmpeg schreibt.
|
||||
app.MapGet("/api/v1/stream/{sitzung:guid}/index.m3u8", async (
|
||||
Guid sitzung, Streamkoordinator koordinator, CancellationToken ct) =>
|
||||
{
|
||||
if (koordinator.Sitzung(sitzung) is not { } laufend) return Results.NotFound();
|
||||
koordinator.Lebenszeichen(sitzung);
|
||||
|
||||
// **Hier wird gewartet, nicht abgewiesen.**
|
||||
//
|
||||
// Zuerst stand hier eine 204, solange noch kein Segment da war —
|
||||
// der Spieler sollte gleich noch einmal fragen. Gemessen: hls.js
|
||||
// hält jede Antwort ohne Playlist für einen Fehler und gibt sofort
|
||||
// auf. Eine Antwort, die ein paar Sekunden braucht, ist für ihn
|
||||
// dagegen das Normale.
|
||||
//
|
||||
// Gemessen am Prüfbestand: beim Umpacken liegt das erste Segment
|
||||
// nach deutlich unter einer Sekunde vor. Die Spanne hier ist für
|
||||
// den anderen Fall gedacht — ein 4K-Film, der neu gerechnet wird.
|
||||
for (var versuch = 0; versuch < 60; versuch++)
|
||||
{
|
||||
if (ct.IsCancellationRequested) return Results.NoContent();
|
||||
|
||||
if (koordinator.Sitzung(sitzung) is not { } jetzt) return Results.NotFound();
|
||||
|
||||
if (jetzt.Fehler is { Length: > 0 })
|
||||
{
|
||||
return Results.Problem(
|
||||
"Die Wiedergabe liess sich nicht aufbereiten. "
|
||||
+ "Die Einzelheiten stehen im Protokoll von heute.",
|
||||
statusCode: StatusCodes.Status500InternalServerError);
|
||||
}
|
||||
|
||||
if (Streamkoordinator.PlaylistBereit(jetzt.Ordner))
|
||||
return Results.File(Path.Combine(jetzt.Ordner, HlsArgumente.Playlist),
|
||||
"application/vnd.apple.mpegurl");
|
||||
|
||||
// **Hört ffmpeg auf, ohne ein Segment geschrieben zu haben**,
|
||||
// kommt auch keines mehr. Weiterzuwarten hiesse, eine halbe
|
||||
// Minute auf etwas zu warten, das es nicht geben wird.
|
||||
if (jetzt.Beendet)
|
||||
{
|
||||
return Results.Problem(
|
||||
"Für diese Datei kam keine abspielbare Fassung zustande. "
|
||||
+ "Die Einzelheiten stehen im Protokoll von heute.",
|
||||
statusCode: StatusCodes.Status500InternalServerError);
|
||||
}
|
||||
|
||||
await Task.Delay(250, ct);
|
||||
}
|
||||
|
||||
return Results.Problem(
|
||||
"Die Aufbereitung dauert ungewöhnlich lange. Versuche eine kleinere Auflösung.",
|
||||
statusCode: StatusCodes.Status504GatewayTimeout);
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Die Segmente.** Jedes Abholen ist zugleich das Lebenszeichen.
|
||||
app.MapGet("/api/v1/stream/{sitzung:guid}/{datei}", (
|
||||
Guid sitzung, string datei, Streamkoordinator koordinator) =>
|
||||
{
|
||||
if (koordinator.Sitzung(sitzung) is not { } laufend) return Results.NotFound();
|
||||
|
||||
// **Nur der blosse Name.** Ohne diese Prüfung käme man mit
|
||||
// `../../config/flaro.db` an die Datenbank — ein Pfad aus der
|
||||
// Anfrage darf nie ungeprüft an das Dateisystem.
|
||||
if (datei != Path.GetFileName(datei) || datei.Contains("..", StringComparison.Ordinal))
|
||||
return Results.BadRequest();
|
||||
|
||||
if (!datei.EndsWith(".m4s", StringComparison.Ordinal)
|
||||
&& !datei.EndsWith(".mp4", StringComparison.Ordinal))
|
||||
{
|
||||
return Results.NotFound();
|
||||
}
|
||||
|
||||
koordinator.Lebenszeichen(sitzung);
|
||||
|
||||
var pfad = Path.Combine(laufend.Ordner, datei);
|
||||
return File.Exists(pfad)
|
||||
? Results.File(pfad, "video/mp4", enableRangeProcessing: true)
|
||||
: Results.NotFound();
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Schliessen heisst aufräumen.** Ohne das liefe ffmpeg weiter, bis
|
||||
// die Geduld der Sitzung abgelaufen ist — und schriebe solange den
|
||||
// ganzen Film auf den Kratzplatz.
|
||||
app.MapDelete("/api/v1/stream/{sitzung:guid}", (Guid sitzung, Streamkoordinator koordinator) =>
|
||||
{
|
||||
koordinator.Beenden(sitzung);
|
||||
return Results.NoContent();
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Dasselbe noch einmal als POST, für `sendBeacon`.**
|
||||
//
|
||||
// Beim Schliessen eines Reiters kommt eine gewöhnliche Anfrage oft
|
||||
// nicht mehr durch — der Browser bricht sie mit der Seite ab.
|
||||
// `sendBeacon` überlebt das, kann aber nur POST. Ohne diesen Weg
|
||||
// bliebe nach jedem geschlossenen Reiter ein ffmpeg stehen, bis die
|
||||
// Geduld der Sitzung abgelaufen ist.
|
||||
app.MapPost("/api/v1/stream/{sitzung:guid}/schliessen", (
|
||||
Guid sitzung, Streamkoordinator koordinator) =>
|
||||
{
|
||||
koordinator.Beenden(sitzung);
|
||||
return Results.NoContent();
|
||||
}).RequireAuthorization();
|
||||
|
||||
// **Untertitel als eigene Datei, nicht im Strom.**
|
||||
//
|
||||
// So lassen sie sich während der Wiedergabe umschalten, ohne dass
|
||||
// irgendetwas neu gerechnet wird. In einer fMP4-Segmentierung hätten
|
||||
// sie ohnehin keinen Platz.
|
||||
app.MapGet("/api/v1/files/{id:guid}/subtitles/{spur:int}.vtt", async (
|
||||
Guid id, int spur, FlaroContext db, UntertitelLeser leser, CancellationToken ct) =>
|
||||
{
|
||||
var datei = await db.MediaFiles.AsNoTracking().FirstOrDefaultAsync(f => f.Id == id, ct);
|
||||
if (datei is null || !File.Exists(datei.Path)) return Results.NotFound();
|
||||
|
||||
var vtt = await leser.AlsWebVttAsync(datei.Path, spur, ct);
|
||||
return vtt is null
|
||||
? Results.NotFound()
|
||||
: Results.Text(vtt, "text/vtt", Encoding.UTF8);
|
||||
}).RequireAuthorization();
|
||||
}
|
||||
|
||||
/// <summary>Die Datei, wenn der Browser sie unverändert öffnen kann — sonst <c>null</c>.</summary>
|
||||
private static async Task<Guid?> Durchreichbar(FlaroContext db, Guid id, DeviceProfile profil)
|
||||
{
|
||||
var datei = await db.MediaFiles.AsNoTracking().FirstOrDefaultAsync(f => f.Id == id);
|
||||
if (datei is null || !File.Exists(datei.Path)) return null;
|
||||
|
||||
var spuren = await db.MediaStreams.AsNoTracking()
|
||||
.Where(s => s.MediaFileId == id).OrderBy(s => s.Index).ToListAsync();
|
||||
|
||||
var gelesen = spuren.Select(s => new ProbedStream(
|
||||
s.Index, s.Kind, s.Codec, s.Language, s.Title,
|
||||
s.IsDefault, s.IsForced, s.Channels, s.Width, s.Height)).ToList();
|
||||
|
||||
return Stromentscheid.Fuer(datei.Container, gelesen, profil).Art == Stromart.Direkt
|
||||
? datei.Id
|
||||
: null;
|
||||
}
|
||||
|
||||
private static async Task<StreamResponse> Direktauskunft(FlaroContext db, Guid datei, double ab)
|
||||
{
|
||||
var spuren = await db.MediaStreams.AsNoTracking()
|
||||
.Where(s => s.MediaFileId == datei)
|
||||
.OrderBy(s => s.Index)
|
||||
.ToListAsync();
|
||||
|
||||
return new StreamResponse(
|
||||
// **Keine Sitzung, also keine Kennung.** Der Spieler merkt daran,
|
||||
// dass es nichts zu beenden und nichts aufzuräumen gibt.
|
||||
SessionId: Guid.Empty,
|
||||
Url: $"/api/v1/files/{datei}/download",
|
||||
Method: "direct",
|
||||
|
||||
// **Null, nicht `ab`.** Bei einer durchgereichten Datei springt
|
||||
// der Spieler selbst; es gibt keinen Vorlauf, den er aufrechnen
|
||||
// müsste. Ihn hier zu melden hiesse, die Stelle doppelt zu zählen.
|
||||
StartSeconds: 0,
|
||||
Height: null,
|
||||
AudioStream: spuren.FirstOrDefault(s => s.Kind == MediaStreamKind.Audio)?.Index,
|
||||
AudioStreams: spuren.Where(s => s.Kind == MediaStreamKind.Audio)
|
||||
.Select(s => new SpurAuskunft(s.Index, Benennung(s), s.Language, s.IsDefault))
|
||||
.ToList(),
|
||||
SubtitleStreams: spuren.Where(s => s.Kind == MediaStreamKind.Subtitle)
|
||||
.Where(s => s.Codec is null || !IstBild(s.Codec))
|
||||
.Select(s => new SpurAuskunft(s.Index, Benennung(s), s.Language, s.IsDefault))
|
||||
.ToList());
|
||||
}
|
||||
|
||||
/// <summary>Das Geräteprofil aus der Anfrage — oder, wenn keines kam, Apples.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Die Rückfallebene ist nicht harmlos.</b> Sie erlaubt HEVC und EAC3;
|
||||
/// ein Browser, der sein Profil nicht mitschickt, bekommt damit womöglich
|
||||
/// etwas, das er nicht abspielen kann. Alte Clients sollen aber nicht
|
||||
/// plötzlich gar nichts mehr bekommen — die Apps schicken ohnehin bald
|
||||
/// ihr eigenes.
|
||||
/// </remarks>
|
||||
private static DeviceProfile Profil(StreamRequest anfrage)
|
||||
{
|
||||
if (anfrage.Containers is not { Count: > 0 }
|
||||
|| anfrage.VideoCodecs is not { Count: > 0 }
|
||||
|| anfrage.AudioCodecs is not { Count: > 0 })
|
||||
{
|
||||
return DeviceProfile.AppleDefault;
|
||||
}
|
||||
|
||||
return new DeviceProfile(
|
||||
new HashSet<string>(anfrage.Containers, StringComparer.OrdinalIgnoreCase),
|
||||
new HashSet<string>(anfrage.VideoCodecs, StringComparer.OrdinalIgnoreCase),
|
||||
new HashSet<string>(anfrage.AudioCodecs, StringComparer.OrdinalIgnoreCase));
|
||||
}
|
||||
|
||||
private static async Task<StreamResponse> Auskunft(FlaroContext db, Stromsitzung sitzung)
|
||||
{
|
||||
var spuren = await db.MediaStreams.AsNoTracking()
|
||||
.Where(s => s.MediaFileId == sitzung.DateiId)
|
||||
.OrderBy(s => s.Index)
|
||||
.ToListAsync();
|
||||
|
||||
return new StreamResponse(
|
||||
SessionId: sitzung.Kennung,
|
||||
Url: $"/api/v1/stream/{sitzung.Kennung}/index.m3u8",
|
||||
Method: sitzung.Art switch
|
||||
{
|
||||
Stromart.Direkt => "direct",
|
||||
Stromart.Umpacken => "remux",
|
||||
_ => "transcode",
|
||||
},
|
||||
StartSeconds: sitzung.Ab,
|
||||
Height: sitzung.Hoehe,
|
||||
AudioStream: sitzung.Tonspur,
|
||||
AudioStreams: spuren.Where(s => s.Kind == MediaStreamKind.Audio)
|
||||
.Select(s => new SpurAuskunft(s.Index, Benennung(s), s.Language, s.IsDefault))
|
||||
.ToList(),
|
||||
SubtitleStreams: spuren.Where(s => s.Kind == MediaStreamKind.Subtitle)
|
||||
.Where(s => s.Codec is null || !IstBild(s.Codec))
|
||||
.Select(s => new SpurAuskunft(s.Index, Benennung(s), s.Language, s.IsDefault))
|
||||
.ToList());
|
||||
}
|
||||
|
||||
/// <summary>Bildbasierte Untertitel lassen sich nicht nach WebVTT wandeln.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Sie anzubieten wäre eine Zusage, die nicht eingelöst werden kann.</b>
|
||||
/// PGS ist auf jedem Blu-ray-Rip die Regel — ein Eintrag im Menü, der zu
|
||||
/// nichts führt, ist schlechter als kein Eintrag.
|
||||
/// </remarks>
|
||||
private static bool IstBild(string codec) =>
|
||||
codec is "hdmv_pgs_subtitle" or "pgssub" or "dvd_subtitle" or "dvdsub" or "xsub";
|
||||
|
||||
/// <summary>Wie eine Spur im Menü heisst.</summary>
|
||||
private static string Benennung(MediaStream spur)
|
||||
{
|
||||
if (spur.Title is { Length: > 0 } eigen) return eigen;
|
||||
|
||||
var sprache = Sprache(spur.Language);
|
||||
var teile = new List<string> { sprache };
|
||||
if (spur.Channels is { } k and > 2) teile.Add($"{k} Kanäle");
|
||||
if (spur.IsForced) teile.Add("erzwungen");
|
||||
return string.Join(" · ", teile);
|
||||
}
|
||||
|
||||
/// <summary>Dreibuchstabige Kennungen in Worte — für die üblichen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Keine vollständige Tabelle.</b> „deu" steht auf fast jeder Datei
|
||||
/// hier; die übrigen bleiben, wie sie sind, statt eine Liste zu pflegen,
|
||||
/// die nie fertig wird.
|
||||
/// </remarks>
|
||||
private static string Sprache(string? kennung) => kennung?.ToLowerInvariant() switch
|
||||
{
|
||||
null or "" or "und" => "Unbenannt",
|
||||
"deu" or "ger" or "de" => "Deutsch",
|
||||
"eng" or "en" => "Englisch",
|
||||
"fra" or "fre" or "fr" => "Französisch",
|
||||
"ita" or "it" => "Italienisch",
|
||||
"spa" or "es" => "Spanisch",
|
||||
"jpn" or "ja" => "Japanisch",
|
||||
_ => kennung!.ToUpperInvariant(),
|
||||
};
|
||||
}
|
||||
@@ -104,6 +104,11 @@ builder.Services.AddScoped<MetadataEnricher>();
|
||||
builder.Services.AddScoped<MatchApplier>();
|
||||
builder.Services.AddSingleton<ScanCoordinator>();
|
||||
builder.Services.AddSingleton<PackageCoordinator>();
|
||||
|
||||
// **Neben dem Umpacker, nicht an seiner Stelle.** Der baut eine fertige Datei
|
||||
// zum Mitnehmen; dieser lässt sie laufen, während sie entsteht.
|
||||
builder.Services.AddSingleton<Streamkoordinator>();
|
||||
builder.Services.AddSingleton<UntertitelLeser>();
|
||||
// Im Arbeitsspeicher und nur dort: wer gerade was schaut, ist eine Frage
|
||||
// ueber den Augenblick. Nach einem Neustart lautet die Antwort: niemand.
|
||||
builder.Services.AddSingleton<PlaybackSessions>();
|
||||
@@ -259,6 +264,7 @@ app.MapLibraryContent();
|
||||
app.MapSettings();
|
||||
app.MapImages();
|
||||
app.MapDelivery();
|
||||
app.MapStream();
|
||||
app.MapPlayback();
|
||||
app.MapMatching();
|
||||
app.MapArtwork();
|
||||
|
||||
@@ -0,0 +1,310 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Diagnostics;
|
||||
using Flaro.Core.Delivery;
|
||||
using Flaro.Core.Library;
|
||||
using Flaro.Data;
|
||||
using Flaro.Media;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Flaro.Api;
|
||||
|
||||
/// <summary>Eine laufende Wiedergabe mit ihrem ffmpeg dahinter.</summary>
|
||||
///
|
||||
/// <param name="Ab">
|
||||
/// Ab welcher Sekunde des Films diese Sitzung beginnt. <b>Die Zeitachse des
|
||||
/// Spielers fängt bei null an</b>, nicht beim Film — wer ab Minute 30
|
||||
/// einsteigt, dessen Spieler steht bei 0, während der Film bei 1800 steht.
|
||||
/// Ohne diesen Wert ginge jeder gemeldete Stand um eine halbe Stunde daneben.
|
||||
/// </param>
|
||||
public sealed record Stromsitzung(
|
||||
Guid Kennung,
|
||||
Guid DateiId,
|
||||
Guid Benutzer,
|
||||
string Ordner,
|
||||
double Ab,
|
||||
int? Hoehe,
|
||||
int? Tonspur,
|
||||
Stromart Art,
|
||||
DateTimeOffset Begonnen)
|
||||
{
|
||||
/// <summary>Wann zuletzt ein Segment abgeholt wurde.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Daran hängt das Aufräumen.</b> Ein geschlossener Browser sagt
|
||||
/// niemandem Bescheid; bliebe die Sitzung stehen, liefe ffmpeg weiter und
|
||||
/// schriebe den ganzen Film auf den Kratzplatz.
|
||||
/// </remarks>
|
||||
public DateTimeOffset Gesehen { get; set; } = Begonnen;
|
||||
|
||||
public string? Fehler { get; set; }
|
||||
public bool Beendet { get; set; }
|
||||
}
|
||||
|
||||
/// <summary>Verwaltet laufende Ströme: starten, bedienen, aufräumen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Neben <see cref="PackageCoordinator"/>, nicht an seiner Stelle.</b> Der
|
||||
/// baut eine fertige Datei zum Mitnehmen — mit Länge, Bereichsanfragen und
|
||||
/// Fortsetzen nach einem Abbruch; das bleibt für die Apps richtig. Hier geht
|
||||
/// es um etwas anderes: der erste Ton soll nach Sekunden kommen, nicht nach
|
||||
/// Minuten.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Eine Sitzung je Wiedergabe, nicht je Datei.</b> Zwei Leute können
|
||||
/// denselben Film in verschiedenen Auflösungen und mit verschiedenen
|
||||
/// Tonspuren sehen. Das nach Dateikennung zu führen hiesse, dass der zweite
|
||||
/// bekommt, was der erste gewählt hat.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class Streamkoordinator(
|
||||
IServiceScopeFactory scopes,
|
||||
FlaroPaths pfade,
|
||||
FfmpegOptions ffmpeg,
|
||||
TimeProvider clock,
|
||||
ILogger<Streamkoordinator> log) : IDisposable
|
||||
{
|
||||
private readonly ConcurrentDictionary<Guid, Eintrag> _sitzungen = new();
|
||||
|
||||
private sealed record Eintrag(Stromsitzung Sitzung, Process Prozess, CancellationTokenSource Abbruch);
|
||||
|
||||
/// <summary>Nach dieser Stille gilt eine Sitzung als verlassen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Grosszügiger als ein Segment lang.</b> Wer pausiert, holt eine
|
||||
/// Weile nichts ab; ihn nach zwanzig Sekunden abzuwürgen wäre
|
||||
/// Sparsamkeit an der falschen Stelle. Zwei Minuten reichen für eine
|
||||
/// Pause und sind kurz genug, dass ein geschlossener Browser nicht
|
||||
/// stundenlang Platten füllt.
|
||||
/// </remarks>
|
||||
public static readonly TimeSpan Geduld = TimeSpan.FromMinutes(2);
|
||||
|
||||
/// <summary>Wie viele Ströme gleichzeitig laufen dürfen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Weil Umkodieren einen ganzen Rechner beschäftigt.</b> Vier
|
||||
/// gleichzeitige 4K-Läufe bringen jedes NAS zum Stehen — und dann
|
||||
/// ruckelt nicht einer, sondern alle vier.
|
||||
/// </remarks>
|
||||
private const int HoechstensGleichzeitig = 6;
|
||||
|
||||
public int LaufendeAnzahl => _sitzungen.Count;
|
||||
|
||||
public Stromsitzung? Sitzung(Guid kennung) => _sitzungen.GetValueOrDefault(kennung)?.Sitzung;
|
||||
|
||||
/// <summary>Startet einen Strom und gibt die Sitzung zurück.</summary>
|
||||
public async Task<Stromsitzung> StartenAsync(
|
||||
Guid dateiId, Guid benutzer, DeviceProfile profil,
|
||||
int? hoehe, int? tonspur, double ab, CancellationToken ct = default)
|
||||
{
|
||||
AbgelaufeneWegraeumen();
|
||||
|
||||
if (_sitzungen.Count >= HoechstensGleichzeitig)
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
$"Es laufen bereits {HoechstensGleichzeitig} Wiedergaben, die umgerechnet werden müssen. "
|
||||
+ "Warte, bis eine davon zu Ende ist.");
|
||||
}
|
||||
|
||||
using var bereich = scopes.CreateScope();
|
||||
var db = bereich.ServiceProvider.GetRequiredService<FlaroContext>();
|
||||
|
||||
var datei = await db.MediaFiles.AsNoTracking().FirstOrDefaultAsync(f => f.Id == dateiId, ct)
|
||||
?? throw new InvalidOperationException("Diese Datei steht nicht mehr in der Mediathek.");
|
||||
|
||||
if (!File.Exists(datei.Path))
|
||||
throw new InvalidOperationException($"„{Path.GetFileName(datei.Path)}“ liegt nicht mehr da.");
|
||||
|
||||
var spuren = await db.MediaStreams.AsNoTracking()
|
||||
.Where(s => s.MediaFileId == dateiId).OrderBy(s => s.Index)
|
||||
.ToListAsync(ct);
|
||||
|
||||
var gelesen = spuren.Select(s => new ProbedStream(
|
||||
s.Index, s.Kind, s.Codec, s.Language, s.Title,
|
||||
s.IsDefault, s.IsForced, s.Channels, s.Width, s.Height)).ToList();
|
||||
|
||||
var plan = Stromentscheid.Fuer(datei.Container, gelesen, profil, hoehe);
|
||||
|
||||
var kennung = Guid.CreateVersion7();
|
||||
var ordner = Path.Combine(pfade.Transcode, "stroeme", kennung.ToString("N"));
|
||||
Directory.CreateDirectory(ordner);
|
||||
|
||||
var anfrage = new Stromanfrage(
|
||||
datei.Path, ordner, gelesen, plan, tonspur, Math.Max(0, ab), Hardware());
|
||||
|
||||
// **Die tatsächlich benutzte Spur, nicht die gewünschte.** Sonst
|
||||
// stünde im Menü bei keiner ein Haken, obwohl eine davon läuft — und
|
||||
// bei einer Spur, die es nicht mehr gibt, bei der falschen.
|
||||
var sitzung = new Stromsitzung(
|
||||
kennung, dateiId, benutzer, ordner, Math.Max(0, ab),
|
||||
plan.Hoehe, HlsArgumente.Tonspur(gelesen, tonspur)?.Index, plan.Art, clock.GetUtcNow());
|
||||
|
||||
var prozess = Starten(anfrage, sitzung);
|
||||
var abbruch = new CancellationTokenSource();
|
||||
_sitzungen[kennung] = new Eintrag(sitzung, prozess, abbruch);
|
||||
|
||||
log.LogInformation(
|
||||
"Strom {Kennung}: {Art} von {Datei} ab {Ab}s{Hoehe}.",
|
||||
kennung, plan.Art, Path.GetFileName(datei.Path), sitzung.Ab,
|
||||
plan.Hoehe is { } h ? $", auf {h}p" : "");
|
||||
|
||||
return sitzung;
|
||||
}
|
||||
|
||||
/// <summary>Hält eine Sitzung am Leben — bei jedem abgeholten Segment.</summary>
|
||||
public void Lebenszeichen(Guid kennung)
|
||||
{
|
||||
if (_sitzungen.TryGetValue(kennung, out var eintrag))
|
||||
eintrag.Sitzung.Gesehen = clock.GetUtcNow();
|
||||
}
|
||||
|
||||
/// <summary>Beendet eine Sitzung und räumt ihren Ordner weg.</summary>
|
||||
public void Beenden(Guid kennung)
|
||||
{
|
||||
if (!_sitzungen.TryRemove(kennung, out var eintrag)) return;
|
||||
Abraeumen(eintrag);
|
||||
}
|
||||
|
||||
/// <summary>Beendet, was niemand mehr abholt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Beim Starten einer neuen Sitzung, nicht in einem eigenen Takt.</b>
|
||||
/// Ein Hintergrunddienst für einen Handgriff, der ohnehin selten
|
||||
/// geschieht, wäre ein Faden mehr, der schiefgehen kann.
|
||||
/// </remarks>
|
||||
public void AbgelaufeneWegraeumen()
|
||||
{
|
||||
var grenze = clock.GetUtcNow() - Geduld;
|
||||
foreach (var (kennung, eintrag) in _sitzungen)
|
||||
{
|
||||
if (eintrag.Sitzung.Gesehen > grenze) continue;
|
||||
if (!_sitzungen.TryRemove(kennung, out var weg)) continue;
|
||||
|
||||
log.LogInformation("Strom {Kennung} wurde seit {Geduld} nicht abgeholt — beendet.",
|
||||
kennung, Geduld);
|
||||
Abraeumen(weg);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Ob die Playlist schon etwas enthält, das sich abspielen lässt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Die Datei allein genügt nicht.</b> ffmpeg legt sie an, bevor das
|
||||
/// erste Segment fertig ist; ein Spieler, der sie dann bekommt, sieht
|
||||
/// eine leere Liste und gibt auf.
|
||||
/// </remarks>
|
||||
public static bool PlaylistBereit(string ordner)
|
||||
{
|
||||
var pfad = Path.Combine(ordner, HlsArgumente.Playlist);
|
||||
if (!File.Exists(pfad)) return false;
|
||||
|
||||
try
|
||||
{
|
||||
// `ReadAllText` auf einer Datei, in die ffmpeg gerade schreibt:
|
||||
// deshalb ausdrücklich teilend geöffnet, sonst gäbe es hier je
|
||||
// nach Zeitpunkt eine Ausnahme statt einer Antwort.
|
||||
using var strom = new FileStream(
|
||||
pfad, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
|
||||
using var leser = new StreamReader(strom);
|
||||
return leser.ReadToEnd().Contains(".m4s", StringComparison.Ordinal);
|
||||
}
|
||||
catch (IOException) { return false; }
|
||||
}
|
||||
|
||||
/// <summary>Welche Beschleunigung benutzt wird.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b><c>auto</c> prüft, statt zu behaupten.</b> Liegt kein
|
||||
/// <c>/dev/dri/renderD128</c> vor — auf einem Mac, in einem Container ohne
|
||||
/// durchgereichtes Gerät —, läuft es in Software weiter. Langsamer, aber
|
||||
/// es läuft; ein ffmpeg, das mit „No VA display found" abbricht, wäre für
|
||||
/// den Zuschauer dasselbe wie ein kaputter Server.
|
||||
/// </remarks>
|
||||
private Beschleunigung Hardware()
|
||||
{
|
||||
var gewuenscht = Environment.GetEnvironmentVariable("FLARO_HWACCEL")?.Trim().ToLowerInvariant();
|
||||
|
||||
return gewuenscht switch
|
||||
{
|
||||
"none" or "software" => Beschleunigung.Software,
|
||||
"vaapi" => Beschleunigung.Vaapi,
|
||||
_ => File.Exists("/dev/dri/renderD128") ? Beschleunigung.Vaapi : Beschleunigung.Software,
|
||||
};
|
||||
}
|
||||
|
||||
private Process Starten(Stromanfrage anfrage, Stromsitzung sitzung)
|
||||
{
|
||||
var argumente = HlsArgumente.Fuer(anfrage);
|
||||
|
||||
var start = new ProcessStartInfo(ffmpeg.Ffmpeg)
|
||||
{
|
||||
RedirectStandardOutput = true,
|
||||
RedirectStandardError = true,
|
||||
UseShellExecute = false,
|
||||
};
|
||||
foreach (var a in argumente) start.ArgumentList.Add(a);
|
||||
|
||||
var prozess = Process.Start(start)
|
||||
?? throw new InvalidOperationException($"{ffmpeg.Ffmpeg} liess sich nicht starten.");
|
||||
|
||||
// **Der Fehlerkanal wird gelesen, nicht nur umgeleitet.** Läuft die
|
||||
// Röhre voll, bleibt ffmpeg beim Schreiben stehen — und der Strom
|
||||
// hört mitten im Film auf, ohne dass irgendwo etwas stünde.
|
||||
_ = Task.Run(async () =>
|
||||
{
|
||||
var text = await prozess.StandardError.ReadToEndAsync();
|
||||
await prozess.WaitForExitAsync();
|
||||
|
||||
sitzung.Beendet = true;
|
||||
if (prozess.ExitCode == 0) return;
|
||||
|
||||
sitzung.Fehler = text.Trim();
|
||||
log.LogWarning("Strom {Kennung}: ffmpeg endete mit {Code}: {Fehler}",
|
||||
sitzung.Kennung, prozess.ExitCode, sitzung.Fehler);
|
||||
});
|
||||
|
||||
_ = Task.Run(() => prozess.StandardOutput.ReadToEndAsync());
|
||||
return prozess;
|
||||
}
|
||||
|
||||
private void Abraeumen(Eintrag eintrag)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!eintrag.Prozess.HasExited) eintrag.Prozess.Kill(entireProcessTree: true);
|
||||
}
|
||||
catch (Exception fehler) when (fehler is InvalidOperationException or NotSupportedException)
|
||||
{
|
||||
log.LogDebug(fehler, "ffmpeg zu {Kennung} liess sich nicht beenden.", eintrag.Sitzung.Kennung);
|
||||
}
|
||||
|
||||
eintrag.Prozess.Dispose();
|
||||
eintrag.Abbruch.Dispose();
|
||||
|
||||
try
|
||||
{
|
||||
if (Directory.Exists(eintrag.Sitzung.Ordner))
|
||||
Directory.Delete(eintrag.Sitzung.Ordner, recursive: true);
|
||||
}
|
||||
catch (IOException fehler)
|
||||
{
|
||||
log.LogWarning(fehler, "Der Ordner zu Strom {Kennung} blieb liegen.", eintrag.Sitzung.Kennung);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Beim Herunterfahren bleibt nichts laufen und nichts liegen.</summary>
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (var kennung in _sitzungen.Keys) Beenden(kennung);
|
||||
|
||||
// **Auch, was ein Absturz hinterlassen hat.** Nach einem harten Ende
|
||||
// steht der Ordner noch da; ihn beim nächsten Herunterfahren zu
|
||||
// übersehen hiesse, dass der Kratzplatz nur wächst.
|
||||
try
|
||||
{
|
||||
var wurzel = Path.Combine(pfade.Transcode, "stroeme");
|
||||
if (Directory.Exists(wurzel)) Directory.Delete(wurzel, recursive: true);
|
||||
}
|
||||
catch (IOException) { }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
using Flaro.Core.Library;
|
||||
|
||||
namespace Flaro.Core.Delivery;
|
||||
|
||||
/// <summary>Wie eine Datei in einen laufenden Spieler kommt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Nicht zu verwechseln mit <see cref="DeliveryMethod"/>.</b> Dort geht es
|
||||
/// um eine fertige Datei zum Mitnehmen; hier um einen Strom, der sofort
|
||||
/// anfängt. Beides hat dieselbe Frage — passt das Gerät zur Datei? — und ganz
|
||||
/// verschiedene Antworten: eine Datei darf Minuten brauchen, ein Spieler nicht.
|
||||
/// </remarks>
|
||||
public enum Stromart
|
||||
{
|
||||
/// <summary>Die Datei geht unverändert hinaus, der Browser spielt sie direkt.</summary>
|
||||
Direkt,
|
||||
|
||||
/// <summary>
|
||||
/// Umgepackt, aber nicht neu gerechnet — mkv nach fMP4, Bild Byte für Byte.
|
||||
/// </summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Das ist der häufigste Fall und der billigste.</b> Eine MKV mit H.264
|
||||
/// und AAC kann jeder Browser abspielen; nur die Schachtel kennt er nicht.
|
||||
/// Sie zu wechseln kostet den Server fast nichts.
|
||||
/// </remarks>
|
||||
Umpacken,
|
||||
|
||||
/// <summary>Das Bild wird neu gerechnet — anderer Codec oder kleinere Auflösung.</summary>
|
||||
Umkodieren,
|
||||
}
|
||||
|
||||
/// <summary>Warum es nicht beim Durchreichen bleibt.</summary>
|
||||
public enum Stromgrund
|
||||
{
|
||||
PasstSchon,
|
||||
SchachtelUnbekannt,
|
||||
BildcodecUnbekannt,
|
||||
TonUnbekannt,
|
||||
KleinereAufloesungGewuenscht,
|
||||
}
|
||||
|
||||
/// <summary>Was für diesen Strom zu tun ist.</summary>
|
||||
///
|
||||
/// <param name="Hoehe">
|
||||
/// Auf wie viele Bildzeilen herunterskaliert wird — <c>null</c> heisst:
|
||||
/// Originalauflösung.
|
||||
/// </param>
|
||||
public sealed record Streamplan(
|
||||
Stromart Art,
|
||||
IReadOnlyList<Stromgrund> Gruende,
|
||||
int? Hoehe)
|
||||
{
|
||||
public bool BildKopieren => Art != Stromart.Umkodieren;
|
||||
}
|
||||
|
||||
/// <summary>Entscheidet, was ein Strom braucht, damit der Spieler ihn öffnet.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Getrennt von <see cref="DeliveryDecider"/>, und das ist Absicht.</b> Der
|
||||
/// entscheidet über eine Datei zum Herunterladen und kennt nur zwei Ausgänge:
|
||||
/// durchreichen oder umpacken. Ein unbekannter Bildcodec führte dort ebenfalls
|
||||
/// zum Umpacken — und das half nichts, weil Umpacken das Bild nicht anfasst.
|
||||
/// Für den Browser war das der Fehler, an dem jede Wiedergabe mit HEVC
|
||||
/// scheiterte: er bekam eine tadellose MP4, in der ein Codec steckte, den er
|
||||
/// nicht kennt.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Das Bild wird nur angefasst, wenn es sein muss.</b> Neu zu rechnen
|
||||
/// kostet ein Vielfaches des Umpackens und verliert Bildqualität. Wer eine
|
||||
/// kleinere Auflösung will, bekommt sie; wer nicht, bekommt das Original.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class Stromentscheid
|
||||
{
|
||||
/// <summary>Die Stufen, die ein Spieler anbieten darf.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Keine freie Zahl.</b> Vier Stufen decken ab, wofür es Gründe gibt:
|
||||
/// das Original, zwei Zwischenstufen und eine für die langsame Leitung.
|
||||
/// Eine beliebige Höhe zuzulassen hiesse, für jede Zahl eine eigene
|
||||
/// Sitzung zu rechnen.
|
||||
/// </remarks>
|
||||
public static readonly IReadOnlyList<int> Stufen = [1080, 720, 480];
|
||||
|
||||
/// <param name="hoeheGewuenscht">
|
||||
/// Die vom Spieler gewählte Stufe, oder <c>null</c> für das Original.
|
||||
/// </param>
|
||||
public static Streamplan Fuer(
|
||||
string? schachtel,
|
||||
IReadOnlyList<ProbedStream> spuren,
|
||||
DeviceProfile profil,
|
||||
int? hoeheGewuenscht = null)
|
||||
{
|
||||
var gruende = new List<Stromgrund>();
|
||||
|
||||
var bild = spuren.FirstOrDefault(s => s.Kind == MediaStreamKind.Video);
|
||||
var bildPasst = Passt(bild?.Codec, profil.VideoCodecs);
|
||||
if (!bildPasst) gruende.Add(Stromgrund.BildcodecUnbekannt);
|
||||
|
||||
// **Eine Stufe über der Quelle ist keine Stufe.** Ein 720p-Film in
|
||||
// „1080p" abzuspielen hiesse, ihn hochzurechnen: mehr Last, mehr
|
||||
// Daten, kein besseres Bild.
|
||||
var hoehe = hoeheGewuenscht is { } gewuenscht
|
||||
&& (bild?.Height is not { } vorhanden || gewuenscht < vorhanden)
|
||||
? gewuenscht
|
||||
: (int?)null;
|
||||
if (hoehe is not null) gruende.Add(Stromgrund.KleinereAufloesungGewuenscht);
|
||||
|
||||
if (!bildPasst || hoehe is not null)
|
||||
return new Streamplan(Stromart.Umkodieren, gruende, hoehe);
|
||||
|
||||
var schachtelPasst = Passt(schachtel, profil.Containers);
|
||||
if (!schachtelPasst) gruende.Add(Stromgrund.SchachtelUnbekannt);
|
||||
|
||||
// **Beim Ton genügt eine passende Spur.** Welche gespielt wird,
|
||||
// entscheidet der Benutzer; dass eine siebenkanalige DTS-Spur daneben
|
||||
// liegt, ist kein Grund, den ganzen Film anzufassen.
|
||||
var tonspuren = spuren.Where(s => s.Kind == MediaStreamKind.Audio).ToList();
|
||||
var tonPasst = tonspuren.Count == 0 || tonspuren.Any(s => Passt(s.Codec, profil.AudioCodecs));
|
||||
if (!tonPasst) gruende.Add(Stromgrund.TonUnbekannt);
|
||||
|
||||
if (!schachtelPasst || !tonPasst)
|
||||
return new Streamplan(Stromart.Umpacken, gruende, null);
|
||||
|
||||
return new Streamplan(Stromart.Direkt, [Stromgrund.PasstSchon], null);
|
||||
}
|
||||
|
||||
/// <summary>Was fehlt, zählt als passend — eine Lücke ist kein Urteil.</summary>
|
||||
private static bool Passt(string? wert, IReadOnlySet<string> erlaubt) =>
|
||||
string.IsNullOrWhiteSpace(wert) || erlaubt.Contains(wert);
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
using System.Globalization;
|
||||
using Flaro.Core.Delivery;
|
||||
using Flaro.Core.Library;
|
||||
|
||||
namespace Flaro.Media;
|
||||
|
||||
/// <summary>Welche Bildbeschleunigung benutzt werden soll.</summary>
|
||||
public enum Beschleunigung
|
||||
{
|
||||
/// <summary>Alles im Hauptprozessor — geht überall, kostet am meisten.</summary>
|
||||
Software,
|
||||
|
||||
/// <summary>VAAPI über <c>/dev/dri</c> — Intel und AMD unter Linux.</summary>
|
||||
Vaapi,
|
||||
}
|
||||
|
||||
/// <param name="Quelle">Die Datei auf der Platte.</param>
|
||||
/// <param name="Zielordner">Wohin Playlist und Segmente geschrieben werden.</param>
|
||||
/// <param name="Tonspur">
|
||||
/// Welche Tonspur gespielt wird — die Nummer aus der Datei. <c>null</c> nimmt
|
||||
/// die erste.
|
||||
/// </param>
|
||||
/// <param name="Ab">
|
||||
/// Ab welcher Sekunde. <b>Vor <c>-i</c>, nicht danach</b> — nur dann springt
|
||||
/// ffmpeg im Vorspann statt die ganze Datei durchzulesen.
|
||||
/// </param>
|
||||
public sealed record Stromanfrage(
|
||||
string Quelle,
|
||||
string Zielordner,
|
||||
IReadOnlyList<ProbedStream> Spuren,
|
||||
Streamplan Plan,
|
||||
int? Tonspur = null,
|
||||
double Ab = 0,
|
||||
Beschleunigung Hardware = Beschleunigung.Software);
|
||||
|
||||
/// <summary>Baut die ffmpeg-Zeile für einen laufenden Strom.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Eine reine Funktion, wie bei <see cref="RemuxArguments"/>.</b> Aus
|
||||
/// demselben Grund: eine falsche Parameterkombination lässt sich sonst nur
|
||||
/// gegen einen echten Server entdecken, und dort kostet sie Tage.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Ein Rohr für beides.</b> Eine MKV nach fMP4 umzupacken und einen
|
||||
/// 4K-Film auf 480p herunterzurechnen ist derselbe Weg — einmal mit
|
||||
/// <c>-c:v copy</c>, einmal mit einem Kodierer. Zwei getrennte Wege hiesse,
|
||||
/// Sitzungsverwaltung, Segmentierung und Aufräumen zweimal zu haben.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Warum HLS und nicht eine fertige Datei.</b> Bisher wurde der ganze Film
|
||||
/// umgepackt, bevor das erste Bild lief — bei 4K sind das Minuten, in denen
|
||||
/// nichts geschieht. HLS liefert das erste Segment nach Sekunden.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class HlsArgumente
|
||||
{
|
||||
/// <summary>Wie lang ein Segment ist.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Sechs Sekunden, wie bei Apple.</b> Kürzer heisst mehr Dateien und
|
||||
/// mehr Anfragen; länger heisst, dass der Anfang später kommt und jeder
|
||||
/// Sprung gröber wird.
|
||||
/// </remarks>
|
||||
public const int SegmentSekunden = 6;
|
||||
|
||||
/// <summary>Wie viele Bilder zwischen zwei Schlüsselbildern liegen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Ein Segment muss mit einem Schlüsselbild anfangen.</b> Ohne feste
|
||||
/// Abstände schneidet ffmpeg dort, wo zufällig eines liegt — und die
|
||||
/// Segmente werden unterschiedlich lang, was jeden Sprung ungenau macht.
|
||||
/// </remarks>
|
||||
private const int BilderJeSekunde = 25;
|
||||
|
||||
public const string Playlist = "index.m3u8";
|
||||
private const string Anfangsstueck = "init.mp4";
|
||||
private const string Segmentmuster = "seg%05d.m4s";
|
||||
|
||||
public static List<string> Fuer(Stromanfrage anfrage)
|
||||
{
|
||||
var argumente = new List<string> { "-y", "-loglevel", "error" };
|
||||
|
||||
// **Die Beschleunigung steht vor der Eingabe.** Danach wäre sie eine
|
||||
// Angabe über die Ausgabe und bliebe wirkungslos — ffmpeg sagt dazu
|
||||
// nichts, es dekodiert einfach im Hauptprozessor weiter.
|
||||
if (anfrage.Hardware == Beschleunigung.Vaapi && !anfrage.Plan.BildKopieren)
|
||||
{
|
||||
argumente.AddRange([
|
||||
"-hwaccel", "vaapi",
|
||||
"-hwaccel_output_format", "vaapi",
|
||||
"-vaapi_device", "/dev/dri/renderD128",
|
||||
]);
|
||||
}
|
||||
|
||||
if (anfrage.Ab > 0)
|
||||
{
|
||||
argumente.Add("-ss");
|
||||
argumente.Add(anfrage.Ab.ToString("0.###", CultureInfo.InvariantCulture));
|
||||
}
|
||||
|
||||
argumente.Add("-i");
|
||||
argumente.Add(anfrage.Quelle);
|
||||
|
||||
var bild = anfrage.Spuren.FirstOrDefault(s => s.Kind == MediaStreamKind.Video);
|
||||
var ton = Tonspur(anfrage.Spuren, anfrage.Tonspur);
|
||||
|
||||
// **Nur Bild und eine Tonspur.** Mehr trägt eine HLS-Ausgabe nicht,
|
||||
// ohne in getrennte Listen zu zerfallen; die Spurwahl geschieht
|
||||
// deshalb über eine neue Sitzung. Untertitel kommen als eigene
|
||||
// WebVTT-Datei daneben und brauchen den Strom gar nicht anzufassen.
|
||||
if (bild is not null) { argumente.Add("-map"); argumente.Add($"0:{bild.Index}"); }
|
||||
if (ton is not null) { argumente.Add("-map"); argumente.Add($"0:{ton.Index}"); }
|
||||
|
||||
argumente.AddRange(Bildargumente(anfrage, bild));
|
||||
argumente.AddRange(Tonargumente(anfrage, ton));
|
||||
|
||||
// **Keine Untertitel im Strom.** mov_text in einer fMP4-Segmentierung
|
||||
// bringt ffmpeg zum Abbruch, und bildbasierte Untertitel passen
|
||||
// ohnehin nicht hinein.
|
||||
argumente.Add("-sn");
|
||||
|
||||
argumente.AddRange([
|
||||
"-f", "hls",
|
||||
"-hls_time", SegmentSekunden.ToString(CultureInfo.InvariantCulture),
|
||||
|
||||
// **`event` und nicht `vod`.** Die Liste wächst, während ffmpeg
|
||||
// schreibt; `vod` behauptete, sie sei schon vollständig, und der
|
||||
// Spieler bräche am Ende des ersten Segments ab.
|
||||
"-hls_playlist_type", "event",
|
||||
|
||||
// fMP4 statt MPEG-TS: dieselben Segmente, die auch ein
|
||||
// Browser-MSE-Puffer ohne Umweg annimmt — und HEVC ginge in TS gar
|
||||
// nicht erst.
|
||||
"-hls_segment_type", "fmp4",
|
||||
"-hls_fmp4_init_filename", Anfangsstueck,
|
||||
"-hls_segment_filename", Path.Combine(anfrage.Zielordner, Segmentmuster),
|
||||
|
||||
// Jedes Segment für sich dekodierbar — sonst darf ein Spieler
|
||||
// nicht mittendrin einsteigen.
|
||||
"-hls_flags", "independent_segments",
|
||||
"-start_number", "0",
|
||||
]);
|
||||
|
||||
argumente.Add(Path.Combine(anfrage.Zielordner, Playlist));
|
||||
return argumente;
|
||||
}
|
||||
|
||||
/// <summary>Welche Tonspur gespielt wird.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Eine gewünschte, die es nicht gibt, ist keine Fehlermeldung wert.</b>
|
||||
/// Nach einem erneuten Scan kann sich die Nummerierung verschoben haben;
|
||||
/// dann ist die erste Spur die vernünftige Antwort, nicht ein stummer Film.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Öffentlich, damit die Antwort an den Spieler dieselbe Regel
|
||||
/// benutzt.</b> Vorher meldete der Server die <i>gewünschte</i> Spur
|
||||
/// zurück — also meist <c>null</c> —, und im Menü stand bei keiner ein
|
||||
/// Haken, obwohl eine davon lief.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static ProbedStream? Tonspur(IReadOnlyList<ProbedStream> spuren, int? gewuenscht)
|
||||
{
|
||||
var alle = spuren.Where(s => s.Kind == MediaStreamKind.Audio).ToList();
|
||||
if (alle.Count == 0) return null;
|
||||
|
||||
return gewuenscht is { } wunsch
|
||||
? alle.FirstOrDefault(s => s.Index == wunsch) ?? alle[0]
|
||||
: alle[0];
|
||||
}
|
||||
|
||||
private static IEnumerable<string> Bildargumente(Stromanfrage anfrage, ProbedStream? bild)
|
||||
{
|
||||
if (anfrage.Plan.BildKopieren) return ["-c:v", "copy"];
|
||||
|
||||
var schluesselabstand = (SegmentSekunden * BilderJeSekunde).ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
if (anfrage.Hardware == Beschleunigung.Vaapi)
|
||||
{
|
||||
// **`format=nv12|vaapi,hwupload` vor dem Skalieren.** Ohne diese
|
||||
// Kette liegt das Bild je nach Quelle mal im Hauptspeicher und mal
|
||||
// in der Grafikkarte, und `scale_vaapi` nimmt nur das zweite.
|
||||
var kette = anfrage.Plan.Hoehe is { } h
|
||||
? $"format=nv12|vaapi,hwupload,scale_vaapi=w=-2:h={h}"
|
||||
: "format=nv12|vaapi,hwupload";
|
||||
|
||||
return [
|
||||
"-vf", kette,
|
||||
"-c:v", "h264_vaapi",
|
||||
"-qp", "23",
|
||||
"-g", schluesselabstand,
|
||||
"-bf", "0",
|
||||
];
|
||||
}
|
||||
|
||||
var weich = new List<string>();
|
||||
if (anfrage.Plan.Hoehe is { } hoehe)
|
||||
{
|
||||
// `-2` statt `-1`: die Breite muss gerade sein, sonst lehnt
|
||||
// libx264 sie ab. Das hat schon einmal eine Stunde gekostet.
|
||||
weich.AddRange(["-vf", $"scale=-2:{hoehe}"]);
|
||||
}
|
||||
|
||||
weich.AddRange([
|
||||
"-c:v", "libx264",
|
||||
|
||||
// **`veryfast`, nicht `medium`.** Was in Echtzeit laufen muss,
|
||||
// darf nicht langsamer rechnen als es abspielt — ein schöneres
|
||||
// Bild, das stockt, ist kein schöneres Bild.
|
||||
"-preset", "veryfast",
|
||||
"-crf", "21",
|
||||
"-profile:v", "high",
|
||||
"-level", "4.1",
|
||||
"-pix_fmt", "yuv420p",
|
||||
|
||||
// Feste Schlüsselbildabstände, damit jedes Segment gleich lang wird.
|
||||
"-g", schluesselabstand,
|
||||
"-keyint_min", schluesselabstand,
|
||||
"-sc_threshold", "0",
|
||||
]);
|
||||
|
||||
_ = bild;
|
||||
return weich;
|
||||
}
|
||||
|
||||
private static IEnumerable<string> Tonargumente(Stromanfrage anfrage, ProbedStream? ton)
|
||||
{
|
||||
if (ton is null) return ["-an"];
|
||||
|
||||
// **Immer AAC, immer Stereo.** Beim Umpacken wäre Durchreichen
|
||||
// billiger, aber was hier herauskommt, läuft im Browser: der kennt
|
||||
// weder EAC3 noch DTS, und eine 5.1-Spur in Stereo zu falten ist
|
||||
// Aufgabe des Servers, nicht des Lautsprechers.
|
||||
//
|
||||
// Genau diese Stelle war der Fehler: beim Umpacken wurde der Ton
|
||||
// kopiert, weil Apples Profil EAC3 erlaubt — und im Browser blieb der
|
||||
// Film stumm oder lief gar nicht.
|
||||
_ = anfrage;
|
||||
return ["-c:a", "aac", "-ac", "2", "-b:a", "192k", "-ar", "48000"];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
using System.Diagnostics;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Flaro.Media;
|
||||
|
||||
/// <summary>Holt eine Untertitelspur als WebVTT aus einer Datei.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Getrennt vom Strom, und das ist der Punkt.</b> Wandern Untertitel mit
|
||||
/// in die Segmente, kostet jedes Umschalten eine neue Sitzung — also neues
|
||||
/// Rechnen, neues Puffern, ein Ruckler. Als eigene Datei daneben hängt der
|
||||
/// Spieler sie einfach als <c><track></c> ein und schaltet in
|
||||
/// Millisekunden um.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Nur Text, kein Bild.</b> PGS und VobSub sind Bilder; aus ihnen WebVTT
|
||||
/// zu machen hiesse, Schrift zu erkennen. Sie werden gar nicht erst
|
||||
/// angeboten — siehe <c>StreamEndpoints</c>.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class UntertitelLeser(FfmpegOptions optionen, ILogger<UntertitelLeser> log)
|
||||
{
|
||||
/// <summary>Wie lange das Herausziehen höchstens dauern darf.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Untertitel sind ein paar Dutzend Kilobyte; braucht es dafür länger als
|
||||
/// eine halbe Minute, stimmt etwas mit der Datei nicht — und ein Spieler,
|
||||
/// der ewig auf einen Text wartet, ist schlimmer als einer ohne.
|
||||
/// </remarks>
|
||||
private static readonly TimeSpan Geduld = TimeSpan.FromSeconds(30);
|
||||
|
||||
/// <returns><c>null</c>, wenn es die Spur nicht gibt oder sie kein Text ist.</returns>
|
||||
public async Task<string?> AlsWebVttAsync(string datei, int spur, CancellationToken ct = default)
|
||||
{
|
||||
using var zeitlimit = CancellationTokenSource.CreateLinkedTokenSource(ct);
|
||||
zeitlimit.CancelAfter(Geduld);
|
||||
|
||||
var start = new ProcessStartInfo(optionen.Ffmpeg)
|
||||
{
|
||||
RedirectStandardOutput = true,
|
||||
RedirectStandardError = true,
|
||||
UseShellExecute = false,
|
||||
};
|
||||
|
||||
foreach (var a in new[]
|
||||
{
|
||||
"-loglevel", "error",
|
||||
"-i", datei,
|
||||
"-map", $"0:{spur}",
|
||||
"-c:s", "webvtt",
|
||||
"-f", "webvtt",
|
||||
// Auf die Standardausgabe statt in eine Datei: es geht um
|
||||
// Kilobyte, und eine Datei müsste wieder weggeräumt werden.
|
||||
"pipe:1",
|
||||
})
|
||||
{
|
||||
start.ArgumentList.Add(a);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var prozess = Process.Start(start)
|
||||
?? throw new InvalidOperationException($"{optionen.Ffmpeg} liess sich nicht starten.");
|
||||
|
||||
var lesen = prozess.StandardOutput.ReadToEndAsync(zeitlimit.Token);
|
||||
var fehlerLesen = prozess.StandardError.ReadToEndAsync(zeitlimit.Token);
|
||||
|
||||
try
|
||||
{
|
||||
await prozess.WaitForExitAsync(zeitlimit.Token);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
try { prozess.Kill(entireProcessTree: true); } catch (InvalidOperationException) { }
|
||||
throw;
|
||||
}
|
||||
|
||||
var text = await lesen;
|
||||
if (prozess.ExitCode != 0)
|
||||
{
|
||||
log.LogDebug("Untertitelspur {Spur} aus {Datei}: {Fehler}",
|
||||
spur, Path.GetFileName(datei), (await fehlerLesen).Trim());
|
||||
return null;
|
||||
}
|
||||
|
||||
// **Eine leere Antwort ist keine Antwort.** ffmpeg gibt bei einer
|
||||
// Bildspur eine gültige, aber inhaltslose WebVTT-Datei aus; sie
|
||||
// auszuliefern hiesse, leere Untertitel anzubieten.
|
||||
return text.Contains("-->", StringComparison.Ordinal) ? text : null;
|
||||
}
|
||||
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
|
||||
{
|
||||
log.LogWarning("Untertitelspur {Spur} aus {Datei} brauchte länger als {Geduld}.",
|
||||
spur, Path.GetFileName(datei), Geduld);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user