Halo heisst ab hier Flaro — die Marke stand im Weg
Der Upload zu App Store Connect scheiterte am Namen. „Halo" ist eine eingetragene Marke von Microsoft; im App Store heisst zwar keine App exakt so, aber reservierte und markenrechtlich belegte Namen tauchen in keiner Suche auf. Der einzige verlässliche Test war die Eingabe dort, und die ging daneben. **Der Name wurde diesmal vorher geprüft.** Zwanzig Kandidaten gegen den deutschen und amerikanischen App Store, auf exakte Treffer und auf ähnliche Namen. „Kavo" wäre dieselbe Wand gewesen — exakt belegt in beiden Stores, in Deutschland von KaVo Dental GmbH. „Flare" ist mit 42 ähnlichen Apps je Store der am dichtesten besetzte Name der ganzen Runde. **Flaro** ist in beiden frei und liest sich als eigenes Wort, nicht als Flare mit Tippfehler. Das bleibt eine Store-Suche und keine Markenrecherche — reservierte Namen ohne veröffentlichte App sieht sie nicht. Aber es ist mehr Prüfung, als beim letzten Mal stattfand. --- 2160 Textvorkommen in 273 Dateien, 49 Pfade. Betroffen ist diesmal auch der Server: `Flaro.Api`, `Flaro.Core`, `Flaro.Data`, `Flaro.Media`, `Flaro.Metadata`, `FlaroContext`, `FlaroPaths`, `flaro.db`, die Variablen `FLARO_DATA`, `FLARO_CACHE`, `FLARO_TRANSCODE`, `FLARO_WRITE_SIDECARS`, und das Image. **Vor dem Ersetzen geprüft**, ob „halo" irgendwo als Teil eines anderen Wortes steckt — und ob es im TMDB-Token vorkommt. Tat es nicht; ein blindes Ersetzen hätte den sonst zerlegt. `docs/superpowers/specs/` bleibt wie beim letzten Mal unangetastet: datierte Entwurfsdokumente sind ein Protokoll getroffener Entscheidungen. Das Server-Dokument hat stattdessen einen Nachtrag bekommen, damit es niemanden in die Irre führt. **Die Bundle-ID wandert mit**, zum zweiten Mal an einem Tag: `com.scarriffleservices.flaro`. Wer die vorige Fassung installiert hat, hat jetzt zwei Karteileichen auf dem Gerät — beide löschen, dann ist Ruhe. 308 Server-Tests grün, 368 im Swift-Paket, null Warnungen. iOS und tvOS bauen, das Image baut, und ein frischer Container läuft durch Einrichtung und Anmeldung. 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
f98b995050
commit
a7cf6c5def
@@ -0,0 +1,150 @@
|
||||
using Flaro.Core.Library;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Flaro.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(), "flaro-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\Flaro.Media\Flaro.Media.csproj" />
|
||||
<ProjectReference Include="..\..\src\Flaro.Core\Flaro.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,121 @@
|
||||
using Flaro.Core.Delivery;
|
||||
using Flaro.Core.Library;
|
||||
|
||||
namespace Flaro.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 Flaro.Core.Delivery;
|
||||
using Flaro.Core.Library;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Flaro.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(), "flaro-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,146 @@
|
||||
using System.Text;
|
||||
using Flaro.Core.Library;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Flaro.Media.Tests;
|
||||
|
||||
/// <summary>Was wirklich auf der Platte landet.</summary>
|
||||
public class SidecarWriterTests
|
||||
{
|
||||
private string _ordner = "";
|
||||
private string _film = "";
|
||||
|
||||
[SetUp]
|
||||
public void Anlegen()
|
||||
{
|
||||
_ordner = Directory.CreateDirectory(Path.Combine(
|
||||
Path.GetTempPath(), "flaro-beiwerk-" + Guid.CreateVersion7().ToString("N"),
|
||||
"Der Untergang (2004)")).FullName;
|
||||
_film = Path.Combine(_ordner, "Der Untergang (2004).mkv");
|
||||
File.WriteAllBytes(_film, new byte[2048]);
|
||||
}
|
||||
|
||||
[TearDown]
|
||||
public void Aufraeumen()
|
||||
{
|
||||
try { Directory.Delete(Path.GetDirectoryName(_ordner)!, recursive: true); } catch (IOException) { }
|
||||
}
|
||||
|
||||
private static SidecarWriter Schreiber(bool an = true) =>
|
||||
new(new SidecarOptions(an), NullLogger<SidecarWriter>.Instance);
|
||||
|
||||
[Test]
|
||||
public async Task Eine_NFO_landet_neben_dem_Film()
|
||||
{
|
||||
await Schreiber().WriteTextAsync(_film, SidecarNames.MovieNfo, "<movie><tmdbid>613</tmdbid></movie>");
|
||||
|
||||
var ziel = Path.Combine(_ordner, "movie.nfo");
|
||||
Assert.That(File.Exists(ziel), Is.True);
|
||||
Assert.That(await File.ReadAllTextAsync(ziel), Does.Contain("613"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Ein_Bild_landet_neben_dem_Film()
|
||||
{
|
||||
using var inhalt = new MemoryStream(Encoding.UTF8.GetBytes("ein plakat"));
|
||||
await Schreiber().WriteStreamAsync(_film, SidecarNames.MoviePoster, inhalt);
|
||||
|
||||
Assert.That(File.Exists(Path.Combine(_ordner, "poster.jpg")), Is.True);
|
||||
}
|
||||
|
||||
/// <summary>Die Prüfung, an der der Schutz des Bestands hängt.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// <b>Es muss laut scheitern, nicht still übergehen.</b> Käme hier ein
|
||||
/// Name durch, der nicht auf der Liste steht, wäre der gesamte Bestand
|
||||
/// offen — und ein stilles Übergehen verstecke den Fehler, bis jemand
|
||||
/// seine Filme vermisst.
|
||||
/// </remarks>
|
||||
[TestCase("film.mkv")]
|
||||
[TestCase("../anderswo.nfo")]
|
||||
[TestCase("/etc/passwd")]
|
||||
[TestCase("unterordner/poster.jpg")]
|
||||
[TestCase("beliebig.txt")]
|
||||
public void Was_nicht_auf_der_Liste_steht_wird_laut_abgelehnt(string versuch)
|
||||
{
|
||||
var fehler = Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Schreiber().WriteTextAsync(_film, versuch, "egal"));
|
||||
|
||||
Assert.That(fehler!.Message, Does.Contain("Liste"));
|
||||
}
|
||||
|
||||
/// <summary>Die Mediendatei bleibt unberührt — auch beim Versuch.</summary>
|
||||
[Test]
|
||||
public void Die_Mediendatei_wird_nie_angefasst()
|
||||
{
|
||||
var vorher = new FileInfo(_film).Length;
|
||||
|
||||
Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Schreiber().WriteTextAsync(_film, "Der Untergang (2004).mkv", "kaputt"));
|
||||
|
||||
Assert.That(new FileInfo(_film).Length, Is.EqualTo(vorher));
|
||||
Assert.That(File.ReadAllBytes(_film).All(b => b == 0), Is.True);
|
||||
}
|
||||
|
||||
/// <summary>Abgeschaltet heisst abgeschaltet.</summary>
|
||||
[Test]
|
||||
public async Task Ohne_Erlaubnis_wird_nichts_geschrieben()
|
||||
{
|
||||
await Schreiber(an: false).WriteTextAsync(_film, SidecarNames.MovieNfo, "<movie/>");
|
||||
|
||||
Assert.That(File.Exists(Path.Combine(_ordner, "movie.nfo")), Is.False);
|
||||
Assert.That(Schreiber(an: false).Enabled, Is.False);
|
||||
}
|
||||
|
||||
/// <summary>Gelesen wird trotzdem.</summary>
|
||||
///
|
||||
/// <remarks>
|
||||
/// Eine vorhandene NFO ist eine Zuordnung, die jemand getroffen hat. Sie
|
||||
/// zu übergehen, bloss weil Flaro selbst nicht schreiben darf, wäre
|
||||
/// verkehrt herum.
|
||||
/// </remarks>
|
||||
[Test]
|
||||
public async Task Gelesen_wird_auch_ohne_Schreiberlaubnis()
|
||||
{
|
||||
await File.WriteAllTextAsync(Path.Combine(_ordner, "movie.nfo"), "<movie><tmdbid>613</tmdbid></movie>");
|
||||
|
||||
var gelesen = await Schreiber(an: false).ReadTextAsync(_film, SidecarNames.MovieNfo);
|
||||
Assert.That(Nfo.ReadIds(gelesen!).Tmdb, Is.EqualTo(613));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Eine_fehlende_Datei_ergibt_null()
|
||||
{
|
||||
Assert.That(await Schreiber().ReadTextAsync(_film, SidecarNames.MovieNfo), Is.Null);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Ein_zweites_Schreiben_ersetzt_das_erste()
|
||||
{
|
||||
await Schreiber().WriteTextAsync(_film, SidecarNames.MovieNfo, "<movie>alt</movie>");
|
||||
await Schreiber().WriteTextAsync(_film, SidecarNames.MovieNfo, "<movie>neu</movie>");
|
||||
|
||||
Assert.That(await File.ReadAllTextAsync(Path.Combine(_ordner, "movie.nfo")), Is.EqualTo("<movie>neu</movie>"));
|
||||
Assert.That(Directory.GetFiles(_ordner, "*.flaro-tmp"), Is.Empty, "Keine Reste vom Umbenennen");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Ein_Film_allein_im_Ordner_wird_erkannt()
|
||||
{
|
||||
Assert.That(Schreiber().IsAloneInFolder(_film), Is.True);
|
||||
|
||||
File.WriteAllBytes(Path.Combine(_ordner, "Noch ein Film (2005).mkv"), new byte[10]);
|
||||
Assert.That(Schreiber().IsAloneInFolder(_film), Is.False);
|
||||
}
|
||||
|
||||
/// <summary>Beiwerk zählt nicht als zweiter Film.</summary>
|
||||
[Test]
|
||||
public async Task Das_eigene_Beiwerk_macht_den_Film_nicht_unselbstaendig()
|
||||
{
|
||||
await Schreiber().WriteTextAsync(_film, SidecarNames.MovieNfo, "<movie/>");
|
||||
using var bild = new MemoryStream([1, 2, 3]);
|
||||
await Schreiber().WriteStreamAsync(_film, SidecarNames.MoviePoster, bild);
|
||||
|
||||
Assert.That(Schreiber().IsAloneInFolder(_film), Is.True);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace Flaro.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 Flaro 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 Flaro.
|
||||
/// </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