Eine Leiter bestellen statt einer einzelnen Stufe

Der Kern des Ruckelproblems: die App bestellte bei beiden Servern eine
HLS-Liste mit genau einer Variante. AVPlayer kann nur zwischen Stufen
wechseln, die in der Liste stehen — bei einer gibt es nichts zu wechseln,
und wenn die Leitung einbricht, kann nichts nachgeben.

**Jellyfin.** `enableAdaptiveBitrateStreaming` wird gesetzt, und zwar
ersetzend: die Voreinstellung im Server ist `false`, und bei zwei
gleichnamigen Werten gilt beim Server der erste — dieselbe Falle wie bei
`maxHeight` eine Funktion weiter oben. Dazu wird `main.m3u8` zu
`master.m3u8`, falls der Server die Schnipselliste nennt; nur auf der
Stufenliste kann der Parameter wirken.

Am Geräteprofil ändert sich **nichts**. Mehrere `TranscodingProfiles`
wären der naheliegende Fehlgriff — die beschreiben Formate, nicht
Bitraten. `MaxStreamingBitrate` bleibt die oberste Sprosse; was darunter
liegt, erfindet der Server.

**Plex.** `autoAdjustQuality=1`, als Eigenschaft der Anfrage statt als
feste Zeile: `queryItems` speist auch die Adresse zum Herunterladen, und
dort ergäbe eine Leiter keinen Sinn. Bewusst **nicht** am Entscheider —
der antwortet auf Unbekanntes mit nackten 400ern, wofür es hier eigens
`transcoderBisect` gibt. Er beantwortet ohnehin nur „darf das gespielt
werden". Stünde der Wert dort und nähme der Server ihn übel, wäre nicht
die Leiter kaputt, sondern die Wiedergabe.

Beides nur bei „automatisch". Wer im Blatt ausdrücklich „720p · 3 Mbps"
antippt, bekommt das und nicht „höchstens 3, meistens weniger" unter
unverändertem Etikett.

**Was das nicht kann, und das gehört dazugesagt:** Jellyfin verweigert
die Leiter im lokalen Netz grundsätzlich — „Within the local network this
will likely do more harm than good." Ein schwaches WLAN zählt dort mit,
und vom Client aus ist das nicht zu überstimmen. Ebenso fällt sie weg,
wenn Bild oder Ton nur kopiert statt gerechnet werden. Ob am Ende
wirklich mehrere Stufen ankommen, steht deshalb nicht im Code, sondern in
`PlaybackStatistics.variantCount`.

Elf neue Tests, darunter der doppelte Parameter, die andere
Schreibweise, und dass die Sitzungskennung beim Umbau dieselbe bleibt —
sonst bliebe beim Aufräumen ein Transcoder stehen.

Die Probe zeigt jetzt außerdem, ob kopiert statt gerechnet wird. Das ist
die zweite Hürde, und sie ist von zuhause aus nicht sichtbar.

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

Packages/FlixyKit/Sources/PlexKit/Endpoints/TranscodeRequest.swift

