Die Tonspur wird aus der Datei gewählt, nicht aus dem Stream

Im Spurenblatt stand eine einzige Zeile: „Unbekannt". Das ist der Name, den
AVFoundation einer namenlosen Spur gibt — und bei einem umgerechneten
Stream liefert der Server genau eine. Der Player hatte nichts zur Auswahl,
weil die Wahl längst gefallen war, bevor er gefragt wurde.

Gewählt wird jetzt aus den Spuren, die **in der Datei** stehen, und zwar
bevor der Stream ausgehandelt wird. Die Nummer geht als `audioStreamIndex`
mit hinaus; wer mitten im Film umstellt, bekommt den Stream neu — ausser
bei unveränderter Wiedergabe, wo der Player ohne Unterbrechung umschaltet.

Die Abwägung selbst macht `AudioTrackChooser`: gemerkte Spur, dann
Wunschsprache, dann Rangliste, dann Standardspur — und Audiodeskription
mit deutlichem Abzug statt Ausschluss, damit eine Sprache, die es nur so
gibt, immer noch besser ist als Stille.

Drei Ebenen in `LanguagePreferences`: Serie, Mediathek, allgemein. Gefragt
wird von unten nach oben. Die Mediathek wird nur nachgeschlagen, wenn
überhaupt jemand eine Sprache je Mediathek gesetzt hat — sonst kostete jede
Wiedergabe eine Anfrage für eine Ebene, die niemand benutzt.

Wer von Hand umstellt, dessen Wahl wird für die Serie gemerkt, ohne
Nachfrage. Der Dialog „für diese Serie merken?" ist genau die Art, die man
nach dem dritten Mal wegklickt. Sichtbar ist es trotzdem: das Spurenblatt
zeigt es und lässt es löschen.

Dazu die Rangliste in den Einstellungen, ziehbar, und der Schalter
„Audiodeskription meiden".

Und die Player-Oberfläche blendet endlich als Ganzes über. Die Kopfzeile
hatte gar keine Überblendung — sie sprang herein, während die Bedienung
darunter verblasste. Jetzt steht die Animation an einer Stelle statt an
sechs, und sie läuft über Deckkraft statt über Einfügen und Entfernen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy/Views/Player/PlayerModel.swift

