Der Player weiß jetzt, wie es ihm geht

Bisher gab es über eine laufende Wiedergabe zwei Zahlen — gemessene
Bitrate und verworfene Bilder —, und die standen nur zur Anzeige da. Die
Frage „trägt die Leitung das gerade" war nicht zu beantworten, weder für
den Nutzer noch für die App.

**Die wichtigste neue Zahl ist `variantCount`.** Sie kommt aus
`AVAsset.variants`, also vom Parser des Players, und beantwortet die
Frage, ob es überhaupt etwas zum Umschalten gibt. Steht dort 1, greift
jedes Nachregeln ins Leere — und genau das ist heute der Fall, weil die
App bei beiden Servern eine Playlist mit einer Stufe bestellt.

Dazu der Pufferstand aus `loadedTimeRanges`: der einzige echte
Frühwarner. Schrumpft er schneller, als die Zeit vergeht, kommt weniger
herein als hinausgeht — zehn bis zwanzig Sekunden, bevor das Bild steht.
Alles andere meldet sich erst danach.

**Verworfene Bilder werden jetzt über alle Protokolleinträge summiert.**
Das Zugriffsprotokoll legt bei jedem Stufenwechsel einen neuen an, dessen
Zähler bei null beginnt; wer nur `last` liest, hält eine Wiedergabe für
makellos, die schon zwanzigmal Bilder verworfen hat.

**Der Wachhund war blind für den häufigsten Fall.** Vierzig Sekunden am
Stück ohne Daten brechen ab — aber er setzte sich bei jedem kurzen
Erholen zurück, und zehn Rückler à dreißig Sekunden lösten ihn nie aus.
`StallLedger` zählt daneben mit, wie viel Zeit im gleitenden Fenster
fürs Warten draufging. Es bricht nichts ab, es stellt nur fest — und ist
ein reiner Typ ohne Uhr und ohne AVFoundation, damit sich eine Folge von
Rücklern als Zahlenreihe hinschreiben und das Urteil prüfen lässt.
Sieben Tests, darunter genau der Fall, an dem der alte Wachhund
vorbeisah.

Gezählt wird nur der Weg vom Spielen ins Warten. Das anfängliche Puffern
ist der Start, kein Rückler; würde es mitgezählt, hätte jede Wiedergabe
eine Vorstrafe.

Und zwei Kommentare sind berichtigt. Sie behaupteten, AVPlayer wechsle
die Bitrate von selbst und das sei „die zugesagte automatische
Qualitätsanpassung". Umschalten kann er nur zwischen Varianten, die in
der Liste stehen.

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

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

