rework quality settings

- The order of the formats can now be changed in the Quality Settings.
- sortingOrder is now part of QualitiyProfile.
- bestPlayable is now part of PlayerBackend.
- hls and stream aren't treated as unknown anymore.

Model/Player/Backends/AVPlayerBackend.swift

@@ -116,16 +116,6 @@ final class AVPlayerBackend: PlayerBackend {
         #endif
     }
 
-    func bestPlayable(_ streams: [Stream], maxResolution: ResolutionSetting) -> Stream? {
-        let sortedByResolution = streams
-            .filter { ($0.kind == .adaptive || $0.kind == .stream) && $0.resolution <= maxResolution.value }
-            .sorted { $0.resolution > $1.resolution }
-
-        return streams.first { $0.kind == .hls } ??
-            sortedByResolution.first { $0.kind == .stream } ??
-            sortedByResolution.first
-    }
-
     func canPlay(_ stream: Stream) -> Bool {
         stream.kind == .hls || stream.kind == .stream || (stream.kind == .adaptive && stream.format == .mp4)
     }

Model/Player/Backends/MPVBackend.swift

@@ -201,29 +201,6 @@ final class MPVBackend: PlayerBackend {
 
     typealias AreInIncreasingOrder = (Stream, Stream) -> Bool
 
-    func bestPlayable(_ streams: [Stream], maxResolution: ResolutionSetting) -> Stream? {
-        streams
-            .filter { $0.kind != .hls && $0.resolution <= maxResolution.value }
-            .max { lhs, rhs in
-                let predicates: [AreInIncreasingOrder] = [
-                    { $0.resolution < $1.resolution },
-                    { $0.format > $1.format }
-                ]
-
-                for predicate in predicates {
-                    if !predicate(lhs, rhs), !predicate(rhs, lhs) {
-                        continue
-                    }
-
-                    return predicate(lhs, rhs)
-                }
-
-                return false
-            } ??
-            streams.first { $0.kind == .hls } ??
-            streams.first
-    }
-
     func canPlay(_ stream: Stream) -> Bool {
         stream.resolution != .unknown && stream.format != .av1
     }

Model/Player/Backends/PlayerBackend.swift

@@ -29,7 +29,6 @@ protocol PlayerBackend {
     var videoWidth: Double? { get }
     var videoHeight: Double? { get }
 
-    func bestPlayable(_ streams: [Stream], maxResolution: ResolutionSetting) -> Stream?
     func canPlay(_ stream: Stream) -> Bool
     func canPlayAtRate(_ rate: Double) -> Bool
 
@@ -131,6 +130,38 @@ extension PlayerBackend {
         }
     }
 
+    func bestPlayable(_ streams: [Stream], maxResolution: ResolutionSetting, formatOrder: [QualityProfile.Format]) -> Stream? {
+        return streams.map { stream in
+            if stream.kind == .hls {
+                stream.resolution = maxResolution.value
+                stream.format = .hls
+            } else if stream.kind == .stream {
+                stream.format = .stream
+            }
+            return stream
+        }
+        .filter { stream in
+            stream.resolution <= maxResolution.value
+        }
+        .max { lhs, rhs in
+            if lhs.resolution == rhs.resolution {
+                guard let lhsFormat = QualityProfile.Format(rawValue: lhs.format.rawValue),
+                      let rhsFormat = QualityProfile.Format(rawValue: rhs.format.rawValue)
+                else {
+                    print("Failed to extract lhsFormat or rhsFormat")
+                    return false
+                }
+
+                let lhsFormatIndex = formatOrder.firstIndex(of: lhsFormat) ?? Int.max
+                let rhsFormatIndex = formatOrder.firstIndex(of: rhsFormat) ?? Int.max
+
+                return lhsFormatIndex > rhsFormatIndex
+            }
+
+            return lhs.resolution < rhs.resolution
+        }
+    }
+
     func updateControls(completionHandler: (() -> Void)? = nil) {
         print("updating controls")
 

Model/Player/PlayerModel.swift

@@ -673,7 +673,7 @@ final class PlayerModel: ObservableObject {
         }
 
         guard let video = currentVideo else { return }
-        guard let stream = avPlayerBackend.bestPlayable(availableStreams, maxResolution: .hd720p30) else { return }
+        guard let stream = backend.bestPlayable(availableStreams, maxResolution: .hd720p30, formatOrder: qualityProfile!.formats) else { return }
 
         exitFullScreen()
 

Model/Player/PlayerQueue.swift

@@ -127,12 +127,12 @@ extension PlayerModel {
 
         if let streamPreferredForProfile = backend.bestPlayable(
             availableStreams.filter { backend.canPlay($0) && profile.isPreferred($0) },
-            maxResolution: profile.resolution
+            maxResolution: profile.resolution, formatOrder: profile.formats
         ) {
             return streamPreferredForProfile
         }
 
-        return backend.bestPlayable(availableStreams.filter { backend.canPlay($0) }, maxResolution: profile.resolution)
+        return backend.bestPlayable(availableStreams.filter { backend.canPlay($0) }, maxResolution: profile.resolution, formatOrder: profile.formats)
     }
 
     func advanceToNextItem() {