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) { }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user