@@ -31,6 +31,8 @@ public struct TranscodeRequest: Sendable, Equatable {
     /// Programmanbieter. Der Transcoder nimmt beides — aber nur, wenn man
     /// ihm die richtige Adresse nennt.
     public let pathOverride: String?
+    /// Ob Plex die Qualität selbst nachregeln soll.
+    public let adaptive: Bool
 
     public init(
         ratingKey: String,
@@ -42,7 +44,8 @@ public struct TranscodeRequest: Sendable, Equatable {
         sessionIdentifier: String = UUID().uuidString,
         subtitleStreamID: Int? = nil,
         audioStreamID: Int? = nil,
-        pathOverride: String? = nil
+        pathOverride: String? = nil,
+        adaptive: Bool = false
     ) {
         self.ratingKey = ratingKey
         self.mediaIndex = mediaIndex
@@ -54,6 +57,28 @@ public struct TranscodeRequest: Sendable, Equatable {
         self.subtitleStreamID = subtitleStreamID
         self.audioStreamID = audioStreamID
         self.pathOverride = pathOverride
+        self.adaptive = adaptive
+    }
+
+    /// Dieselbe Anfrage, aber mit Leiter.
+    ///
+    /// Dieselbe Sitzungskennung: es ist **eine** Wiedergabe, und der Server
+    /// soll sie nicht für zwei halten — sonst bliebe beim Aufräumen ein
+    /// Transcoder stehen.
+    func askingForLadder() -> TranscodeRequest {
+        TranscodeRequest(
+            ratingKey: ratingKey,
+            mediaIndex: mediaIndex,
+            partIndex: partIndex,
+            maximumBitrate: maximumBitrate,
+            resolution: resolution,
+            isLocal: isLocal,
+            sessionIdentifier: sessionIdentifier,
+            subtitleStreamID: subtitleStreamID,
+            audioStreamID: audioStreamID,
+            pathOverride: pathOverride,
+            adaptive: true
+        )
     }
 
     /// Die Adresse, die umgerechnet werden soll — so, wie sie in die Anfrage
@@ -96,6 +121,20 @@ public struct TranscodeRequest: Sendable, Equatable {
             URLQueryItem(name: "X-Plex-Session-Identifier", value: sessionIdentifier),
         ]
 
+        // **Eine Leiter statt einer Stufe.**
+        //
+        // Plex' Universal Transcoder liefert dann eine Playlist mit mehreren
+        // Varianten; die bestellte Bitrate bleibt die oberste. Ohne diesen
+        // Wert gibt es genau eine, und AVPlayer hat nichts zum Umschalten.
+        //
+        // Als Eigenschaft und nicht als feste Zeile, weil `queryItems` auch
+        // die Adresse zum **Herunterladen** speist — dort ergäbe eine Leiter
+        // keinen Sinn, und mit einer Eigenschaft muss dort nichts
+        // herausgefiltert werden.
+        if adaptive {
+            items.append(URLQueryItem(name: "autoAdjustQuality", value: "1"))
+        }
+
         if let maximumBitrate {
             items.append(URLQueryItem(name: "maxVideoBitrate", value: String(maximumBitrate)))
             // `videoQuality` skaliert mit: ohne sie ignoriert Plex die

Packages/FlixyKit/Sources/PlexKit/PlexBackend.swift

@@ -155,13 +155,22 @@ public struct PlexBackend: MediaBackend {
         // Vorher fragen, ob der Server überhaupt mitspielt. Sagt er hier schon
         // nein, steht der Grund im Klartext da — statt eines schwarzen Bildes
         // nach zwanzig Sekunden Warten.
+        //
+        // **Ohne `autoAdjustQuality`**, und das mit Absicht: der Entscheider
+        // antwortet auf Unbekanntes mit nackten 400ern — dafür gibt es in
+        // diesem Paket eigens `transcoderBisect`. Er beantwortet ohnehin nur
+        // „darf das gespielt werden", und daran ändert eine Leiter nichts.
+        // Stünde der Wert hier und der Server nähme ihn übel, wäre nicht die
+        // Leiter kaputt, sondern die Wiedergabe.
         let decision = try await mapping { try await server.transcodeDecision(for: request) }
         guard decision.isAllowed else {
             throw .refused(reason: decision.explanation ?? "")
         }
 
-        guard let url = server.transcodeURL(for: request) else { throw .notFound }
-        return PlaybackTarget(url: url, sessionID: request.sessionIdentifier)
+        // Erst für die Adresse, die wirklich gespielt wird.
+        let start = transcode.prefersAdaptive ? request.askingForLadder() : request
+        guard let url = server.transcodeURL(for: start) else { throw .notFound }
+        return PlaybackTarget(url: url, sessionID: start.sessionIdentifier)
     }
 
     public func endPlayback(sessionID: String) async {