Was heruntergeladen wird, muss der Systemplayer öffnen können

**Vorbereitung dafür, dass VLC verschwindet.** Online ist der Fall längst
gelöst: steht nur die Schachtel im Weg, packt der Server um — dieselben
Ströme, eine MP4-Hülle. Offline gibt es diesen Ausweg nicht. Was einmal als
Matroska auf dem Gerät liegt, kann hinterher niemand mehr umpacken, und ohne
zweite Engine bliebe die Datei schwarz.

Also entscheidet sich das beim Herunterladen. Fragt jemand das Original an und
AVFoundation könnte die Datei nicht öffnen, wird `remuxDownloadURL` benutzt:
`/Videos/{id}/stream.mp4` mit `allowVideoStreamCopy` und
`allowAudioStreamCopy`. Der Server reicht durch, was passt, und rechnet nur
um, was nicht passt — das Bild bleibt das Original, nur DTS oder TrueHD
werden zu AC3 oder AAC.

Drei Dinge hängen daran und sind mitgezogen:

- Die **Größe** ist dann keine Zusage mehr: dieselben Ströme in einer anderen
  Hülle wiegen anders. `expectedIsExact` fällt auf falsch, und es gilt wieder
  die weiche Prüfung.
- Der **Container** im Offline-Abzug ist „mp4", nicht die alte Schachtel.
  Sonst entschiede der Player anhand einer Datei, die es so nicht mehr gibt.
- Der **Tonkodierer** bleibt leer. Ob aus DTS dann AAC oder AC3 wird, sagt der
  Server vorher nicht; eine Behauptung wäre schlechter als die Lücke, und die
  Spuren liest der Player ohnehin aus der Datei.

**Die Frage „kann das der Systemplayer?" steht jetzt an einer Stelle.**
`DeviceCapabilities.opens(container:videoCodec:audioCodec:)` — dieselbe Liste,
nach der auch beim Abspielen entschieden wird. Was der Server nicht nennt,
gilt als passend: vorsichtshalber umzupacken hiesse, aus einer tadellosen MP4
eine neu gerechnete Datei zu machen. Fünf Tests.

NOCH NICHT AN EINEM ECHTEN SERVER GEPRÜFT: ob Jellyfin das Kopieren hier
tatsächlich wählt, verrät erst die Dateigröße des ersten Downloads.

140 Tests in FlixyPlayback, iOS und tvOS bauen.

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

Flixy/Session/DownloadService.swift

@@ -1,5 +1,6 @@
 import Foundation
 import FlixyDownloads
+import FlixyPlayback
 import MediaKit
 
 /// Übersetzt Titel vom Server in Download-Aufträge.
@@ -105,8 +106,18 @@ struct DownloadService {
         guard let part = media.files.first else {
             throw .noDownloadableFile(reason: String(localized: "downloads.refused.noPart"))
         }
+        // **Was offline liegt, muss der Systemplayer öffnen können.** Online
+        // springt für eine Matroska das Umpacken ein; auf dem Gerät gibt es
+        // hinterher niemanden mehr, der das nachholen könnte — und seit es
+        // keine zweite Engine mehr gibt, wäre die Datei schlicht stumm und
+        // schwarz. Also wird schon beim Herunterladen umgepackt.
+        let umpacken = quality == .original && !systemPlayerOpens(media: media, part: part)
+
         let url: URL?
         switch quality {
+        case .original where umpacken:
+            url = backend.remuxDownloadURL(itemID: item.id, versionIndex: mediaIndex)
+                ?? backend.downloadURL(for: part)
         case .original:
             url = backend.downloadURL(for: part)
         case .fullHD, .hd, .low:
@@ -143,8 +154,11 @@ struct DownloadService {
             // den Metadaten des Servers. Die umgerechneten Stufen sind aus
             // Bitrate und Dauer hochgerechnet — und was hochgerechnet ist,
             // darf abweichen, ohne dass die Datei kaputt wäre.
-            expectedIsExact: quality == .original && part.size != nil,
-            offlineMedia: offlineMedia(for: item, media: media, part: part)
+            // Umgepackt stimmt die Größe des Servers nicht mehr: dieselben
+            // Ströme in einer anderen Hülle wiegen anders. Dann ist sie wieder
+            // eine Schätzung — und die weiche Prüfung die richtige.
+            expectedIsExact: quality == .original && !umpacken && part.size != nil,
+            offlineMedia: offlineMedia(for: item, media: media, part: part, remuxed: umpacken)
         )
     }
 
@@ -239,11 +253,32 @@ struct DownloadService {
     }
 
     /// Der Abzug der Serverangaben, den der Player offline braucht.
-    private func offlineMedia(for item: MediaItem, media: MediaVersion, part: MediaFile) -> OfflineMedia {
-        OfflineMedia(
+    /// Ob AVFoundation die Datei so, wie sie auf dem Server liegt, öffnet.
+    private func systemPlayerOpens(media: MediaVersion, part: MediaFile) -> Bool {
+        DeviceCapabilities.avFoundation.opens(
             container: part.container ?? media.container,
             videoCodec: media.videoCodec,
-            audioCodec: part.selectedAudioStream?.codec ?? media.audioCodec,
+            audioCodec: part.selectedAudioStream?.codec ?? media.audioCodec
+        )
+    }
+
+    private func offlineMedia(
+        for item: MediaItem,
+        media: MediaVersion,
+        part: MediaFile,
+        remuxed: Bool
+    ) -> OfflineMedia {
+        OfflineMedia(
+            // Umgepackt liegt eine MP4 auf dem Gerät, keine Matroska. Stünde
+            // hier weiter die alte Schachtel, entschiede der Player anhand
+            // einer Datei, die es so nicht mehr gibt.
+            container: remuxed ? "mp4" : (part.container ?? media.container),
+            videoCodec: media.videoCodec,
+            // **Beim Umpacken wissen wir es nicht.** Der Server rechnet nur
+            // um, was nicht durchpasst — ob aus DTS dann AAC oder AC3 wird,
+            // sagt er vorher nicht. Eine Behauptung wäre schlechter als die
+            // Lücke: der Player liest die Spuren ohnehin aus der Datei.
+            audioCodec: remuxed ? nil : (part.selectedAudioStream?.codec ?? media.audioCodec),
             videoResolution: media.videoResolution,
             bitrate: media.bitrate,
             audioLanguages: part.audioStreams.compactMap(\.language),