ScarriffleandClaude Opus 5
9c2e2b5f47
Der Spieler schickte sein Profil aus `canPlayType` — und das ist eine Auskunft des `<video>`-Elements. Ein Strom läuft aber nicht durch das Element, sondern durch den MSE-Puffer, und die beiden sind sich nicht einig. Gemessen in Chromium: | | canPlayType | MediaSource.isTypeSupported | |---|---|---| | `audio/flac` | probably | **false** | | `audio/mp4; codecs="mp3"` | probably | **false** | Der Server glaubte dem Profil, packte die Datei pflichtschuldig um und liess die Spur unberührt — und der Browser stand vor etwas, das er nach eigener Auskunft können müsste. Heraus kam „Dieser Browser kann die Spuren dieser Datei nicht öffnen". Jetzt zählt ein Codec nur, wenn **beide** Auskünfte ihn bestätigen; welcher der beiden Wege es wird, entscheidet der Server erst danach. Und geprüft wird jeder Typ in der Form, in der er wirklich ankommt — `audio/mp4` und nicht `audio/flac`: genau dieser Unterschied entschied bei FLAC zwischen „geht" und „geht nicht". Gemessen: MP3 fällt dadurch aus dem Profil, der Server rechnet es um, statt es durchzureichen. **Und wenn doch etwas durchrutscht, wird gerechnet statt gemeldet.** Scheitert die Wiedergabe mit einem Codec- oder Dekodierfehler, baut der Spieler den Strom genau einmal neu auf — mit `transcode: true`, an derselben Stelle. Der Satz „über das Zahnrad lässt sich eine Fassung wählen, die er versteht" ist weg: wer das liest, weiss weder welche, noch warum der Server sie nicht gleich gegeben hat. Lief schon ein gerechneter Strom, unterbleibt der zweite Versuch — dann liegt es nicht am Codec, und dreissig Sekunden Warten auf dasselbe sind keine Hilfe. **Nicht geprüft:** dass der Rückfall im Betrieb auslöst. Jede Datei im Prüfbestand spielt; ein echtes Scheitern liess sich hier nicht herbeiführen. Gemessen ist der Serverteil (`remux` wird zu `transcode`) und das neue Profil. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
374 lines
14 KiB
C#
374 lines
14 KiB
C#
using Flaro.Core.Delivery;
|
||
using Flaro.Core.Library;
|
||
|
||
namespace Flaro.Media.Tests;
|
||
|
||
/// <summary>Die ffmpeg-Zeile für einen laufenden Strom, ohne sie auszuführen.</summary>
|
||
public class HlsArgumenteTests
|
||
{
|
||
private static ProbedStream Bild(string codec = "h264", int hoehe = 1080) =>
|
||
new(0, MediaStreamKind.Video, codec, null, null, true, false, null, hoehe * 16 / 9, hoehe);
|
||
|
||
private static ProbedStream Ton(int i, string codec = "eac3", int kanaele = 6) =>
|
||
new(i, MediaStreamKind.Audio, codec, "deu", null, false, false, kanaele, null, null);
|
||
|
||
private static ProbedStream Text(int i) =>
|
||
new(i, MediaStreamKind.Subtitle, "subrip", "deu", null, false, false, null, null, null);
|
||
|
||
/// <summary>Was ein gewöhnlicher Browser kann.</summary>
|
||
private static readonly DeviceProfile Browser = new(
|
||
Containers: new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "mp4", "webm" },
|
||
VideoCodecs: new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "h264", "avc1", "vp9" },
|
||
AudioCodecs: new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "aac", "mp3", "opus" });
|
||
|
||
private static string Zeile(
|
||
IReadOnlyList<ProbedStream> spuren, string schachtel = "mkv",
|
||
int? hoehe = null, int? tonspur = null, double ab = 0,
|
||
Beschleunigung hardware = Beschleunigung.Software,
|
||
Kodierstufe stufe = Kodierstufe.Ausgewogen)
|
||
{
|
||
var plan = Stromentscheid.Fuer(schachtel, spuren, Browser, hoehe);
|
||
return string.Join(' ', HlsArgumente.Fuer(new Stromanfrage(
|
||
"/medien/film.mkv", "/kratz/sitzung", spuren, plan, tonspur, ab, hardware, stufe)));
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Umpacken: das Bild bleibt unberührt
|
||
// ------------------------------------------------------------------
|
||
|
||
/// <summary>Eine MKV mit H.264 wird umgepackt, nicht neu gerechnet.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Der häufigste Fall und der billigste.</b> Der Browser kennt die
|
||
/// Schachtel nicht, das Bild darin sehr wohl.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Eine_mkv_mit_bekanntem_Bild_wird_nur_umgepackt()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1, "aac")]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-c:v copy"));
|
||
Assert.That(zeile, Does.Not.Contain("libx264"));
|
||
Assert.That(zeile, Does.Contain("-f hls"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Der Ton wird immer nach AAC gerechnet — das war der Fehler.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Hier lag der Grund, aus dem gar nichts lief.</b> Beim Umpacken für
|
||
/// den Download wird der Ton kopiert, weil Apples Profil EAC3 erlaubt. Der
|
||
/// Browser bekam dieselbe Entscheidung — und mit ihr eine Datei, deren Ton
|
||
/// er nicht öffnen kann.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Der_Ton_wird_immer_nach_AAC_gerechnet()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1, "eac3")]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-c:a aac"));
|
||
Assert.That(zeile, Does.Contain("-ac 2"), "5.1 wird auf Stereo gefaltet");
|
||
Assert.That(zeile, Does.Not.Contain("-c:a copy"));
|
||
});
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Umkodieren: unbekanntes Bild oder kleinere Auflösung
|
||
// ------------------------------------------------------------------
|
||
|
||
/// <summary>HEVC kann kein Browser — da hilft Umpacken nichts.</summary>
|
||
[Test]
|
||
public void Ein_unbekannter_Bildcodec_wird_neu_gerechnet()
|
||
{
|
||
var zeile = Zeile([Bild("hevc"), Ton(1, "aac")]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-c:v libx264"));
|
||
Assert.That(zeile, Does.Not.Contain("-c:v copy"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Ein 4K-Film soll sich auch in 480p ansehen lassen.</summary>
|
||
[Test]
|
||
public void Eine_kleinere_Aufloesung_wird_herunterskaliert()
|
||
{
|
||
var zeile = Zeile([Bild("h264", 2160), Ton(1, "aac")], hoehe: 480);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-vf scale=-2:480"),
|
||
"-2 und nicht -1: die Breite muss gerade sein, sonst lehnt libx264 ab");
|
||
Assert.That(zeile, Does.Contain("-c:v libx264"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Hochrechnen ist keine Stufe.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// Ein 720p-Film in „1080p" kostet mehr Last und mehr Daten für kein
|
||
/// besseres Bild. Die Stufe wird dann stillschweigend übergangen.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Eine_Stufe_ueber_der_Quelle_wird_nicht_hochgerechnet()
|
||
{
|
||
var plan = Stromentscheid.Fuer("mp4", [Bild("h264", 720)], Browser, 1080);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(plan.Hoehe, Is.Null);
|
||
Assert.That(plan.Art, Is.EqualTo(Stromart.Direkt));
|
||
});
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Spurwahl, Springen, Hardware
|
||
// ------------------------------------------------------------------
|
||
|
||
[Test]
|
||
public void Die_gewaehlte_Tonspur_wird_abgebildet()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1), Ton(2), Ton(3)], tonspur: 3);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-map 0:0"));
|
||
Assert.That(zeile, Does.Contain("-map 0:3"));
|
||
Assert.That(zeile, Does.Not.Contain("-map 0:1"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Eine Spur, die es nicht gibt, macht den Film nicht stumm.</summary>
|
||
[Test]
|
||
public void Eine_unbekannte_Tonspur_faellt_auf_die_erste_zurueck()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1), Ton(2)], tonspur: 99);
|
||
|
||
Assert.That(zeile, Does.Contain("-map 0:1"));
|
||
}
|
||
|
||
/// <summary>Der Sprungpunkt steht vor der Eingabe.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Hinter <c>-i</c> wäre es ein genauer, aber langsamer Sprung:</b>
|
||
/// ffmpeg läse die Datei bis dorthin durch. Bei Minute 90 eines Films
|
||
/// dauert das länger als das Ansehen.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Der_Sprungpunkt_steht_vor_der_Eingabe()
|
||
{
|
||
var argumente = HlsArgumente.Fuer(new Stromanfrage(
|
||
"/medien/film.mkv", "/kratz/sitzung",
|
||
[Bild(), Ton(1)],
|
||
Stromentscheid.Fuer("mkv", [Bild(), Ton(1)], Browser),
|
||
Ab: 930.5));
|
||
|
||
var ss = argumente.IndexOf("-ss");
|
||
var i = argumente.IndexOf("-i");
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(ss, Is.GreaterThanOrEqualTo(0));
|
||
Assert.That(ss, Is.LessThan(i));
|
||
Assert.That(argumente[ss + 1], Is.EqualTo("930.5"),
|
||
"mit Punkt, nicht mit Komma — ffmpeg liest keine deutsche Schreibweise");
|
||
});
|
||
}
|
||
|
||
[Test]
|
||
public void Ohne_Sprungpunkt_steht_kein_ss_in_der_Zeile()
|
||
{
|
||
Assert.That(Zeile([Bild(), Ton(1)]), Does.Not.Contain("-ss"));
|
||
}
|
||
|
||
/// <summary>Die Beschleunigung gehört vor die Eingabe, sonst wirkt sie nicht.</summary>
|
||
[Test]
|
||
public void Vaapi_steht_vor_der_Eingabe_und_nur_beim_Rechnen()
|
||
{
|
||
var mitRechnen = HlsArgumente.Fuer(new Stromanfrage(
|
||
"/medien/film.mkv", "/kratz/sitzung",
|
||
[Bild("hevc"), Ton(1)],
|
||
Stromentscheid.Fuer("mkv", [Bild("hevc"), Ton(1)], Browser),
|
||
Hardware: Beschleunigung.Vaapi));
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(mitRechnen.IndexOf("-hwaccel"), Is.LessThan(mitRechnen.IndexOf("-i")));
|
||
Assert.That(string.Join(' ', mitRechnen), Does.Contain("h264_vaapi"));
|
||
|
||
// Beim reinen Umpacken wird nichts dekodiert — die Grafikkarte
|
||
// hätte dabei nichts zu tun.
|
||
Assert.That(Zeile([Bild(), Ton(1)], hardware: Beschleunigung.Vaapi),
|
||
Does.Not.Contain("-hwaccel"));
|
||
});
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Form der Ausgabe
|
||
// ------------------------------------------------------------------
|
||
|
||
[Test]
|
||
public void Die_Segmente_sind_unabhaengig_und_die_Liste_waechst()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1)]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-hls_playlist_type event"),
|
||
"vod behauptete, die Liste sei vollständig — der Spieler brach nach dem ersten Segment ab");
|
||
Assert.That(zeile, Does.Contain("-hls_segment_type fmp4"));
|
||
Assert.That(zeile, Does.Contain("-hls_flags independent_segments"));
|
||
Assert.That(zeile, Does.EndWith(Path.Combine("/kratz/sitzung", "index.m3u8")));
|
||
});
|
||
}
|
||
|
||
/// <summary>Untertitel bleiben draussen — sie kommen als eigene Datei.</summary>
|
||
[Test]
|
||
public void Untertitel_wandern_nicht_in_den_Strom()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1), Text(2)]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-sn"));
|
||
Assert.That(zeile, Does.Not.Contain("-map 0:2"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Beim Rechnen wird jedes Segment gleich lang.</summary>
|
||
[Test]
|
||
public void Beim_Rechnen_stehen_die_Schluesselbilder_fest()
|
||
{
|
||
var zeile = Zeile([Bild("hevc"), Ton(1)]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-g 150"), "6 Sekunden × 25 Bilder");
|
||
Assert.That(zeile, Does.Contain("-keyint_min 150"));
|
||
Assert.That(zeile, Does.Contain("-sc_threshold 0"));
|
||
});
|
||
}
|
||
|
||
/// <summary>Eine Datei ohne Ton bleibt eine Datei ohne Ton.</summary>
|
||
[Test]
|
||
public void Ohne_Tonspur_wird_nichts_erfunden()
|
||
{
|
||
var zeile = Zeile([Bild()]);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-an"));
|
||
Assert.That(zeile, Does.Not.Contain("-c:a aac"));
|
||
});
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Die Stufe: Bild gegen Tempo
|
||
// ------------------------------------------------------------------
|
||
|
||
/// <summary>Jede Stufe rechnet anders — und „ausgewogen" wie bisher.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Preset und CRF gehören zusammen.</b> Ein langsameres Preset holt bei
|
||
/// demselben CRF Bild heraus; ein schnelleres braucht einen höheren, sonst
|
||
/// wächst nur die Datei. Deshalb wird hier beides geprüft und nicht eines.
|
||
/// </remarks>
|
||
[TestCase(Kodierstufe.Qualitaet, "-preset medium", "-crf 19")]
|
||
[TestCase(Kodierstufe.Ausgewogen, "-preset veryfast", "-crf 21")]
|
||
[TestCase(Kodierstufe.Tempo, "-preset ultrafast", "-crf 23")]
|
||
public void Die_Stufe_entscheidet_ueber_Preset_und_Crf(
|
||
Kodierstufe stufe, string preset, string crf)
|
||
{
|
||
var zeile = Zeile([Bild("hevc"), Ton(1)], stufe: stufe);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain(preset));
|
||
Assert.That(zeile, Does.Contain(crf));
|
||
});
|
||
}
|
||
|
||
/// <summary>Die Grafikeinheit kennt kein Preset, nur den Quantisierer.</summary>
|
||
[TestCase(Kodierstufe.Qualitaet, "-qp 21")]
|
||
[TestCase(Kodierstufe.Ausgewogen, "-qp 23")]
|
||
[TestCase(Kodierstufe.Tempo, "-qp 26")]
|
||
public void Die_Stufe_entscheidet_auch_bei_Vaapi(Kodierstufe stufe, string qp)
|
||
{
|
||
var zeile = Zeile([Bild("hevc"), Ton(1)],
|
||
hardware: Beschleunigung.Vaapi, stufe: stufe);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-c:v h264_vaapi"));
|
||
Assert.That(zeile, Does.Contain(qp));
|
||
});
|
||
}
|
||
|
||
// ------------------------------------------------------------------
|
||
// Der zweite Versuch
|
||
// ------------------------------------------------------------------
|
||
|
||
/// <summary>Wer es probiert hat und scheiterte, bekommt gerechnet.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// <b>Das Urteil des Browsers schlägt seine eigene Auskunft.</b>
|
||
/// <c>canPlayType</c> ist eine Behauptung: „kenne ich" heisst nicht „kann
|
||
/// ich diese Datei". Gemessen in Chromium — <c>canPlayType('audio/flac')</c>
|
||
/// sagt „probably", <c>MediaSource.isTypeSupported</c> derselben
|
||
/// Zeichenkette sagt <c>false</c>. Wer es ausprobiert hat, weiss mehr.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Erzwungen_wird_gerechnet_auch_wenn_alles_passt()
|
||
{
|
||
IReadOnlyList<ProbedStream> spuren = [Bild("h264"), Ton(1, "aac")];
|
||
|
||
var ohne = Stromentscheid.Fuer("mp4", spuren, Browser);
|
||
var mit = Stromentscheid.Fuer("mp4", spuren, Browser, erzwingen: true);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(ohne.Art, Is.EqualTo(Stromart.Direkt), "ohne Zwang geht die Datei durch");
|
||
Assert.That(mit.Art, Is.EqualTo(Stromart.Umkodieren));
|
||
Assert.That(mit.Gruende, Does.Contain(Stromgrund.SpielerKamNichtZurecht));
|
||
Assert.That(mit.BildKopieren, Is.False, "umkodieren heisst: das Bild wird angefasst");
|
||
});
|
||
}
|
||
|
||
/// <summary>Und die gewählte Stufe bleibt dabei erhalten.</summary>
|
||
[Test]
|
||
public void Erzwungen_bleibt_die_gewaehlte_Stufe()
|
||
{
|
||
var plan = Stromentscheid.Fuer(
|
||
"mp4", [Bild("h264", 2160), Ton(1, "aac")], Browser, 720, erzwingen: true);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(plan.Art, Is.EqualTo(Stromart.Umkodieren));
|
||
Assert.That(plan.Hoehe, Is.EqualTo(720));
|
||
});
|
||
}
|
||
|
||
/// <summary>Beim Umpacken ist die Stufe gegenstandslos.</summary>
|
||
///
|
||
/// <remarks>
|
||
/// Wird das Bild kopiert, gibt es nichts zu kodieren — dann darf auch kein
|
||
/// Preset in der Zeile stehen, sonst lehnt ffmpeg sie ab.
|
||
/// </remarks>
|
||
[Test]
|
||
public void Wer_nur_umpackt_bekommt_kein_Preset()
|
||
{
|
||
var zeile = Zeile([Bild(), Ton(1)], stufe: Kodierstufe.Qualitaet);
|
||
|
||
Assert.Multiple(() =>
|
||
{
|
||
Assert.That(zeile, Does.Contain("-c:v copy"));
|
||
Assert.That(zeile, Does.Not.Contain("-preset"));
|
||
Assert.That(zeile, Does.Not.Contain("-crf"));
|
||
});
|
||
}
|
||
}
|