MediaKit: die Grundschicht, auf der Plex und Jellyfin dasselbe meinen

Erster Schritt zu Jellyfin, und er besteht vor allem aus Wegnehmen.

`PlaybackDecider` nahm bisher Plex-Modelle entgegen und las daraus sechs
Felder. Das band die Entscheidung an einen bestimmten Server, obwohl an
der Frage „kann iOS das öffnen?" nichts serverspezifisch ist. Jetzt nimmt
er ein `MediaProfile` — Container, Codecs, Bitrate, ob die Datei
untersucht ist.

Wie ernst die Kopplung war, zeigte der Player selbst: für die
Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen — eine
Media mit Kennung 0, ein Part mit dem Dateinamen als Schlüssel,
zusammengesetzte Spurlisten —, nur damit die Signatur passte. Für eine
Datei, die längst auf dem Gerät lag und mit Plex nichts mehr zu tun
hatte. Dieser Hack ist weg.

Neu ist das Target `MediaKit`: Typen und Rechnungen, die für jeden Server
gelten, ohne eine einzige Abhängigkeit. Darin `MediaProfile` und die
`Duration`-Brücke, die bisher in PlexKit stand — „weil es die unterste
Schicht ist". Das stimmte, solange es nur einen Server gab.

Damit kennen Wiedergabe und Downloads Plex nicht mehr. Zwei der
Abhängigkeiten waren ohnehin tot; die dritte trug nur diese Brücke.

Die wichtigste Testtabelle des Projekts ist mitgewandert und dabei
kürzer geworden: dort steht jetzt, worauf es ankommt, statt vollständiger
Modelle mit Kennungen und Dateipfaden, von denen niemand etwas las.

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

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift

@@ -1,5 +1,5 @@
 import Foundation
-import PlexKit
+import MediaKit
 
 /// Entscheidet, wie ein Titel abgespielt wird.
 ///
@@ -15,8 +15,7 @@ public struct PlaybackDecider: Sendable {
     }
 
     public func decide(
-        media: PlexMedia,
-        part: PlexPart,
+        profile: MediaProfile,
         policy: PlaybackPolicy
     ) -> PlaybackDecision {
         var rationale: [PlaybackDecision.Rationale] = []
@@ -36,7 +35,7 @@ public struct PlaybackDecider: Sendable {
         // 1. Reicht die Leitung? Das kommt zuerst, weil es unabhängig vom
         //    Format ist: eine 80-Mbit-Datei über Mobilfunk ist auch dann keine
         //    gute Idee, wenn AVPlayer sie problemlos öffnen könnte.
-        if let limit = policy.maximumBitrate, let bitrate = media.bitrate, bitrate > limit {
+        if let limit = policy.maximumBitrate, let bitrate = profile.bitrate, bitrate > limit {
             rationale.append(.bitrateExceedsLimit(mediaBitrate: bitrate, limit: limit))
             if policy.allowsTranscoding {
                 return PlaybackDecision(method: .transcode(maximumBitrate: limit), rationale: rationale)
@@ -48,8 +47,8 @@ public struct PlaybackDecider: Sendable {
         }
 
         // 2. Kennt der Server die Datei überhaupt?
-        let container = normalized(part.container ?? media.container)
-        guard !part.streams.isEmpty, let videoCodec = normalized(media.videoCodec ?? part.videoStream?.codec) else {
+        let container = normalized(profile.container)
+        guard profile.hasKnownStreams, let videoCodec = normalized(profile.videoCodec) else {
             rationale.append(.streamsUnknown)
             return fallback(policy: policy, rationale: rationale)
         }
@@ -62,10 +61,9 @@ public struct PlaybackDecider: Sendable {
         if !capabilities.videoCodecs.contains(videoCodec) {
             blockers.append(.videoCodecUnsupported(videoCodec))
         }
-        // Geprüft wird die Spur, die tatsächlich klingen soll. Eine Datei mit
-        // deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
-        // solange Deutsch gewählt ist.
-        if let audioCodec = normalized(part.selectedAudioStream?.codec ?? media.audioCodec),
+        // Geprüft wird die Spur, die tatsächlich klingen soll — welche das
+        // ist, hat der Aufrufer beim Bauen des Profils entschieden.
+        if let audioCodec = normalized(profile.audioCodec),
            !capabilities.audioCodecs.contains(audioCodec) {
             blockers.append(.audioCodecUnsupported(audioCodec))
         }

Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift

@@ -1,6 +1,6 @@
 import AVFoundation
 import Foundation
-import PlexKit
+import MediaKit
 
 /// Wiedergabe über den Systemplayer.
 ///

Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift

@@ -1,12 +1,11 @@
 import Foundation
-import PlexKit
 
 /// Eine wählbare Ton- oder Untertitelspur.
 ///
-/// Bewusst getrennt von `PlexStream`: VLCKit und AVPlayer nummerieren ihre
-/// Spuren selbst, und die Nummern stimmen nicht mit denen von Plex überein.
-/// `engineIdentifier` hält deshalb fest, wie der jeweilige Engine die Spur
-/// nennt, während `plexStreamID` für den Server gedacht ist.
+/// Bewusst getrennt von den Spuren, die der Server meldet: VLCKit und
+/// AVPlayer nummerieren selbst, und ihre Nummern stimmen mit denen des Servers
+/// nicht überein. `engineIdentifier` hält fest, wie die laufende Engine die
+/// Spur nennt, `serverStreamID`, wie der Server sie nennt.
 public struct MediaTrack: Sendable, Equatable, Identifiable {
     public enum Kind: Sendable, Equatable { case audio, subtitle }
 
@@ -14,7 +13,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
     public let kind: Kind
     public let displayName: String
     public let languageCode: String?
-    public let plexStreamID: Int?
+    public let serverStreamID: Int?
     /// Die Nummer, unter der der laufende Engine die Spur führt.
     public let engineIdentifier: Int?
     public let isForced: Bool
@@ -24,7 +23,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
         kind: Kind,
         displayName: String,
         languageCode: String? = nil,
-        plexStreamID: Int? = nil,
+        serverStreamID: Int? = nil,
         engineIdentifier: Int? = nil,
         isForced: Bool = false
     ) {
@@ -32,40 +31,9 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
         self.kind = kind
         self.displayName = displayName
         self.languageCode = languageCode
-        self.plexStreamID = plexStreamID
+        self.serverStreamID = serverStreamID
         self.engineIdentifier = engineIdentifier
         self.isForced = isForced
     }
 }
 
-extension MediaTrack {
-    /// Baut eine Spur aus dem, was Plex gemeldet hat.
-    ///
-    /// `displayTitle` ist das, was Plex selbst in seinen Oberflächen zeigt
-    /// (etwa „Deutsch (AC3 5.1)"). Fehlt es, wird aus Sprache und Codec etwas
-    /// Brauchbares gebaut, statt „Spur 3" anzuzeigen.
-    public init?(stream: PlexStream) {
-        guard let kind = stream.kind else { return nil }
-        let trackKind: Kind
-        switch kind {
-        case .audio: trackKind = .audio
-        case .subtitle: trackKind = .subtitle
-        case .video: return nil
-        }
-
-        let name = stream.displayTitle
-            ?? stream.title
-            ?? [stream.language, stream.codec?.uppercased()]
-                .compactMap(\.self)
-                .joined(separator: " · ")
-
-        self.init(
-            id: "plex-\(stream.id)",
-            kind: trackKind,
-            displayName: name.isEmpty ? "—" : name,
-            languageCode: stream.languageCode,
-            plexStreamID: stream.id,
-            isForced: stream.isForced
-        )
-    }
-}