Player: eine gewählte Stufe wurde gar nicht umgerechnet

Der Decider rechnet nur um, wenn die Datei die Grenze überschreitet. Für
den Normalfall ist das richtig — für eine ausdrückliche Wahl im Player
nicht: wer für eine 8-Mbit-Datei „12 Mbit" wählt, bekam DirectPlay, weil
die Datei ja darunter liegt. Gemeint ist aber „rechne es mir auf diese
Stufe um", nicht „gib mir die Datei, falls sie so vorliegt".

Die Richtlinie kann eine Umrechnung jetzt erzwingen, und die Wahl im
Player tut das.

Dazu verschluckte `select(quality:)` den eigentlichen Grund: lehnte der
Server ab und sagte im Klartext warum, wurde diese Meldung danach durch
das allgemeine „keine abspielbare Datei" ersetzt — der eine brauchbare
Hinweis war damit weg. Jetzt bleibt stehen, was der Server gesagt hat.

Und das Menü war zu viel. Vorn steht die kurze Liste — automatisch,
Original, je eine brauchbare Stufe pro Auflösung, nur Ton. Wer eine
bestimmte Bitrate erzwingen muss, klappt „Alle Stufen" auf; im Alltag
will man „eine Stufe kleiner" und nicht die Wahl zwischen zehn und zwölf
Megabit.

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

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

@@ -21,6 +21,18 @@ public struct PlaybackDecider: Sendable {
     ) -> PlaybackDecision {
         var rationale: [PlaybackDecision.Rationale] = []
 
+        // 0. Hat jemand ausdrücklich eine Stufe gewählt, wird umgerechnet —
+        //    auch wenn die Datei die Grenze gar nicht überschreitet. Sonst
+        //    bliebe die Wahl folgenlos: für eine 8-Mbit-Datei „12 Mbit" zu
+        //    wählen ergäbe DirectPlay, und am Bild änderte sich nichts.
+        if policy.forcesTranscoding, policy.allowsTranscoding {
+            rationale.append(.qualityChosen)
+            return PlaybackDecision(
+                method: .transcode(maximumBitrate: policy.maximumBitrate),
+                rationale: rationale
+            )
+        }
+
         // 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.

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

@@ -32,6 +32,8 @@ public struct PlaybackDecision: Sendable, Equatable {
         case bitrateExceedsLimit(mediaBitrate: Int, limit: Int)
         /// Transcoding wäre passender, ist aber (noch) nicht verfügbar.
         case transcodingUnavailable
+        /// Im Player ausdrücklich eine Stufe gewählt.
+        case qualityChosen
     }
 
     public let method: Method

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

@@ -14,15 +14,24 @@ public struct PlaybackPolicy: Sendable, Equatable {
     /// Obergrenze in Kilobit pro Sekunde. `nil` heißt unbegrenzt — der
     /// Normalfall im heimischen WLAN.
     public var maximumBitrate: Int?
+    /// Umrechnen, auch wenn die Datei die Grenze gar nicht überschreitet.
+    ///
+    /// Für die Wahl im Player. Ohne das verpuffte sie: wer für eine
+    /// 8-Mbit-Datei „12 Mbit" wählt, bekam DirectPlay, weil die Datei ja
+    /// unter der Grenze liegt — die Wahl blieb folgenlos. Gemeint ist aber
+    /// „rechne es mir auf diese Stufe um".
+    public var forcesTranscoding: Bool
 
     public init(
         allowsTranscoding: Bool,
         allowsFallbackEngine: Bool = true,
-        maximumBitrate: Int? = nil
+        maximumBitrate: Int? = nil,
+        forcesTranscoding: Bool = false
     ) {
         self.allowsTranscoding = allowsTranscoding
         self.allowsFallbackEngine = allowsFallbackEngine
         self.maximumBitrate = maximumBitrate
+        self.forcesTranscoding = forcesTranscoding
     }
 
     /// Phase 1: alles direkt, nichts umrechnen.

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

@@ -134,11 +134,31 @@ public enum PlayerQuality: Hashable, Sendable, Identifiable {
             PlaybackPolicy(
                 allowsTranscoding: true,
                 allowsFallbackEngine: false,
-                maximumBitrate: maximumBitrate
+                maximumBitrate: maximumBitrate,
+                forcesTranscoding: true
             )
         }
     }
 
+    /// Die kurze Liste: je Auflösung eine Stufe, und zwar eine brauchbare.
+    ///
+    /// Dreizehn Sprossen sind für den Normalfall zu viel — man will „geht
+    /// gerade nicht flüssig, nimm eine Stufe kleiner", nicht die Wahl
+    /// zwischen zehn und zwölf Megabit. Die vollständige Leiter bleibt
+    /// erreichbar, steht aber nicht im Weg.
+    public static let everyday: [Rung] = [
+        Rung(bitrate: 8_000, height: 1080),
+        Rung(bitrate: 3_000, height: 720),
+        Rung(bitrate: 720, height: 480),
+    ]
+
+    /// Die kurze Auswahl für eine Quelle dieser Höhe.
+    public static func everyday(forSourceHeight height: Int?) -> [PlayerQuality] {
+        let rungs = everyday.filter { height == nil || $0.height <= (height ?? 0) }
+        let usable = rungs.isEmpty ? Array(everyday.suffix(1)) : rungs
+        return [.automatic, .original] + usable.map(PlayerQuality.limited) + [.audioOnly]
+    }
+
     /// Nur die Stufen, die für eine Quelle dieser Höhe sinnvoll sind.
     ///
     /// Eine 720p-Datei auf 1080p „hochzurechnen" bringt kein Bild dazu, und