Ein Sprung in den Vorrat laeuft jetzt sofort weiter

Drei Gruende, und der erste erklaert das ganze Aergernis.

AVPlayer besteht nach einem Sprung darauf, erst seinen eigenen Puffer zu
fuellen. Der stand auf sechzig Sekunden — richtig, solange er selbst
vorladen sollte. Mit einem Speicher davor ist es das Gegenteil: springt man
mitten in den Vorrat, liegt dahinter vielleicht noch eine halbe Minute, zu
wenig fuer seine sechzig, und er wartet auf den Server, obwohl alles da
ist. Der Abstand liegt jetzt bei uns; seiner darf klein sein.

Der Vorrat holte ausserdem weiter Schnipsel hinter der Abspielstelle, wenn
der Player vorausgesprungen war — und der eine, auf den gerade gewartet
wurde, kam als letzter. Er macht jetzt dort weiter, wo gesprungen wurde.

Und dieselbe Liste noch einmal zu holen setzte den Vorrat zurueck. Der
Player holt sie staendig: nach einem Sprung, beim Stufenwechsel, von sich
aus. Zurueckgesetzt wird nur noch bei einem echten Wechsel der Quelle.

Dazu ein latenter Fehler, der beim Umpacken ein Schwarzbild gegeben haette:
in EXT-X-MAP steckt die Adresse des Kopfstuecks einer fragmentierten MP4,
ohne das kein einziger Schnipsel zu dekodieren ist. Sie blieb stehen und
zeigte damit relativ auf den lokalen Server. Der alte Test hielt genau
dieses Verhalten fest — er hat mitgeaendert.

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

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

@@ -72,7 +72,18 @@ public struct MediaPlaylist: Sendable, Equatable {
 
         for zeile in lines {
             let getrimmt = zeile.trimmingCharacters(in: .whitespaces)
-            if getrimmt.isEmpty || getrimmt.hasPrefix("#") {
+            if getrimmt.isEmpty {
+                ergebnis.append(zeile)
+            } else if getrimmt.hasPrefix("#EXT-X-MAP:") {
+                // **Die eine Anweisung, in der eine Adresse steckt.**
+                //
+                // Sie zeigt auf das Kopfstück einer fragmentierten MP4 — ohne
+                // das ist kein einziger Schnipsel zu dekodieren. Bliebe sie
+                // stehen, zeigte sie relativ auf den lokalen Server, und dort
+                // gibt es sie nicht: schwarzes Bild, ohne dass an den
+                // Schnipseln irgendetwas falsch wäre.
+                ergebnis.append(Self.rewritingMapURI(zeile, transform))
+            } else if getrimmt.hasPrefix("#") {
                 ergebnis.append(zeile)
             } else {
                 ergebnis.append(transform(getrimmt))
@@ -81,6 +92,24 @@ public struct MediaPlaylist: Sendable, Equatable {
         return ergebnis.joined(separator: "\n")
     }
 
+    /// Tauscht die Adresse in `#EXT-X-MAP:URI="…"` aus, sonst nichts.
+    private static func rewritingMapURI(
+        _ zeile: String,
+        _ transform: (String) -> String
+    ) -> String {
+        let marke = "URI=\""
+        guard let start = zeile.range(of: marke),
+              let ende = zeile[start.upperBound...].firstIndex(of: "\"")
+        else { return zeile }
+        let ende2 = ende..<zeile.index(after: ende)
+
+        let adresse = String(zeile[start.upperBound..<ende2.lowerBound])
+        return zeile.replacingCharacters(
+            in: start.upperBound..<ende2.lowerBound,
+            with: transform(adresse)
+        )
+    }
+
     /// Ob die Liste vollständig ist — dann kommen keine Schnipsel mehr dazu.
     ///
     /// Bei einem laufenden Sender fehlt diese Marke, und die Liste muss

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

@@ -113,11 +113,19 @@ public actor StreamCache {
 
     /// Übernimmt eine Liste von Schnipseln als die, der wir vorauslaufen.
     private func adopt(_ liste: MediaPlaylist, from url: URL) -> String {
+        // **Nur bei einem echten Wechsel von vorn.** Der Player holt dieselbe
+        // Liste immer wieder — nach einem Sprung, beim Stufenwechsel, von
+        // sich aus. Jedes Mal zurückzusetzen hiesse, den Vorrat jedes Mal zu
+        // vergessen und von Schnipsel null neu zu zählen.
+        let neueQuelle = upstream != url
         upstream = url
         segments = liste.segments
         if let dauer = liste.targetDuration { targetDuration = dauer }
-        lastRequested = 0
-        fetched = 0
+
+        if neueQuelle {
+            lastRequested = 0
+            fetched = 0
+        }
         beginPrefetching()
         return liste.rewritingReferences { LocalStreamServer.localPath(for: $0) }
     }
@@ -162,6 +170,13 @@ 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 {
+        // **Ist der Player vorausgesprungen, dort weitermachen.**
+        //
+        // Sonst holt der Vorrat brav weiter Schnipsel hinter der
+        // Abspielstelle — und der eine, auf den gerade gewartet wird, kommt
+        // als letzter. Das ist genau der Fall, in dem es nach einem Sprung
+        // lange lädt, obwohl vorn alles bereitliegt.
+        if lastRequested > fetched { fetched = lastRequested }
         guard fetched < segments.count else { return false }
 
         // Der Vorsprung in Schnipseln, aus dem Vorsprung in Sekunden.