@@ -47,8 +47,10 @@ public struct PlaybackDecision: Sendable, Equatable {
     public var engine: PlaybackEngineKind? {
         switch method {
         case .directPlay(let engine): engine
-        // Der Transcoder liefert HLS — das ist genau die Kost, für die
-        // AVPlayer gebaut ist, inklusive automatischem Bitratenwechsel.
+        // Der Transcoder liefert HLS, und damit ist AVPlayer der richtige
+        // Motor. **Nicht** aber, wie hier früher stand, „inklusive
+        // automatischem Bitratenwechsel": den gibt es nur, wenn die Playlist
+        // mehrere Stufen führt, und das muss ausdrücklich bestellt werden.
         case .transcode: .avPlayer
         }
     }

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

@@ -0,0 +1,107 @@
+import Foundation
+
+/// Buch über das Stocken, mit gleitendem Fenster.
+///
+/// **Warum es das gibt.** Der Wachhund im Player kannte nur eine Frage: steht
+/// es seit vierzig Sekunden am Stück? Bei jedem kurzen Erholen setzte er sich
+/// zurück — zehn Rückler à dreißig Sekunden lösten nichts aus, obwohl die
+/// halbe Stunde unbrauchbar war. Genau dieser Fall ist der, über den geklagt
+/// wird: nicht der tote Strom, sondern der, der immer wieder hakt.
+///
+/// **Warum als eigener Typ.** Keine Uhr, kein AVFoundation, kein Netz — die
+/// Zeiten kommen von außen herein. Damit lässt sich eine Folge von Rücklern
+/// als Zahlenreihe hinschreiben und das Urteil prüfen. Eine Regel, die man
+/// nur im laufenden Film beobachten kann, ist keine Regel, sondern ein
+/// Eindruck.
+///
+/// Alle Zeitpunkte sind **seit Beginn dieser Wiedergabe** gemessen, nicht als
+/// Datum. Das macht die Sache gegen Zeitzonen, Sommerzeit und eine Systemuhr,
+/// die sich mitten im Film stellt, gleichgültig.
+public struct StallLedger: Sendable, Equatable {
+    public struct Episode: Sendable, Equatable {
+        /// Wann dieser Rückler vorbei war.
+        public let endedAt: Duration
+        public let length: Duration
+
+        public init(endedAt: Duration, length: Duration) {
+            self.endedAt = endedAt
+            self.length = length
+        }
+    }
+
+    /// Wie weit zurück gezählt wird.
+    ///
+    /// Drei Minuten: lang genug, dass ein Muster erkennbar wird, kurz genug,
+    /// dass eine überstandene Durststrecke nicht noch eine Viertelstunde
+    /// später nachwirkt.
+    public let window: Duration
+
+    private(set) var episodes: [Episode] = []
+
+    public init(window: Duration = .seconds(180)) {
+        self.window = window
+    }
+
+    /// Trägt einen überstandenen Rückler ein.
+    public mutating func record(_ episode: Episode) {
+        episodes.append(episode)
+        prune(at: episode.endedAt)
+    }
+
+    /// Wie viele Rückler im Fenster liegen.
+    public func count(at now: Duration) -> Int {
+        episodes.count { $0.endedAt >= now - window }
+    }
+
+    /// Welcher Anteil des Fensters mit Warten verbracht wurde — 0 bis 1.
+    ///
+    /// Der laufende Rückler zählt mit, sofern er übergeben wird: wer mitten
+    /// im dritten Stocken steht, soll nicht erst nach dessen Ende erfahren,
+    /// dass es zu viel war.
+    public func share(at now: Duration, ongoing: Duration = .zero) -> Double {
+        let horizon = now - window
+        let waited = episodes
+            .filter { $0.endedAt >= horizon }
+            .reduce(Duration.zero) { $0 + $1.length } + ongoing
+
+        // Am Anfang ist das Fenster noch nicht voll. Dann gegen die
+        // tatsächlich vergangene Zeit rechnen, sonst sähe eine Wiedergabe,
+        // die nach zwanzig Sekunden fünf Sekunden hakte, mit 3 % harmlos aus
+        // statt mit 25 %.
+        let elapsed = min(now, window)
+        guard elapsed > .zero else { return 0 }
+        return min(1, waited / elapsed)
+    }
+
+    /// Der längste einzelne Rückler im Fenster.
+    ///
+    /// Ein einzelner langer ist etwas anderes als viele kurze: der eine sagt
+    /// „die Leitung war weg", die vielen sagen „sie trägt es dauerhaft nicht".
+    /// Beide sollen auslösen dürfen, aber nicht über dieselbe Schwelle.
+    public func longest(at now: Duration) -> Duration {
+        episodes
+            .filter { $0.endedAt >= now - window }
+            .map(\.length)
+            .max() ?? .zero
+    }
+
+    /// Wirft heraus, was aus dem Fenster gefallen ist.
+    public mutating func prune(at now: Duration) {
+        let horizon = now - window
+        episodes.removeAll { $0.endedAt < horizon }
+    }
+
+    public mutating func removeAll() {
+        episodes.removeAll()
+    }
+}
+
+private extension Duration {
+    /// Anteil zweier Dauern. `Duration` kann sich nicht selbst teilen.
+    static func / (lhs: Duration, rhs: Duration) -> Double {
+        let left = Double(lhs.components.seconds) + Double(lhs.components.attoseconds) / 1e18
+        let right = Double(rhs.components.seconds) + Double(rhs.components.attoseconds) / 1e18
+        guard right != 0 else { return 0 }
+        return left / right
+    }
+}