Der Vorrat gibt dem Player Vorrang und weicht, wenn er im Weg steht

Sobald das Umrechnen teuer wird — und das Einbrennen eines Untertitels ist
teuer —, bedient Jellyfin einen Schnipsel nach dem anderen. Der Vorrat hat
dabei gleichzeitig weitergeholt und dem Player die Leitung weggenommen:
zwei Anfragen machen die dringende langsamer, nicht schneller. Herauskam
„Es kommen keine Daten mehr\".

Jetzt ruht der Vorrat, solange eine Anfrage des Players offen ist.

Dazu ein Rueckzugsweg, der gefehlt hat. Der Speicher steht zwischen Player
und Server, und was dort schiefgeht, sieht von aussen aus wie eine tote
Leitung. Kommt nach zwoelf Sekunden nichts an, wird er weggenommen und es
laeuft ohne ihn noch einmal an — das kostet nur den Vorsprung und
unterscheidet die beiden Faelle, statt sie zu verwechseln. Erst danach die
kleinere Bitrate, erst danach das Aufgeben.

Und drei Zeilen ins Protokoll, die drei Runden Ratens erspart haetten: was
bestellt wurde, was der Player daraus meldet, und welche Spur eingeschaltet
wurde. „Nicht geliefert\" und „geliefert und nicht angezeigt\" sehen von
aussen gleich aus — im Protokoll nicht mehr.

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

Packages/FlixyKit/Sources/FlixyPlayback/Prefetch/StreamCache.swift

@@ -56,6 +56,8 @@ public actor StreamCache {
     private var fetched = 0
 
     private var prefetchTask: Task<Void, Never>?
+    /// Ob gerade eine Anfrage des Players offen ist.
+    private var isServingPlayer = false
 
     public init(policy: Policy = Policy()) {
         self.policy = policy
@@ -152,6 +154,15 @@ public actor StreamCache {
         }
 
         if let ort = stored[address], let daten = try? Data(contentsOf: ort) { return daten }
+
+        // **Der Player hat Vorrang.** Fehlt ihm etwas, wartet er darauf — und
+        // der Vorrat darf ihm dabei nicht die Leitung wegnehmen. Rechnet der
+        // Server gerade um, bedient er ohnehin einen Schnipsel nach dem
+        // anderen: zwei Anfragen gleichzeitig machen die dringende langsamer,
+        // nicht schneller. Genau so kam es zu „Stream abgerissen", sobald das
+        // Umrechnen teuer wurde.
+        isServingPlayer = true
+        defer { isServingPlayer = false }
         return await fetch(address)
     }
 
@@ -173,6 +184,9 @@ public actor StreamCache {
     /// Gibt `false` zurück, wenn gerade nichts zu tun ist — dann wartet die
     /// Schleife, statt zu drehen.
     private func prefetchNext() async -> Bool {
+        // Solange der Player wartet, wird nicht vorgeladen.
+        guard !isServingPlayer else { return false }
+
         // **Ist der Player vorausgesprungen, dort weitermachen.**
         //
         // Sonst holt der Vorrat brav weiter Schnipsel hinter der