@@ -42,6 +42,17 @@ final class PlayerModel {
     private(set) var audioTracks: [MediaTrack] = []
     private(set) var subtitleTracks: [MediaTrack] = []
     private(set) var selectedAudioTrack: MediaTrack?
+
+    /// Die Tonspuren, wie sie **in der Datei** stehen.
+    ///
+    /// **Nicht dasselbe wie `audioTracks`.** Die kommen vom laufenden Player,
+    /// und bei einem umgerechneten Stream ist dort genau eine — der Server
+    /// hat sich längst für eine entschieden. Im Player wäre dann nichts mehr
+    /// umzustellen. Gewählt werden muss also aus dem, was die Datei hergibt,
+    /// und die Wahl muss **vor** dem Aushandeln stattfinden.
+    private(set) var audioStreams: [MediaStream] = []
+    /// Welche davon gerade klingt.
+    private(set) var selectedAudioStream: MediaStream?
     private(set) var selectedSubtitleTrack: MediaTrack?
 
     /// Die Marke, in der wir uns gerade befinden — Grundlage für den
@@ -139,6 +150,7 @@ final class PlayerModel {
     private let diagnostics: PlaybackDiagnostics
     private let policy: PlaybackPolicy
     private let settings: PlaybackSettings
+    private let languages: LanguagePreferences
     private let isLocalConnection: Bool
     /// Wie die Verbindung in der Diagnose heißt.
     ///
@@ -161,6 +173,8 @@ final class PlayerModel {
     /// ohne die Metadaten erneut zu holen.
     private var currentMedia: MediaVersion?
     private var currentPart: MediaFile?
+    /// In welcher Mediathek der Titel liegt — einmal nachgeschlagen.
+    private var libraryID: String?
     private var eventTask: Task<Void, Never>?
     private var reportTask: Task<Void, Never>?
     /// Was der Server für diese Wiedergabe angelegt hat.
@@ -334,6 +348,7 @@ final class PlayerModel {
         diagnostics: PlaybackDiagnostics,
         policy: PlaybackPolicy,
         settings: PlaybackSettings,
+        languages: LanguagePreferences,
         isLocalConnection: Bool,
         connectionDescription: String?,
         unavailableMessage: String
@@ -345,6 +360,7 @@ final class PlayerModel {
         self.diagnostics = diagnostics
         self.policy = policy
         self.settings = settings
+        self.languages = languages
         self.isLocalConnection = isLocalConnection
         self.connectionDescription = connectionDescription
         self.unavailableMessage = unavailableMessage
@@ -400,6 +416,7 @@ final class PlayerModel {
 
         currentMedia = media
         currentPart = part
+        await chooseAudioStream(in: part, of: item, backend: backend)
 
         // Die zuletzt gewählte Stufe, falls sie gemerkt werden soll. **Vor**
         // der Entscheidung, nicht danach: hinterher umzustellen hieße, den
@@ -642,7 +659,10 @@ final class PlayerModel {
                 file: part,
                 transcode: transcode,
                 startTime: start,
-                isLocalConnection: isLocalConnection
+                isLocalConnection: isLocalConnection,
+                // Ohne diese Angabe wählt der Server, und bei einem
+                // umgerechneten Stream kommt danach nur noch **eine** Spur an.
+                audioStreamIndex: selectedAudioStream?.index
             ))
             playbackSession = target.sessionID
             playbackVersionID = target.versionID
@@ -1366,19 +1386,110 @@ final class PlayerModel {
         }
     }
 
-    /// Wählt die bevorzugten Sprachen, sofern es sie gibt.
+    /// Wählt die Untertitelspur, sofern eine gewünscht ist.
+    ///
+    /// **Nur noch Untertitel.** Die Tonspur wird nicht mehr hier gewählt,
+    /// sondern in `chooseAudioStream(in:of:backend:)` — also **bevor** der
+    /// Stream ausgehandelt wird. Hier wäre es zu spät: bei einem umgerechneten
+    /// Stream meldet der Player genau eine Tonspur, und die hat der Server
+    /// längst ausgesucht.
     ///
     /// Nur beim ersten Mal: hat jemand während der Wiedergabe umgestellt, darf
     /// eine später gemeldete Spurliste das nicht zurücksetzen.
     private func applyPreferredLanguages() {
-        if selectedAudioTrack == nil, !settings.preferredAudioLanguage.isEmpty,
-           let match = audioTracks.first(where: { $0.matches(language: settings.preferredAudioLanguage) }) {
-            selectAudioTrack(match)
+        guard selectedSubtitleTrack == nil, !languages.subtitleLanguage.isEmpty,
+              let treffer = subtitleTracks.first(where: {
+                  LanguageCode.matches(languages.subtitleLanguage, $0.languageCode)
+              })
+        else { return }
+        selectSubtitleTrack(treffer)
+    }
+
+    // MARK: - Die Tonspur
+
+    /// Entscheidet, welche Tonspur bestellt wird.
+    ///
+    /// **Vor dem Aushandeln**, und das ist der ganze Punkt: rechnet der Server
+    /// um, liefert er genau eine Tonspur aus. Wer erst im Player wählen will,
+    /// hat dann nichts mehr zur Auswahl. Die Entscheidung muss in die Anfrage.
+    ///
+    /// Die Abwägung selbst steht in `AudioTrackChooser` — ein reiner Typ ohne
+    /// Netz und ohne Einstellungen, damit sich der ZDF-Fall wörtlich
+    /// hinschreiben und durchspielen lässt. Hier steht nur, woher der Wunsch
+    /// kommt.
+    private func chooseAudioStream(
+        in part: MediaFile,
+        of item: MediaItem,
+        backend: any MediaBackend
+    ) async {
+        audioStreams = part.audioStreams
+        guard !audioStreams.isEmpty else {
+            selectedAudioStream = nil
+            return
         }
-        if selectedSubtitleTrack == nil, !settings.preferredSubtitleLanguage.isEmpty,
-           let match = subtitleTracks.first(where: { $0.matches(language: settings.preferredSubtitleLanguage) }) {
-            selectSubtitleTrack(match)
+
+        // Die Mediathek nur nachschlagen, wenn überhaupt jemand eine Sprache
+        // je Mediathek gesetzt hat. Sonst kostete jede Wiedergabe eine
+        // Anfrage für eine Ebene, die niemand benutzt.
+        if languages.usesLibraryLevel, libraryID == nil {
+            libraryID = await backend.libraryID(for: item)
         }
+
+        selectedAudioStream = AudioTrackChooser.choose(
+            from: part.streams,
+            wish: languages.wish(seriesID: item.seriesID, libraryID: libraryID)
+        )
+
+        if let gewählt = selectedAudioStream {
+            diagnostics.note("Tonspur \(gewählt.index.map(String.init) ?? "?"): \(gewählt.name)")
+        }
+    }
+
+    /// Stellt auf eine andere Tonspur um.
+    ///
+    /// **Und merkt sie sich für die Serie** — ohne zu fragen. Die Frage „für
+    /// diese Serie merken?" bei jeder Umstellung ist genau die Art Dialog, die
+    /// man nach dem dritten Mal wegklickt. Sichtbar ist es trotzdem: das
+    /// Spurenblatt zeigt es an und lässt es löschen.
+    ///
+    /// Bei Filmen wird nichts gemerkt — ein Film wird einmal gesehen.
+    func selectAudioStream(_ stream: MediaStream) async {
+        guard stream != selectedAudioStream else { return }
+        selectedAudioStream = stream
+
+        if let seriesID = item?.seriesID {
+            languages.remember(stream, forSeries: seriesID)
+        }
+
+        // **Der billige Weg, wenn er offensteht.** Wird die Datei unverändert
+        // gespielt, liegen alle Spuren im Stream, und der Player schaltet
+        // ohne Unterbrechung um. Die Zuordnung geht über die Reihenfolge:
+        // bei unveränderter Wiedergabe reicht AVFoundation die Spuren in der
+        // Reihenfolge der Datei durch. Stimmt die Anzahl nicht überein, ist
+        // die Annahme falsch — dann lieber neu aufbauen als die falsche Spur
+        // schalten.
+        if case .directPlay = decision?.method,
+           audioTracks.count == audioStreams.count,
+           let position = audioStreams.firstIndex(of: stream) {
+            selectAudioTrack(audioTracks[position])
+            return
+        }
+
+        await restart()
+    }
+
+    /// Was für diese Serie gemerkt ist — für die Anzeige im Spurenblatt.
+    var rememberedTrackName: String? {
+        guard let seriesID = item?.seriesID,
+              let signatur = languages.rememberedTrack(forSeries: seriesID)
+        else { return nil }
+        return signatur.title ?? signatur.languageCode
+    }
+
+    /// Vergisst die gemerkte Spur dieser Serie.
+    func forgetRememberedTrack() {
+        guard let seriesID = item?.seriesID else { return }
+        languages.forgetTrack(forSeries: seriesID)
     }
 
     private func playerSubtitle(for item: MediaItem) -> String? {
@@ -1390,18 +1501,6 @@ final class PlayerModel {
     }
 }
 
-extension MediaTrack {
-    /// Ob die Spur zu einem Sprachcode passt.
-    ///
-    /// Verglichen wird nachsichtig: Plex meldet mal `de`, mal `deu`, mal
-    /// `ger`, und AVFoundation liefert manchmal `de-DE`. Ein strenger
-    /// Vergleich fände die Spur in der Hälfte der Fälle nicht.
-    func matches(language code: String) -> Bool {
-        guard let languageCode, !code.isEmpty else { return false }
-        let normalized = languageCode.lowercased().prefix(2)
-        return normalized == code.lowercased().prefix(2)
-    }
-}
 
 
 /// Verbindet Bild-in-Bild mit der App.