Zwei Tonspuren sind eine Wahl, kein Chor

„Auf der App höre ich einfach alle Audiospuren gleichzeitig." MP4 ordnet Spuren derselben Art einer `alternate_group` zu, und ein Abspieler nimmt daraus genau eine. ffmpeg leitet diese Gruppe aus der Markierung der Quelle ab — sind dort zwei Tonspuren als Vorgabe markiert, hält es sie für Verschiedenes und legt sie in getrennte Gruppen. Dann ist jede für sich eingeschaltet, und man hört beide übereinander. Bei Rips aus freier Wildbahn ist die doppelte Markierung eher Regel als Ausnahme; in Matroska stört sie niemanden, in MP4 ist sie der Unterschied zwischen Wahl und Chor. Gemessen an einer Quelle mit zwei markierten Tonspuren, am Spurkopf der fertigen MP4: vorher Spur 2: an, Gruppe 1 Spur 3: an, Gruppe 2 <- beide laufen nachher Spur 2: an, Gruppe 1 Spur 3: aus, Gruppe 1 <- eine zur Wahl Das Umpacken schreibt jetzt genau eine Vorgabe je Spurart: die, die es in der Quelle schon war, sonst die erste. Auch die Nullen gehören hingeschrieben — ffmpeg übernähme sonst die Markierung der Quelle für alle übrigen, und genau die ist ja das Problem. „Erzwungen" wird dabei ausdrücklich erhalten, weil `-disposition` die ganze Markierung ersetzt statt sie zu ergänzen. Untertitel bekommen dieselbe Behandlung. War in der Quelle keiner vorgesehen, bleibt es dabei — sonst erschienen auf einmal zwei übereinander. Der Name im Zwischenspeicher trägt jetzt die Bauart mit. Ohne das bliebe auf einem NAS, das schon umgepackt hat, die fehlerhafte Datei liegen und würde weiter ausgeliefert, obwohl der Server es längst besser kann. Geprüft an der echten Datei, am `tkhd` und nicht an der Disposition: was ein Abspieler tut, hängt an „enabled" und `alternate_group`, und ffprobe zeigt davon nur einen Teil. Ohne die Korrektur fällt die Prüfung um (Gruppe 1 gegen 2). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 06:32:25 +02:00
parent 1531163bc1
commit 40f41f0cee
5 changed files with 273 additions and 1 deletions
@@ -1,3 +1,5 @@
+using System.Buffers.Binary;
+using System.Text;
 using Flaro.Core.Delivery;
 using Flaro.Core.Library;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -185,4 +187,95 @@ public class RemuxTests

        Assert.That(File.Exists(ziel), Is.False);
    }
+
+    /// <summary>Zwei Tonspuren stehen zur Wahl — sie laufen nicht gleichzeitig.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>Der gemeldete Fehler, in einer Datei festgehalten.</b> „Auf der App
+    /// höre ich einfach alle Audiospuren gleichzeitig." So entsteht das: MP4
+    /// ordnet Spuren derselben Art einer <c>alternate_group</c> zu, und ein
+    /// Abspieler nimmt daraus genau eine. ffmpeg leitet die Gruppe aus der
+    /// Markierung der Quelle ab — sind dort zwei Tonspuren als Vorgabe
+    /// markiert, hält es sie für Verschiedenes und legt sie in getrennte
+    /// Gruppen. Dann laufen beide.
+    /// </para>
+    /// <para>
+    /// <b>Geprüft wird am Spurkopf, nicht an der Disposition.</b> Was ein
+    /// Abspieler tut, hängt an <c>alternate_group</c> und am Schalter
+    /// „enabled" im <c>tkhd</c>; ffprobe zeigt davon nur einen Teil. Die
+    /// zwanzig Zeilen Leser unten sind der Preis dafür, dass diese Prüfung
+    /// dasselbe liest wie das iPad.
+    /// </para>
+    /// </remarks>
+    [Test]
+    public async Task Zwei_Tonspuren_stehen_zur_Wahl_statt_zugleich_zu_laufen()
+    {
+        var quelle = Path.Combine(_ordner, "zweivorgaben.mkv");
+        Testdateien.MitZweiVorgabetonspuren(quelle);
+
+        var (ergebnis, _) = await Umpacken(quelle);
+        Assert.That(ergebnis.Success, Is.True, ergebnis.Error);
+
+        var koepfe = Spurkoepfe(Path.Combine(_ordner, "zweivorgaben.mp4"));
+        var ton = koepfe.Skip(1).ToList();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(ton, Has.Count.EqualTo(2));
+            Assert.That(ton[0].Gruppe, Is.EqualTo(ton[1].Gruppe),
+                "beide Tonspuren müssen in derselben Alternativgruppe stehen, sonst sind sie keine Alternativen");
+            Assert.That(ton.Count(t => t.Eingeschaltet), Is.EqualTo(1),
+                "genau eine läuft; sind es zwei, hört man beide übereinander");
+        });
+    }
+
+    /// <summary>Ein Spurkopf, so weit ein Abspieler ihn liest.</summary>
+    private readonly record struct Spurkopf(bool Eingeschaltet, int Gruppe);
+
+    /// <summary>Liest die <c>tkhd</c>-Kästen einer MP4 der Reihe nach.</summary>
+    ///
+    /// <remarks>
+    /// Nur so weit, wie diese Prüfung es braucht: Kästen haben eine Länge
+    /// und einen Namen, <c>moov</c> und <c>trak</c> enthalten weitere.
+    /// </remarks>
+    private static List<Spurkopf> Spurkoepfe(string datei)
+    {
+        var daten = File.ReadAllBytes(datei);
+        var koepfe = new List<Spurkopf>();
+        Durchgehen(daten, 0, daten.Length);
+        return koepfe;
+
+        void Durchgehen(byte[] d, int von, int bis)
+        {
+            var p = von;
+            while (p + 8 <= bis)
+            {
+                var groesse = (long)BinaryPrimitives.ReadUInt32BigEndian(d.AsSpan(p, 4));
+                var art = Encoding.ASCII.GetString(d, p + 4, 4);
+                var kopf = 8;
+
+                if (groesse == 1)
+                {
+                    groesse = (long)BinaryPrimitives.ReadUInt64BigEndian(d.AsSpan(p + 8, 8));
+                    kopf = 16;
+                }
+
+                if (groesse < kopf || p + groesse > bis) return;
+
+                if (art is "moov" or "trak") Durchgehen(d, p + kopf, (int)(p + groesse));
+                if (art == "tkhd")
+                {
+                    var fassung = d[p + kopf];
+                    var schalter = (d[p + kopf + 1] << 16) | (d[p + kopf + 2] << 8) | d[p + kopf + 3];
+                    // Nach den Schaltern: Zeiten und Kennung, dann Ebene und Gruppe.
+                    var stelle = p + kopf + 4 + (fassung == 0 ? 28 : 40);
+                    var gruppe = BinaryPrimitives.ReadInt16BigEndian(d.AsSpan(stelle + 2, 2));
+                    koepfe.Add(new Spurkopf((schalter & 1) != 0, gruppe));
+                }
+
+                p += (int)groesse;
+            }
+        }
+    }
 }