Stufe 3: Download mit allen Ton- und Textspuren
**Der Grund, warum es diesen Server gibt.** Eine MKV mit zwei Tonspuren geht
hinein, eine MP4 mit zwei Tonspuren kommt heraus — mitsamt Sprachkennung und
Spurnamen. Im Container nachgewiesen, nicht nur im Test:
0 video h264 und
1 audio aac deu Deutsch
2 audio aac deu Audiodeskription
3 subtitle mov_text deu
Jellyfins Transcode-Endpunkt bildet je Sitzung **eine** Tonspur ab und
verliert beim Umpacken zusätzlich die Sprachkennungen. Der Plan hier hat gar
kein Feld „welche Tonspur" — es gibt nichts auszuwählen, weil alle mitgehen.
**Vorher fragen können.** `GET /files/{id}/delivery` sagt, was geschehen wird:
umgepackt oder nicht, welche Tonspuren neu gerechnet werden müssen, welche
Untertitel nicht mitkönnen. Drei Gigabyte zu laden und erst danach zu merken,
dass die falsche Tonspur drin ist, war der Anlass für das Ganze.
**Umgepackt wird auf die Platte, nicht in die Antwort.** Der bequeme Weg wäre,
ffmpeg durchzureichen. Dann kennt aber niemand die Länge im Voraus: kein
Fortschrittsbalken, kein Fortsetzen, kein Springen. Jetzt kommt beim ersten
Abruf ein 202 mit Fortschritt, danach die fertige Datei mit `Content-Length`
und `Accept-Ranges`.
**Bildbasierte Untertitel fallen weg, und das steht im Plan.** PGS passt in
keine MP4 — betrifft fast jeden Blu-ray-Rip. Stillschweigend wegzulassen
hiesse, jemanden nach Untertiteln suchen zu lassen, die der Server bewusst
entfernt hat.
---
**Zwei Funde aus echten Messungen:**
*Die Spurnamen überlebten das Umpacken nicht* — „Deutsch" kam als `null` an,
und damit wären zwei deutsche Tonspuren hinterher nicht mehr zu unterscheiden
gewesen. Ein Versuch an einer echten Datei zeigte den Grund: **MP4 nennt das
Feld `name`, Matroska nennt es `title`.** ffmpeg schreibt das eine ins andere
um; mein Leser kannte nur `title`. Keine Grenze des Formats, ein Lesefehler.
`handler_name` steht ausdrücklich nicht in der Suche — dort schreibt ffmpeg
„SoundHandler" hinein.
*Der Image-Bau brach mit Code 100 ab.* `intel-media-va-driver` gibt es für
arm64 nicht, und die Meldung verrät nicht, welches von sechs Paketen fehlt.
Die Intel-Treiber kommen jetzt nur auf amd64 dazu; `mesa-va-drivers` bedient
AMD auf beiden.
---
**Die ffmpeg-Zeile ist eine reine Funktion und wird ohne Ausführen geprüft.**
Hier liegt die Erfahrung dieser Woche: eine falsche Parameterkombination
kostete Tage, weil sie nur gegen einen echten Server zu entdecken war. Dazu
gehört die Verwechslung, vor der jetzt ein Test steht: `-c:a:1` meint die
zweite Tonspur der **Ausgabe**, nicht Spur 1 der Datei.
ffmpeg läuft als eigener Prozess, nicht als eingebundene Bibliothek — das
hält die Lizenzen getrennt und lässt einen Absturz dort den Server nicht
mitnehmen.
223 Tests grün (98 Kern, 31 Metadaten, 26 Medien, 68 Schnittstelle).
Image baut für amd64 und arm64, mit ffmpeg 6.1.1 und VAAPI.
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
deefc79fc1
commit
e4a90fce4e
@@ -0,0 +1,150 @@
|
||||
using Halo.Core.Library;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Halo.Media.Tests;
|
||||
|
||||
public class FfprobeRunnerTests
|
||||
{
|
||||
private string _ordner = "";
|
||||
private FfprobeRunner _ffprobe = null!;
|
||||
|
||||
[SetUp]
|
||||
public void Anlegen()
|
||||
{
|
||||
if (!Testdateien.FfmpegVorhanden) Assert.Ignore("ffmpeg ist auf diesem Rechner nicht installiert.");
|
||||
_ordner = Directory.CreateDirectory(
|
||||
Path.Combine(Path.GetTempPath(), "halo-probe-" + Guid.CreateVersion7().ToString("N"))).FullName;
|
||||
_ffprobe = new FfprobeRunner(
|
||||
new FfmpegOptions(Testdateien.Suchen("ffmpeg")!, Testdateien.Suchen("ffprobe")!),
|
||||
NullLogger<FfprobeRunner>.Instance);
|
||||
}
|
||||
|
||||
[TearDown]
|
||||
public void Aufraeumen()
|
||||
{
|
||||
try { if (_ordner.Length > 0) Directory.Delete(_ordner, recursive: true); } catch (IOException) { }
|
||||
}
|
||||
|
||||
/// <summary>Die Frage, um die es im ganzen Projekt geht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Zwei Tonspuren, beide deutsch, eine davon Audiodeskription.</b> Genau
|
||||
/// diese Datei hat die Sache ausgelöst: die Sprachkennung ist bei beiden
|
||||
/// „deu", und nur der Name unterscheidet sie. Wer hier nur die Sprache
|
||||
/// liest, kann die Frage „welche willst du?" gar nicht stellen.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Zwei_Tonspuren_werden_mit_Sprache_und_Namen_gelesen()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "zwei-tonspuren.mkv");
|
||||
Testdateien.MitZweiTonspuren(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
|
||||
Assert.That(ergebnis, Is.Not.Null);
|
||||
var ton = ergebnis!.Streams.Where(s => s.Kind == MediaStreamKind.Audio).ToList();
|
||||
|
||||
Assert.That(ton, Has.Count.EqualTo(2));
|
||||
Assert.That(ton.Select(t => t.Language), Is.EqualTo(new[] { "deu", "deu" }));
|
||||
Assert.That(ton.Select(t => t.Title), Is.EqualTo(new[] { "Deutsch", "Audiodeskription" }));
|
||||
Assert.That(ton[0].Codec, Is.EqualTo("aac"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Bild_Ton_und_Untertitel_werden_auseinandergehalten()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "alles.mkv");
|
||||
Testdateien.MitZweiTonspuren(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
|
||||
Assert.That(ergebnis!.Streams.Count(s => s.Kind == MediaStreamKind.Video), Is.EqualTo(1));
|
||||
Assert.That(ergebnis.Streams.Count(s => s.Kind == MediaStreamKind.Audio), Is.EqualTo(2));
|
||||
Assert.That(ergebnis.Streams.Count(s => s.Kind == MediaStreamKind.Subtitle), Is.EqualTo(1));
|
||||
}
|
||||
|
||||
/// <summary>Die Nummern müssen die von ffmpeg sein, nicht eine eigene Zählung.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// An ihnen hängt später das Umpacken: <c>-map 0:2</c> spricht die dritte
|
||||
/// Spur an. Eine eigene Zählung je Art wäre dort eine Falle.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Die_Spurnummern_sind_die_von_ffmpeg()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "nummern.mkv");
|
||||
Testdateien.MitZweiTonspuren(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
Assert.That(ergebnis!.Streams.Select(s => s.Index), Is.EqualTo(new[] { 0, 1, 2, 3 }));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Schachtel_Dauer_und_Bildgroesse_kommen_mit()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "angaben.mkv");
|
||||
Testdateien.MitZweiTonspuren(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
|
||||
Assert.That(ergebnis!.Container, Is.EqualTo("mkv"));
|
||||
Assert.That(ergebnis.Duration, Is.Not.Null);
|
||||
Assert.That(ergebnis.Duration!.Value.TotalSeconds, Is.EqualTo(1).Within(0.5));
|
||||
|
||||
var bild = ergebnis.Streams.Single(s => s.Kind == MediaStreamKind.Video);
|
||||
Assert.That((bild.Width, bild.Height), Is.EqualTo((160, 120)));
|
||||
}
|
||||
|
||||
/// <summary>Die MP4-Familie meldet sechs Namen auf einmal.</summary>
|
||||
[Test]
|
||||
public async Task Eine_MP4_heisst_mp4_und_nicht_mov_mp4_m4a_3gp_3g2_mj2()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "einfach.mp4");
|
||||
Testdateien.Einfach(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
Assert.That(ergebnis!.Container, Is.EqualTo("mp4"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Eine_Datei_die_es_nicht_gibt_ergibt_nichts()
|
||||
{
|
||||
Assert.That(await _ffprobe.ProbeAsync(Path.Combine(_ordner, "gibtesnicht.mkv")), Is.Null);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Eine_Datei_die_kein_Video_ist_ergibt_nichts()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "kaputt.mkv");
|
||||
await File.WriteAllTextAsync(datei, "das ist kein Film");
|
||||
Assert.That(await _ffprobe.ProbeAsync(datei), Is.Null);
|
||||
}
|
||||
|
||||
/// <summary>Ein Dateiname mit Anführungszeichen darf nichts ausführen.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Die Argumente gehen als Liste an den Prozess, nicht als zusammengesetzte
|
||||
/// Zeile. Sonst bestimmte der Dateiname mit, was ausgeführt wird.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Ein_Dateiname_mit_Anfuehrungszeichen_wird_gelesen()
|
||||
{
|
||||
var datei = Path.Combine(_ordner, "Der \"echte\" Film; echo nein.mkv");
|
||||
Testdateien.Einfach(datei);
|
||||
|
||||
var ergebnis = await _ffprobe.ProbeAsync(datei);
|
||||
Assert.That(ergebnis, Is.Not.Null);
|
||||
Assert.That(ergebnis!.Streams, Is.Not.Empty);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Ein_fehlendes_ffprobe_wirft_nicht()
|
||||
{
|
||||
var ohne = new FfprobeRunner(
|
||||
new FfmpegOptions("ffmpeg", "/gibt/es/nicht/ffprobe"), NullLogger<FfprobeRunner>.Instance);
|
||||
var datei = Path.Combine(_ordner, "egal.mp4");
|
||||
Testdateien.Einfach(datei);
|
||||
|
||||
Assert.That(await ohne.ProbeAsync(datei), Is.Null);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<IsPackable>false</IsPackable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="coverlet.collector" Version="6.0.4" />
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
|
||||
<PackageReference Include="NUnit" Version="4.3.2" />
|
||||
<PackageReference Include="NUnit.Analyzers" Version="4.7.0" />
|
||||
<PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<Using Include="NUnit.Framework" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\src\Halo.Media\Halo.Media.csproj" />
|
||||
<ProjectReference Include="..\..\src\Halo.Core\Halo.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,121 @@
|
||||
using Halo.Core.Delivery;
|
||||
using Halo.Core.Library;
|
||||
|
||||
namespace Halo.Media.Tests;
|
||||
|
||||
/// <summary>Die ffmpeg-Zeile, betrachtet ohne sie auszuführen.</summary>
|
||||
public class RemuxArgumentsTests
|
||||
{
|
||||
private static ProbedStream Bild() => new(0, MediaStreamKind.Video, "h264", null, null, true, false, null, 1920, 1080);
|
||||
private static ProbedStream Ton(int i, string codec = "aac", int kanäle = 6) =>
|
||||
new(i, MediaStreamKind.Audio, codec, "deu", null, false, false, kanäle, null, null);
|
||||
private static ProbedStream Text(int i, string codec = "subrip") =>
|
||||
new(i, MediaStreamKind.Subtitle, codec, "deu", null, false, false, null, null, null);
|
||||
|
||||
private static List<string> Bauen(IReadOnlyList<ProbedStream> spuren, string schachtel = "mkv")
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload(schachtel, spuren);
|
||||
return RemuxArguments.For(new RemuxRequest("/medien/film.mkv", "/kratz/film.mp4", spuren, plan));
|
||||
}
|
||||
|
||||
private static string AlsZeile(List<string> argumente) => string.Join(' ', argumente);
|
||||
|
||||
/// <summary>Jede Spur wird einzeln benannt — und zwar alle.</summary>
|
||||
[Test]
|
||||
public void Alle_Spuren_werden_abgebildet()
|
||||
{
|
||||
var zeile = AlsZeile(Bauen([Bild(), Ton(1), Ton(2), Text(3)]));
|
||||
|
||||
Assert.That(zeile, Does.Contain("-map 0:0"));
|
||||
Assert.That(zeile, Does.Contain("-map 0:1"));
|
||||
Assert.That(zeile, Does.Contain("-map 0:2"));
|
||||
Assert.That(zeile, Does.Contain("-map 0:3"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Bild_und_Ton_werden_kopiert_nicht_gerechnet()
|
||||
{
|
||||
var zeile = AlsZeile(Bauen([Bild(), Ton(1), Ton(2)]));
|
||||
|
||||
Assert.That(zeile, Does.Contain("-c copy"));
|
||||
Assert.That(zeile, Does.Not.Contain("-c:a:"), "Nichts davon muss neu gerechnet werden");
|
||||
Assert.That(zeile, Does.Not.Contain("libx264"), "Das Bild wird nie angefasst");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Textuntertitel_werden_nach_tx3g_umgeschrieben()
|
||||
{
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1), Text(2)])), Does.Contain("-c:s mov_text"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Ohne_Untertitel_steht_auch_keine_Untertitel_Anweisung_da()
|
||||
{
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1)])), Does.Not.Contain("-c:s"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Bilduntertitel_werden_gar_nicht_erst_abgebildet()
|
||||
{
|
||||
var zeile = AlsZeile(Bauen([Bild(), Ton(1), Text(2, "hdmv_pgs_subtitle"), Text(3, "subrip")]));
|
||||
|
||||
Assert.That(zeile, Does.Not.Contain("-map 0:2"), "PGS passt in keine MP4");
|
||||
Assert.That(zeile, Does.Contain("-map 0:3"));
|
||||
}
|
||||
|
||||
/// <summary>Die Verwechslung, vor der der Kommentar an MediaStream.Index warnt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b><c>-c:a:1</c> meint die zweite Tonspur der Ausgabe, nicht die Spur
|
||||
/// Nummer 1 der Datei.</b> Hier steht DTS an Dateinummer 2 und ist die
|
||||
/// zweite Tonspur — also <c>-c:a:1</c>. Wer die Dateinummer einsetzte,
|
||||
/// träfe eine andere Spur oder gar keine.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public void Neu_gerechnet_wird_nach_der_Nummer_der_Ausgabe()
|
||||
{
|
||||
var zeile = AlsZeile(Bauen([Bild(), Ton(1, "aac"), Ton(2, "dts"), Ton(3, "aac")]));
|
||||
|
||||
Assert.That(zeile, Does.Contain("-c:a:1 aac"));
|
||||
Assert.That(zeile, Does.Not.Contain("-c:a:0"), "Die erste Tonspur passt schon");
|
||||
Assert.That(zeile, Does.Not.Contain("-c:a:2"), "Die dritte auch");
|
||||
}
|
||||
|
||||
/// <summary>Fällt ein Untertitel weg, verschieben sich die Tonnummern nicht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Tonspuren werden unter sich gezählt — ein weggelassener Untertitel
|
||||
/// ändert daran nichts. Die Prüfung steht hier, weil der umgekehrte Fehler
|
||||
/// naheliegt und erst an einer stummen Spur auffiele.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public void Ein_weggelassener_Untertitel_verschiebt_die_Tonnummern_nicht()
|
||||
{
|
||||
var zeile = AlsZeile(Bauen([Bild(), Text(1, "hdmv_pgs_subtitle"), Ton(2, "aac"), Ton(3, "dts")]));
|
||||
Assert.That(zeile, Does.Contain("-c:a:1 aac"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Mehr_Kanaele_bekommen_mehr_Bitrate()
|
||||
{
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1, "dts", kanäle: 2)])), Does.Contain("-b:a:0 192000"));
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1, "dts", kanäle: 6)])), Does.Contain("-b:a:0 576000"));
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1, "dts", kanäle: 8)])), Does.Contain("-b:a:0 640000"),
|
||||
"Gedeckelt — acht Kanäle bekämen sonst mehr, als irgendein Gerät braucht");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Das_Inhaltsverzeichnis_wandert_nach_vorn()
|
||||
{
|
||||
Assert.That(AlsZeile(Bauen([Bild(), Ton(1)])), Does.Contain("-movflags +faststart"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Quelle_und_Ziel_stehen_an_der_richtigen_Stelle()
|
||||
{
|
||||
var argumente = Bauen([Bild(), Ton(1)]);
|
||||
|
||||
Assert.That(argumente[argumente.IndexOf("-i") + 1], Is.EqualTo("/medien/film.mkv"));
|
||||
Assert.That(argumente[^1], Is.EqualTo("/kratz/film.mp4"), "Das Ziel steht bei ffmpeg immer zuletzt");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
using Halo.Core.Delivery;
|
||||
using Halo.Core.Library;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Halo.Media.Tests;
|
||||
|
||||
/// <summary>Umpacken, von der echten Datei bis zum Ergebnis.</summary>
|
||||
public class RemuxTests
|
||||
{
|
||||
private string _ordner = "";
|
||||
private FfprobeRunner _ffprobe = null!;
|
||||
private FfmpegRemuxer _umpacker = null!;
|
||||
|
||||
[SetUp]
|
||||
public void Anlegen()
|
||||
{
|
||||
if (!Testdateien.FfmpegVorhanden) Assert.Ignore("ffmpeg ist auf diesem Rechner nicht installiert.");
|
||||
_ordner = Directory.CreateDirectory(
|
||||
Path.Combine(Path.GetTempPath(), "halo-umpacken-" + Guid.CreateVersion7().ToString("N"))).FullName;
|
||||
var optionen = new FfmpegOptions(Testdateien.Suchen("ffmpeg")!, Testdateien.Suchen("ffprobe")!);
|
||||
_ffprobe = new FfprobeRunner(optionen, NullLogger<FfprobeRunner>.Instance);
|
||||
_umpacker = new FfmpegRemuxer(optionen, NullLogger<FfmpegRemuxer>.Instance);
|
||||
}
|
||||
|
||||
[TearDown]
|
||||
public void Aufraeumen()
|
||||
{
|
||||
try { if (_ordner.Length > 0) Directory.Delete(_ordner, recursive: true); } catch (IOException) { }
|
||||
}
|
||||
|
||||
private async Task<(RemuxOutcome Ergebnis, ProbeResult? Danach)> Umpacken(
|
||||
string quelle, IProgress<double>? fortschritt = null)
|
||||
{
|
||||
var davor = await _ffprobe.ProbeAsync(quelle);
|
||||
Assert.That(davor, Is.Not.Null, "Die Quelldatei liess sich nicht lesen");
|
||||
|
||||
var plan = DeliveryDecider.ForDownload(davor!.Container, davor.Streams);
|
||||
var ziel = Path.Combine(_ordner, Path.GetFileNameWithoutExtension(quelle) + ".mp4");
|
||||
|
||||
var ergebnis = await _umpacker.RunAsync(
|
||||
new RemuxRequest(quelle, ziel, davor.Streams, plan), davor.Duration, fortschritt);
|
||||
|
||||
return (ergebnis, ergebnis.Success ? await _ffprobe.ProbeAsync(ziel) : null);
|
||||
}
|
||||
|
||||
/// <summary>Der Beweis, auf dem das ganze Projekt ruht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Zwei Tonspuren und ein Untertitel gehen hinein, und alles kommt in
|
||||
/// der MP4 wieder heraus</b> — samt Sprachkennung und Namen. Genau das
|
||||
/// kann Jellyfins Transcode-Endpunkt nicht: der bildet je Sitzung eine
|
||||
/// Tonspur ab, und beim Umpacken verliert er zusätzlich die
|
||||
/// Sprachkennungen. Dass hier beides erhalten bleibt, ist der Grund für
|
||||
/// diesen Server.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Alle_Ton_und_Textspuren_ueberstehen_das_Umpacken()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "zwei-tonspuren.mkv");
|
||||
Testdateien.MitZweiTonspuren(quelle);
|
||||
|
||||
var (ergebnis, danach) = await Umpacken(quelle);
|
||||
|
||||
Assert.That(ergebnis.Success, Is.True, ergebnis.Error);
|
||||
Assert.That(danach!.Container, Is.EqualTo("mp4"));
|
||||
|
||||
var ton = danach.Streams.Where(s => s.Kind == MediaStreamKind.Audio).ToList();
|
||||
Assert.That(ton, Has.Count.EqualTo(2), "Beide Tonspuren müssen da sein");
|
||||
Assert.That(ton.Select(t => t.Title), Is.EqualTo(new[] { "Deutsch", "Audiodeskription" }),
|
||||
"Die Namen unterscheiden die beiden — ohne sie wäre keine Auswahl möglich");
|
||||
Assert.That(ton.Select(t => t.Language), Is.EqualTo(new[] { "deu", "deu" }),
|
||||
"Die Sprachkennung überlebt — Jellyfin verliert sie an dieser Stelle");
|
||||
|
||||
Assert.That(danach.Streams.Count(s => s.Kind == MediaStreamKind.Subtitle), Is.EqualTo(1));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Der_Untertitel_liegt_danach_als_tx3g_vor()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "mit-text.mkv");
|
||||
Testdateien.MitZweiTonspuren(quelle);
|
||||
|
||||
var (_, danach) = await Umpacken(quelle);
|
||||
|
||||
var text = danach!.Streams.Single(s => s.Kind == MediaStreamKind.Subtitle);
|
||||
Assert.That(text.Codec, Is.EqualTo("mov_text"), "MP4 kennt nur diese eine Form");
|
||||
Assert.That(text.Language, Is.EqualTo("deu"));
|
||||
}
|
||||
|
||||
/// <summary>Nur die untaugliche Spur wird gerechnet, die andere kopiert.</summary>
|
||||
[Test]
|
||||
public async Task Eine_untaugliche_Tonspur_wird_gerechnet_die_taugliche_nicht()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "gemischt.mkv");
|
||||
Testdateien.MitUntauglichemTon(quelle);
|
||||
|
||||
var davor = await _ffprobe.ProbeAsync(quelle);
|
||||
Assert.That(davor!.Streams.Select(s => s.Codec), Does.Contain("dts"), "Die Vorlage muss DTS enthalten");
|
||||
|
||||
var (ergebnis, danach) = await Umpacken(quelle);
|
||||
Assert.That(ergebnis.Success, Is.True, ergebnis.Error);
|
||||
|
||||
var ton = danach!.Streams.Where(s => s.Kind == MediaStreamKind.Audio).ToList();
|
||||
Assert.That(ton, Has.Count.EqualTo(2));
|
||||
Assert.That(ton.Select(t => t.Codec), Is.EqualTo(new[] { "aac", "aac" }),
|
||||
"DTS wurde zu AAC, und die erste Spur blieb, was sie war");
|
||||
Assert.That(ton.Select(t => t.Language), Is.EqualTo(new[] { "deu", "eng" }),
|
||||
"Auch die neu gerechnete Spur behält ihre Sprache");
|
||||
}
|
||||
|
||||
/// <summary>Das Bild wird nie angefasst — nachgewiesen an der Bildgrösse und am Codec.</summary>
|
||||
[Test]
|
||||
public async Task Das_Bild_bleibt_unberuehrt()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "bild.mkv");
|
||||
Testdateien.MitZweiTonspuren(quelle);
|
||||
|
||||
var davor = await _ffprobe.ProbeAsync(quelle);
|
||||
var (_, danach) = await Umpacken(quelle);
|
||||
|
||||
var vorher = davor!.Streams.Single(s => s.Kind == MediaStreamKind.Video);
|
||||
var nachher = danach!.Streams.Single(s => s.Kind == MediaStreamKind.Video);
|
||||
|
||||
Assert.That(nachher.Codec, Is.EqualTo(vorher.Codec));
|
||||
Assert.That((nachher.Width, nachher.Height), Is.EqualTo((vorher.Width, vorher.Height)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Der_Fortschritt_wird_gemeldet_und_endet_bei_eins()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "fortschritt.mkv");
|
||||
Testdateien.MitZweiTonspuren(quelle);
|
||||
|
||||
var gemeldet = new List<double>();
|
||||
var (ergebnis, _) = await Umpacken(quelle, new Progress<double>(w => { lock (gemeldet) gemeldet.Add(w); }));
|
||||
|
||||
Assert.That(ergebnis.Success, Is.True);
|
||||
// Progress<T> meldet über den Synchronisierungskontext — kurz warten.
|
||||
await Task.Delay(200);
|
||||
lock (gemeldet)
|
||||
{
|
||||
Assert.That(gemeldet, Is.Not.Empty);
|
||||
Assert.That(gemeldet[^1], Is.EqualTo(1.0));
|
||||
Assert.That(gemeldet, Is.Ordered, "Der Fortschritt darf nicht zurückspringen");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Eine halbe Datei ist schlimmer als keine.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Bliebe sie liegen, hielte der nächste Aufruf sie für fertig und gäbe
|
||||
/// einen abgeschnittenen Film heraus — der beim Abspielen mittendrin
|
||||
/// abbricht.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Nach_einem_Fehlschlag_liegt_keine_halbe_Datei_herum()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "kaputt.mkv");
|
||||
await File.WriteAllTextAsync(quelle, "das ist kein Film");
|
||||
var ziel = Path.Combine(_ordner, "kaputt.mp4");
|
||||
|
||||
var ergebnis = await _umpacker.RunAsync(new RemuxRequest(
|
||||
quelle, ziel, [], new DeliveryPlan(DeliveryMethod.Remux, [], [], [])));
|
||||
|
||||
Assert.That(ergebnis.Success, Is.False);
|
||||
Assert.That(ergebnis.Error, Is.Not.Null.And.Not.Empty);
|
||||
Assert.That(File.Exists(ziel), Is.False);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Ein_Abbruch_laesst_nichts_zurueck()
|
||||
{
|
||||
var quelle = Path.Combine(_ordner, "abbruch.mkv");
|
||||
Testdateien.MitZweiTonspuren(quelle);
|
||||
var ziel = Path.Combine(_ordner, "abbruch.mp4");
|
||||
|
||||
var davor = await _ffprobe.ProbeAsync(quelle);
|
||||
using var abbruch = new CancellationTokenSource();
|
||||
await abbruch.CancelAsync();
|
||||
|
||||
Assert.ThrowsAsync<OperationCanceledException>(() => _umpacker.RunAsync(
|
||||
new RemuxRequest(quelle, ziel, davor!.Streams,
|
||||
DeliveryDecider.ForDownload(davor.Container, davor.Streams)),
|
||||
ct: abbruch.Token));
|
||||
|
||||
Assert.That(File.Exists(ziel), Is.False);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace Halo.Media.Tests;
|
||||
|
||||
/// <summary>Baut echte Mediendateien mit ffmpeg.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Echte Dateien und keine aufgezeichneten Antworten.</b> Bei TMDB ist das
|
||||
/// umgekehrt richtig — dort steht ein fremder Dienst dahinter. Hier geht es
|
||||
/// um das Werkzeug, das Halo im Container ohnehin mitbringt, und die Frage
|
||||
/// „liest er die zweite Tonspur mitsamt Sprache?" lässt sich nur an einer
|
||||
/// Datei beantworten, die wirklich zwei hat.
|
||||
/// </remarks>
|
||||
public static class Testdateien
|
||||
{
|
||||
public static bool FfmpegVorhanden => Suchen("ffmpeg") is not null && Suchen("ffprobe") is not null;
|
||||
|
||||
public static string? Suchen(string name)
|
||||
{
|
||||
foreach (var ordner in (Environment.GetEnvironmentVariable("PATH") ?? "").Split(Path.PathSeparator))
|
||||
{
|
||||
if (ordner.Length == 0) continue;
|
||||
var pfad = Path.Combine(ordner, name);
|
||||
if (File.Exists(pfad)) return pfad;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Zwei Tonspuren mit Sprache und Namen, dazu ein Untertitel.</summary>
|
||||
public static void MitZweiTonspuren(string ziel)
|
||||
{
|
||||
var untertitel = Path.ChangeExtension(ziel, ".srt");
|
||||
File.WriteAllText(untertitel,
|
||||
"1\n00:00:00,000 --> 00:00:01,000\nEin Untertitel\n\n");
|
||||
|
||||
Ausführen("ffmpeg",
|
||||
[
|
||||
"-y", "-loglevel", "error",
|
||||
"-f", "lavfi", "-i", "testsrc=duration=1:size=160x120:rate=10",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=1",
|
||||
"-f", "lavfi", "-i", "sine=frequency=880:duration=1",
|
||||
"-i", untertitel,
|
||||
"-map", "0:v", "-map", "1:a", "-map", "2:a", "-map", "3:s",
|
||||
"-metadata:s:a:0", "language=deu", "-metadata:s:a:0", "title=Deutsch",
|
||||
"-metadata:s:a:1", "language=deu", "-metadata:s:a:1", "title=Audiodeskription",
|
||||
"-metadata:s:s:0", "language=deu",
|
||||
"-c:v", "libx264", "-preset", "ultrafast", "-c:a", "aac", "-c:s", "srt",
|
||||
ziel,
|
||||
]);
|
||||
File.Delete(untertitel);
|
||||
}
|
||||
|
||||
/// <summary>Eine schlichte MP4 mit einer Tonspur.</summary>
|
||||
public static void Einfach(string ziel) => Ausführen("ffmpeg",
|
||||
[
|
||||
"-y", "-loglevel", "error",
|
||||
"-f", "lavfi", "-i", "testsrc=duration=1:size=160x120:rate=10",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=1",
|
||||
"-c:v", "libx264", "-preset", "ultrafast", "-c:a", "aac",
|
||||
ziel,
|
||||
]);
|
||||
|
||||
/// <summary>Eine MKV mit einer Tonspur in einem Codec, den Apple nicht kennt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>DTS, also der echte Fall.</b> So liegen Blu-ray-Rips vor, und genau
|
||||
/// daran entscheidet sich, ob eine sonst tadellose Datei stumm bliebe.
|
||||
/// Der Encoder gilt bei ffmpeg als erprobungsweise und braucht deshalb
|
||||
/// <c>-strict -2</c> — das betrifft nur das Erzeugen dieser Testvorlage,
|
||||
/// nicht Halo.
|
||||
/// </remarks>
|
||||
public static void MitUntauglichemTon(string ziel) => Ausführen("ffmpeg",
|
||||
[
|
||||
"-y", "-loglevel", "error",
|
||||
"-f", "lavfi", "-i", "testsrc=duration=1:size=160x120:rate=10",
|
||||
"-f", "lavfi", "-i", "sine=frequency=440:duration=1",
|
||||
"-f", "lavfi", "-i", "sine=frequency=880:duration=1",
|
||||
"-map", "0:v", "-map", "1:a", "-map", "2:a",
|
||||
"-metadata:s:a:0", "language=deu", "-metadata:s:a:0", "title=Deutsch",
|
||||
"-metadata:s:a:1", "language=eng", "-metadata:s:a:1", "title=English",
|
||||
"-c:v", "libx264", "-preset", "ultrafast",
|
||||
"-c:a:0", "aac", "-c:a:1", "dca", "-strict", "-2",
|
||||
ziel,
|
||||
]);
|
||||
|
||||
private static void Ausführen(string werkzeug, string[] argumente)
|
||||
{
|
||||
var start = new ProcessStartInfo(Suchen(werkzeug)!) { RedirectStandardError = true, UseShellExecute = false };
|
||||
foreach (var a in argumente) start.ArgumentList.Add(a);
|
||||
|
||||
using var prozess = Process.Start(start)!;
|
||||
var fehler = prozess.StandardError.ReadToEnd();
|
||||
prozess.WaitForExit();
|
||||
if (prozess.ExitCode != 0)
|
||||
throw new InvalidOperationException($"{werkzeug} scheiterte: {fehler}");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user