Merge branch 'main' into add-user-agent-to-header

Model/Player/Backends/MPVBackend.swift

@@ -217,9 +217,22 @@ final class MPVBackend: PlayerBackend {
         #endif
 
         var captions: Captions?
-        if let captionsLanguageCode = Defaults[.captionsLanguageCode] {
-            captions = video.captions.first { $0.code == captionsLanguageCode } ??
-                video.captions.first { $0.code.contains(captionsLanguageCode) }
+
+        if Defaults[.captionsAutoShow] == true {
+            let captionsDefaultLanguageCode = Defaults[.captionsDefaultLanguageCode],
+                captionsFallbackLanguageCode = Defaults[.captionsFallbackLanguageCode]
+
+            // Try to get captions with the default language code first
+            captions = video.captions.first { $0.code == captionsDefaultLanguageCode } ??
+                video.captions.first { $0.code.contains(captionsDefaultLanguageCode) }
+
+            // If there are still no captions, try to get captions with the fallback language code
+            if captions.isNil && !captionsFallbackLanguageCode.isEmpty {
+                captions = video.captions.first { $0.code == captionsFallbackLanguageCode } ??
+                    video.captions.first { $0.code.contains(captionsFallbackLanguageCode) }
+            }
+        } else {
+            captions = nil
         }
 
         let updateCurrentStream = {
@@ -254,9 +267,8 @@ final class MPVBackend: PlayerBackend {
 
                 self.startClientUpdates()
 
-                // Captions should only be displayed when selected by the user,
-                // not when the video starts. So, we remove them.
-                self.client?.removeSubs()
+                if Defaults[.captionsAutoShow] { self.client?.setSubToAuto() } else { self.client?.setSubToNo() }
+                PlayerModel.shared.captions = self.captions
 
                 if !preservingTime,
                    !upgrading,

Model/Player/Backends/MPVClient.swift

@@ -68,6 +68,8 @@ final class MPVClient: ObservableObject {
         checkError(mpv_set_option_string(mpv, "vo", "libmpv"))
         checkError(mpv_set_option_string(mpv, "demuxer-lavf-analyzeduration", "1"))
         checkError(mpv_set_option_string(mpv, "deinterlace", Defaults[.mpvDeinterlace] ? "yes" : "no"))
+        checkError(mpv_set_option_string(mpv, "sub-scale", Defaults[.captionsFontScaleSize]))
+        checkError(mpv_set_option_string(mpv, "sub-color", Defaults[.captionsFontColor]))
         checkError(mpv_set_option_string(mpv, "user-agent", UserAgentManager.shared.userAgent))
 
         checkError(mpv_initialize(mpv))
@@ -406,6 +408,22 @@ final class MPVClient: ObservableObject {
         setString("video", "no")
     }
 
+    func setSubToAuto() {
+        setString("sub", "auto")
+    }
+
+    func setSubToNo() {
+        setString("sub", "no")
+    }
+
+    func setSubFontSize(scaleSize: String) {
+        setString("sub-scale", scaleSize)
+    }
+
+    func setSubFontColor(color: String) {
+        setString("sub-color", color)
+    }
+
     var tracksCount: Int {
         Int(getString("track-list/count") ?? "-1") ?? -1
     }

Model/Player/Backends/PlayerBackend.swift

@@ -133,23 +133,22 @@ extension PlayerBackend {
     }
 
     func bestPlayable(_ streams: [Stream], maxResolution: ResolutionSetting, formatOrder: [QualityProfile.Format]) -> Stream? {
-        // filter out non HLS streams
-        let nonHLSStreams = streams.filter { $0.kind != .hls }
+        // filter out non-HLS streams and streams with resolution more than maxResolution
+        let nonHLSStreams = streams.filter {
+            $0.kind != .hls && $0.resolution <= maxResolution.value
+        }
 
-        // find max resolution from non HLS streams
-        let bestResolution = nonHLSStreams
-            .filter { $0.resolution <= maxResolution.value }
-            .max { $0.resolution < $1.resolution }
+        // find max resolution and bitrate from non-HLS streams
+        let bestResolutionStream = nonHLSStreams.max { $0.resolution < $1.resolution }
+        let bestBitrateStream = nonHLSStreams.max { $0.bitrate ?? 0 < $1.bitrate ?? 0 }
 
-        // finde max bitrate from non HLS streams
-        let bestBitrate = nonHLSStreams
-            .filter { $0.resolution <= maxResolution.value }
-            .max { $0.bitrate ?? 0 < $1.bitrate ?? 0 }
+        let bestResolution = bestResolutionStream?.resolution ?? maxResolution.value
+        let bestBitrate = bestBitrateStream?.bitrate ?? bestResolutionStream?.resolution.bitrate ?? maxResolution.value.bitrate
 
         return streams.map { stream in
             if stream.kind == .hls {
-                stream.resolution = bestResolution?.resolution ?? maxResolution.value
-                stream.bitrate = bestBitrate?.bitrate ?? (bestResolution?.resolution.bitrate ?? maxResolution.value.bitrate)
+                stream.resolution = bestResolution
+                stream.bitrate = bestBitrate
                 stream.format = .hls
             } else if stream.kind == .stream {
                 stream.format = .stream