Improve resolution switching

Model/AudioVideoStream.swift

@@ -0,0 +1,16 @@
+import AVFoundation
+import Foundation
+
+final class AudioVideoStream: Stream {
+    var avAsset: AVURLAsset
+
+    init(avAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
+        self.avAsset = avAsset
+
+        super.init(audioAsset: avAsset, videoAsset: avAsset, resolution: resolution, type: type, encoding: encoding)
+    }
+
+    override var assets: [AVURLAsset] {
+        [videoAsset]
+    }
+}

Model/MuxedStream.swift

@@ -1,12 +0,0 @@
-import AVFoundation
-import Foundation
-
-final class MuxedStream: Stream {
-    var muxedAsset: AVURLAsset
-
-    init(muxedAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
-        self.muxedAsset = muxedAsset
-
-        super.init(audioAsset: muxedAsset, videoAsset: muxedAsset, resolution: resolution, type: type, encoding: encoding)
-    }
-}

Model/PlayerState.swift

@@ -1,7 +1,52 @@
 import AVFoundation
 import Foundation
+import Logging
 
 final class PlayerState: ObservableObject {
-    @Published var currentStream: Stream!
+    let logger = Logger(label: "net.arekf.Pearvidious.ps")
+
+    @Published private(set) var currentStream: Stream!
+    @Published var streamToLoad: Stream!
+
     @Published var seekTo: CMTime?
+
+    @Published var streamLoading = false
+
+    func cancelLoadingStream(_ stream: Stream) {
+        guard streamToLoad == stream else {
+            return
+        }
+
+        streamToLoad = nil
+        streamLoading = false
+
+        logger.info("cancel streamToLoad: \(streamToLoad?.description ?? "nil"), streamLoading \(streamLoading)")
+    }
+
+    func loadStream(_ stream: Stream?) {
+        guard streamToLoad != stream else {
+            return
+        }
+
+        streamToLoad?.cancelLoadingAssets()
+
+        streamLoading = true
+        streamToLoad = stream
+
+        logger.info("replace streamToLoad: \(streamToLoad?.description ?? "nil"), streamLoading \(streamLoading)")
+    }
+
+    func streamDidLoad(_ stream: Stream?) {
+        logger.info("didload stream: \(stream!.description)")
+        logger.info("before: toLoad: \(streamToLoad?.description ?? "nil"), current \(currentStream?.description ?? "nil"), loading \(streamLoading)")
+
+        currentStream = stream
+        streamLoading = streamToLoad != stream
+
+        if streamToLoad == stream {
+            streamToLoad = nil
+        }
+
+        logger.info("after: toLoad: \(streamToLoad?.description ?? "nil"), current \(currentStream?.description ?? "nil"), loading \(streamLoading)")
+    }
 }

Model/Stream.swift

@@ -23,6 +23,20 @@ class Stream: Equatable {
         "\(resolution.height)p"
     }
 
+    var assets: [AVURLAsset] {
+        [audioAsset, videoAsset]
+    }
+
+    var assetsLoaded: Bool {
+        assets.allSatisfy { $0.statusOfValue(forKey: "playable", error: nil) == .loaded }
+    }
+
+    func cancelLoadingAssets() {
+        assets.forEach { $0.cancelLoading() }
+        audioAsset = AVURLAsset(url: audioAsset.url)
+        videoAsset = AVURLAsset(url: videoAsset.url)
+    }
+
     static func == (lhs: Stream, rhs: Stream) -> Bool {
         lhs.resolution == rhs.resolution && lhs.type == rhs.type
     }

Model/Video.swift

@@ -95,6 +95,10 @@ final class Video: Identifiable, ObservableObject {
         selectableStreams.first { $0.type == .stream }
     }
 
+    var bestStream: Stream? {
+        selectableStreams.min { $0.resolution > $1.resolution }
+    }
+
     private func extractThumbnailURL(from details: JSON) -> URL? {
         if details["videoThumbnails"].arrayValue.isEmpty {
             return nil
@@ -106,8 +110,8 @@ final class Video: Identifiable, ObservableObject {
 
     private func extractFormatStreams(from streams: [JSON]) -> [Stream] {
         streams.map {
-            MuxedStream(
-                muxedAsset: AVURLAsset(url: DataProvider.proxyURLForAsset($0["url"].stringValue)!),
+            AudioVideoStream(
+                avAsset: AVURLAsset(url: DataProvider.proxyURLForAsset($0["url"].stringValue)!),
                 resolution: StreamResolution.from(resolution: $0["resolution"].stringValue)!,
                 type: .stream,
                 encoding: $0["encoding"].stringValue