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,192 @@
|
||||
using System.Diagnostics;
|
||||
using System.Net;
|
||||
using System.Net.Http.Headers;
|
||||
using System.Net.Http.Json;
|
||||
using Halo.Api.Endpoints;
|
||||
|
||||
namespace Halo.Api.Tests;
|
||||
|
||||
/// <summary>Der Weg vom Scan bis zur heruntergeladenen Datei.</summary>
|
||||
public class DeliveryTests
|
||||
{
|
||||
private string _bestand = "";
|
||||
|
||||
private static string? Werkzeug(string name) =>
|
||||
(Environment.GetEnvironmentVariable("PATH") ?? "").Split(Path.PathSeparator)
|
||||
.Select(o => o.Length == 0 ? null : Path.Combine(o, name))
|
||||
.FirstOrDefault(p => p is not null && File.Exists(p));
|
||||
|
||||
[SetUp]
|
||||
public void Anlegen()
|
||||
{
|
||||
if (Werkzeug("ffmpeg") is null) Assert.Ignore("ffmpeg ist auf diesem Rechner nicht installiert.");
|
||||
_bestand = Directory.CreateDirectory(
|
||||
Path.Combine(Path.GetTempPath(), "halo-liefern-" + Guid.CreateVersion7().ToString("N"))).FullName;
|
||||
}
|
||||
|
||||
[TearDown]
|
||||
public void Aufraeumen()
|
||||
{
|
||||
try { if (_bestand.Length > 0) Directory.Delete(_bestand, recursive: true); } catch (IOException) { }
|
||||
}
|
||||
|
||||
/// <summary>Eine Datei mit zwei Tonspuren, in der gewünschten Schachtel.</summary>
|
||||
private string Film(string name, string endung)
|
||||
{
|
||||
var ziel = Path.Combine(_bestand, $"{name}.{endung}");
|
||||
var start = new ProcessStartInfo(Werkzeug("ffmpeg")!) { RedirectStandardError = true, UseShellExecute = false };
|
||||
foreach (var a in new[]
|
||||
{
|
||||
"-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=deu", "-metadata:s:a:1", "title=Audiodeskription",
|
||||
"-c:v", "libx264", "-preset", "ultrafast", "-c:a", "aac", ziel,
|
||||
}) start.ArgumentList.Add(a);
|
||||
|
||||
using var prozess = Process.Start(start)!;
|
||||
var fehler = prozess.StandardError.ReadToEnd();
|
||||
prozess.WaitForExit();
|
||||
if (prozess.ExitCode != 0) throw new InvalidOperationException(fehler);
|
||||
return ziel;
|
||||
}
|
||||
|
||||
private async Task<(HttpClient Client, MediaFileResponse Datei)> Eingelesen()
|
||||
{
|
||||
var server = _server = new HaloServer();
|
||||
var admin = await server.SetUpAndSignIn();
|
||||
var client = server.AlsAngemeldeter(admin.Token);
|
||||
|
||||
var angelegt = await client.PostAsJsonAsync("/api/v1/libraries",
|
||||
new CreateLibraryRequest("Prüfbestand", "Movies", _bestand));
|
||||
angelegt.EnsureSuccessStatusCode();
|
||||
var bibliothek = (await angelegt.Content.ReadFromJsonAsync<LibraryResponse>())!;
|
||||
|
||||
(await client.PostAsync($"/api/v1/libraries/{bibliothek.Id}/scan", null)).EnsureSuccessStatusCode();
|
||||
for (var i = 0; i < 150; i++)
|
||||
{
|
||||
var stand = await client.GetFromJsonAsync<ScanStatus>($"/api/v1/libraries/{bibliothek.Id}/scan");
|
||||
if (stand!.State == "finished") break;
|
||||
await Task.Delay(50);
|
||||
}
|
||||
|
||||
var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
|
||||
Assert.That(filme!.Items, Is.Not.Empty, "Der Scan hat nichts gefunden");
|
||||
return (client, filme.Items[0].Files.Single());
|
||||
}
|
||||
|
||||
private HaloServer? _server;
|
||||
|
||||
[TearDown]
|
||||
public void ServerSchliessen() { _server?.Dispose(); _server = null; }
|
||||
|
||||
/// <summary>Der Scan trägt die Spuren ein — darunter die beiden Namen.</summary>
|
||||
[Test]
|
||||
public async Task Die_Spuren_stehen_in_der_Mediathek()
|
||||
{
|
||||
Film("Zwei Spuren (2020)", "mkv");
|
||||
var (_, datei) = await Eingelesen();
|
||||
|
||||
Assert.That(datei.Container, Is.EqualTo("mkv"));
|
||||
Assert.That(datei.DurationSeconds, Is.EqualTo(1).Within(0.5));
|
||||
|
||||
var ton = datei.Streams.Where(s => s.Kind == "Audio").ToList();
|
||||
Assert.That(ton, Has.Count.EqualTo(2));
|
||||
Assert.That(ton.Select(t => t.Title), Is.EqualTo(new[] { "Deutsch", "Audiodeskription" }));
|
||||
}
|
||||
|
||||
/// <summary>Der volle Pfad des Servers geht niemanden etwas an.</summary>
|
||||
[Test]
|
||||
public async Task Nur_der_Dateiname_kommt_heraus_nicht_der_Pfad()
|
||||
{
|
||||
Film("Pfadprobe (2020)", "mkv");
|
||||
var (_, datei) = await Eingelesen();
|
||||
|
||||
Assert.That(datei.FileName, Is.EqualTo("Pfadprobe (2020).mkv"));
|
||||
Assert.That(datei.FileName, Does.Not.Contain("/"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Eine_passende_MP4_geht_unveraendert_hinaus()
|
||||
{
|
||||
Film("Passend (2020)", "mp4");
|
||||
var (client, datei) = await Eingelesen();
|
||||
|
||||
var auskunft = await client.GetFromJsonAsync<DeliveryInfo>($"/api/v1/files/{datei.Id}/delivery");
|
||||
Assert.That(auskunft!.Method, Is.EqualTo("directFile"));
|
||||
Assert.That(auskunft.PackageState, Is.EqualTo("notNeeded"));
|
||||
|
||||
var antwort = await client.GetAsync($"/api/v1/files/{datei.Id}/download");
|
||||
Assert.That(antwort.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
||||
Assert.That(antwort.Content.Headers.ContentLength, Is.GreaterThan(0),
|
||||
"Ohne Längenangabe gäbe es keinen Fortschrittsbalken");
|
||||
}
|
||||
|
||||
/// <summary>Eine Matroska wird umgepackt — und der Client erfährt es vorher.</summary>
|
||||
[Test]
|
||||
public async Task Eine_Matroska_wird_angekuendigt_und_dann_umgepackt()
|
||||
{
|
||||
Film("Umzupacken (2020)", "mkv");
|
||||
var (client, datei) = await Eingelesen();
|
||||
|
||||
var auskunft = await client.GetFromJsonAsync<DeliveryInfo>($"/api/v1/files/{datei.Id}/delivery");
|
||||
Assert.That(auskunft!.Method, Is.EqualTo("remux"));
|
||||
Assert.That(auskunft.Reasons, Does.Contain("containerUnsupported"));
|
||||
Assert.That(auskunft.AudioToEncode, Is.Empty, "Beide Tonspuren passen und werden nur umgepackt");
|
||||
|
||||
// Der erste Abruf stösst an und wartet nicht.
|
||||
var erster = await client.GetAsync($"/api/v1/files/{datei.Id}/download");
|
||||
Assert.That(erster.StatusCode, Is.EqualTo(HttpStatusCode.Accepted));
|
||||
|
||||
HttpResponseMessage? fertig = null;
|
||||
for (var i = 0; i < 150; i++)
|
||||
{
|
||||
fertig = await client.GetAsync($"/api/v1/files/{datei.Id}/download");
|
||||
if (fertig.StatusCode != HttpStatusCode.Accepted) break;
|
||||
await Task.Delay(100);
|
||||
}
|
||||
|
||||
Assert.That(fertig!.StatusCode, Is.EqualTo(HttpStatusCode.OK));
|
||||
Assert.That(fertig.Content.Headers.ContentLength, Is.GreaterThan(0));
|
||||
Assert.That(fertig.Content.Headers.ContentDisposition?.FileNameStar ?? "",
|
||||
Does.EndWith(".mp4"), "Heruntergeladen wird eine MP4, nicht eine MKV");
|
||||
}
|
||||
|
||||
/// <summary>Fortsetzen nach einem Abbruch — die Forderung aus dem Fehlerbericht.</summary>
|
||||
[Test]
|
||||
public async Task Die_Auslieferung_versteht_Bereichsanfragen()
|
||||
{
|
||||
Film("Bereich (2020)", "mp4");
|
||||
var (client, datei) = await Eingelesen();
|
||||
|
||||
var anfrage = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/files/{datei.Id}/download");
|
||||
anfrage.Headers.Range = new RangeHeaderValue(100, 199);
|
||||
var antwort = await client.SendAsync(anfrage);
|
||||
|
||||
Assert.That(antwort.StatusCode, Is.EqualTo(HttpStatusCode.PartialContent));
|
||||
Assert.That((await antwort.Content.ReadAsByteArrayAsync()), Has.Length.EqualTo(100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Eine_Datei_die_es_nicht_gibt_ergibt_404()
|
||||
{
|
||||
Film("Egal (2020)", "mp4");
|
||||
var (client, _) = await Eingelesen();
|
||||
|
||||
var antwort = await client.GetAsync($"/api/v1/files/{Guid.CreateVersion7()}/download");
|
||||
Assert.That(antwort.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Ohne_Anmeldung_gibt_es_nichts()
|
||||
{
|
||||
Film("Geschuetzt (2020)", "mp4");
|
||||
var (_, datei) = await Eingelesen();
|
||||
|
||||
var antwort = await _server!.Client.GetAsync($"/api/v1/files/{datei.Id}/download");
|
||||
Assert.That(antwort.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
using Halo.Core.Delivery;
|
||||
using Halo.Core.Library;
|
||||
|
||||
namespace Halo.Core.Tests;
|
||||
|
||||
public class DeliveryDeciderTests
|
||||
{
|
||||
private static ProbedStream Bild(string codec = "h264") =>
|
||||
new(0, MediaStreamKind.Video, codec, null, null, true, false, null, 1920, 1080);
|
||||
|
||||
private static ProbedStream Ton(int index, string codec = "aac", string? sprache = "deu", string? name = null) =>
|
||||
new(index, MediaStreamKind.Audio, codec, sprache, name, index == 1, false, 6, null, null);
|
||||
|
||||
private static ProbedStream Text(int index, string codec = "subrip") =>
|
||||
new(index, MediaStreamKind.Subtitle, codec, "deu", null, false, false, null, null, null);
|
||||
|
||||
[Test]
|
||||
public void Eine_passende_MP4_geht_unveraendert_hinaus()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mp4", [Bild(), Ton(1)]);
|
||||
|
||||
Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
|
||||
Assert.That(plan.NeedsWork, Is.False);
|
||||
Assert.That(plan.Reasons, Is.EqualTo(new[] { DeliveryReason.NativelySupported }));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Eine_Matroska_muss_umgepackt_werden_auch_wenn_alles_darin_passt()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1)]);
|
||||
|
||||
Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.Remux));
|
||||
Assert.That(plan.Reasons, Does.Contain(DeliveryReason.ContainerUnsupported));
|
||||
// Das Bild bleibt unberührt, und kein Ton muss gerechnet werden.
|
||||
Assert.That(plan.AudioToEncode, Is.Empty);
|
||||
}
|
||||
|
||||
/// <summary>Der Fall, um den es im ganzen Projekt geht.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Zwei Tonspuren, und beide kommen mit.</b> Der Plan hat gar kein Feld
|
||||
/// „welche Tonspur" — und das ist der Unterschied zu Jellyfin, dessen
|
||||
/// Transcode-Endpunkt je Sitzung genau eine abbildet. Wer hier eine
|
||||
/// auswählen wollte, fände keine Stelle dafür.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public void Alle_Tonspuren_bleiben_erhalten()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv",
|
||||
[Bild(), Ton(1, name: "Deutsch"), Ton(2, name: "Audiodeskription"), Ton(3, sprache: "eng")]);
|
||||
|
||||
Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.Remux));
|
||||
Assert.That(plan.AudioToEncode, Is.Empty, "Alle drei passen und werden nur umgepackt");
|
||||
Assert.That(plan.SubtitlesDropped, Is.Empty);
|
||||
}
|
||||
|
||||
/// <summary>DTS kennt AVPlayer nicht — nur diese eine Spur wird gerechnet.</summary>
|
||||
[Test]
|
||||
public void Nur_untaugliche_Tonspuren_werden_neu_gerechnet()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "aac"), Ton(2, "dts"), Ton(3, "truehd")]);
|
||||
|
||||
Assert.That(plan.AudioToEncode, Is.EqualTo(new[] { 2, 3 }));
|
||||
Assert.That(plan.Reasons, Does.Contain(DeliveryReason.AudioCodecUnsupported));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Textuntertitel_werden_fuer_MP4_umgeschrieben()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1), Text(2, "subrip")]);
|
||||
|
||||
Assert.That(plan.Reasons, Does.Contain(DeliveryReason.SubtitlesNeedConversion));
|
||||
Assert.That(plan.SubtitlesDropped, Is.Empty);
|
||||
}
|
||||
|
||||
/// <summary>Betrifft fast jeden Blu-ray-Rip.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// PGS liegt als Bild vor, und in eine MP4 passt das nicht. Diese Spuren
|
||||
/// fallen weg — und das muss gesagt werden, statt stillschweigend zu
|
||||
/// geschehen: sonst sucht jemand nach Untertiteln, die der Server bewusst
|
||||
/// weggelassen hat.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public void Bilduntertitel_fallen_weg_und_das_steht_im_Plan()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv",
|
||||
[Bild(), Ton(1), Text(2, "hdmv_pgs_subtitle"), Text(3, "subrip")]);
|
||||
|
||||
Assert.That(plan.SubtitlesDropped, Is.EqualTo(new[] { 2 }));
|
||||
Assert.That(plan.Reasons, Does.Contain(DeliveryReason.ImageSubtitlesDropped));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Ein_untaugliches_Bild_verlangt_ebenfalls_Umpacken()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild("vp9"), Ton(1)]);
|
||||
Assert.That(plan.Reasons, Does.Contain(DeliveryReason.VideoCodecUnsupported));
|
||||
}
|
||||
|
||||
/// <summary>Was die Datei nicht nennt, gilt als passend.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Vorsichtshalber umzupacken hiesse, aus einer tadellosen MP4 eine neue
|
||||
/// Datei zu machen — für eine Angabe, die schlicht fehlt.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public void Fehlende_Angaben_loesen_kein_Umpacken_aus()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload(null,
|
||||
[Bild(null!) with { Codec = null }, Ton(1) with { Codec = null }]);
|
||||
|
||||
Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Jeder_Grund_steht_nur_einmal_da()
|
||||
{
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "dts"), Ton(2, "truehd"), Ton(3, "vorbis")]);
|
||||
|
||||
Assert.That(plan.Reasons.Count(g => g == DeliveryReason.AudioCodecUnsupported), Is.EqualTo(1));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Ein_eigenes_Geraeteprofil_sticht_die_Voreinstellung()
|
||||
{
|
||||
var alleskoenner = new DeviceProfile(
|
||||
new HashSet<string> { "mkv" }, new HashSet<string> { "h264" }, new HashSet<string> { "dts" });
|
||||
|
||||
var plan = DeliveryDecider.ForDownload("mkv", [Bild(), Ton(1, "dts")], alleskoenner);
|
||||
Assert.That(plan.Method, Is.EqualTo(DeliveryMethod.DirectFile));
|
||||
}
|
||||
}
|
||||
@@ -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