add drag gestures to video details

refactor Search

CHANGELOG.md

@@ -1,10 +1,10 @@
-## Build 192
-* Fix mpv crashing on macOS by @stonerl in https://github.com/yattee/yattee/pull/754
-* Refreshed icons for iOS and macOS by @stonerl in https://github.com/yattee/yattee/pull/752
-* Add new MPVKit repo by @stonerl in https://github.com/yattee/yattee/pull/753
-* Add Chinese (Simplified) - zh-Hans to LanguageCodes by @stonerl in https://github.com/yattee/yattee/pull/757
-* Color changes to VideoActions by @stonerl in https://github.com/yattee/yattee/pull/759
-* Hide VideoActions Bar when no buttons is visible by @stonerl in https://github.com/yattee/yattee/pull/760
+## Build 196
+* Orientation/Fullscreen fixes and cleanup by @stonerl in https://github.com/yattee/yattee/pull/806
+* More robust resolution handling by @stonerl in https://github.com/yattee/yattee/pull/807
+* MPV: improved A/V sync by @stonerl in https://github.com/yattee/yattee/pull/805
+* Retry loading video before presenting error by @stonerl in https://github.com/yattee/yattee/pull/810
+* Refactor Search by @stonerl in https://github.com/yattee/yattee/pull/809
+* Updated dependencies
 
 ## Previous builds
 * Add skip, play/pause, and fullscreen shortcuts to macOS player (by @rickykresslein)
@@ -23,6 +23,33 @@
 * Add import export of missing settings
 * macOS: Fix settings windows layout
 * Fix seek OSD layout on tvOS, revert OSD position
+* iOS: Simplified fullscreen and orientation by @stonerl in https://github.com/yattee/yattee/pull/786
+* macOS: only apply player shortcuts when window is active by @stonerl in https://github.com/yattee/yattee/pull/802
+* player controls: add background opacity selection by @stonerl in https://github.com/yattee/yattee/pull/799
+* add missing Shorts resolutions by @stonerl in https://github.com/yattee/yattee/pull/797
+* use -O1 on macOS by @stonerl in https://github.com/yattee/yattee/pull/801
+* Gestures: swipe up toggles fullscreen by @stonerl in https://github.com/yattee/yattee/pull/778
+* don’t open video when dismissing context menu by @stonerl in https://github.com/yattee/yattee/pull/780
+* mpv: remove video layer when entering background by @stonerl in https://github.com/yattee/yattee/pull/793
+* hi-res invidious logos by @stonerl in https://github.com/yattee/yattee/pull/791
+* enable -O3 by @stonerl in https://github.com/yattee/yattee/pull/794
+* Better audio ducking by @stonerl in https://github.com/yattee/yattee/pull/779
+* fix picture in picture by @stonerl in https://github.com/yattee/yattee/pull/789
+* Invidious: propper HTTP basic auth support by @stonerl in https://github.com/yattee/yattee/pull/762
+* Apply correct orientation by @stonerl in https://github.com/yattee/yattee/pull/770
+* Circular Invidious logo by @stonerl in https://github.com/yattee/yattee/pull/769
+* Video Thumbnails: retry 3 times fetching from URL by @stonerl in https://github.com/yattee/yattee/pull/768
+* Make thumbnail fill the view in music mode by @stonerl in https://github.com/yattee/yattee/pull/766
+* Changes to defaults by @stonerl in https://github.com/yattee/yattee/pull/767
+* Fixed fullscreen handling for backgrounding by @stonerl in https://github.com/yattee/yattee/pull/772
+* Update now playing info when using system controls – Partial fix for 503 by @stonerl in https://github.com/yattee/yattee/pull/765
+* Fix crash on HLS live playback by @stonerl in https://github.com/yattee/yattee/pull/775
+* Fix mpv crashing on macOS by @stonerl in https://github.com/yattee/yattee/pull/754
+* Refreshed icons for iOS and macOS by @stonerl in https://github.com/yattee/yattee/pull/752
+* Add new MPVKit repo by @stonerl in https://github.com/yattee/yattee/pull/753
+* Add Chinese (Simplified) - zh-Hans to LanguageCodes by @stonerl in https://github.com/yattee/yattee/pull/757
+* Color changes to VideoActions by @stonerl in https://github.com/yattee/yattee/pull/759
+* Hide VideoActions Bar when no buttons is visible by @stonerl in https://github.com/yattee/yattee/pull/760
 * Improved stream resolution handling by @stonerl in https://github.com/yattee/yattee/pull/747
 * Fix some potential crashes by @stonerl in https://github.com/yattee/yattee/pull/748
 * Fix regression and improve curentChapter handling by @stonerl in https://github.com/yattee/yattee/pull/749

Gemfile.lock

@@ -10,17 +10,17 @@ GEM
     artifactory (3.0.17)
     atomos (0.1.3)
     aws-eventstream (1.3.0)
-    aws-partitions (1.968.0)
-    aws-sdk-core (3.201.5)
+    aws-partitions (1.973.0)
+    aws-sdk-core (3.204.0)
       aws-eventstream (~> 1, >= 1.3.0)
       aws-partitions (~> 1, >= 1.651.0)
       aws-sigv4 (~> 1.9)
       jmespath (~> 1, >= 1.6.1)
-    aws-sdk-kms (1.88.0)
-      aws-sdk-core (~> 3, >= 3.201.0)
+    aws-sdk-kms (1.90.0)
+      aws-sdk-core (~> 3, >= 3.203.0)
       aws-sigv4 (~> 1.5)
-    aws-sdk-s3 (1.159.0)
-      aws-sdk-core (~> 3, >= 3.201.0)
+    aws-sdk-s3 (1.161.0)
+      aws-sdk-core (~> 3, >= 3.203.0)
       aws-sdk-kms (~> 1)
       aws-sigv4 (~> 1.5)
     aws-sigv4 (1.9.1)
@@ -171,8 +171,7 @@ GEM
       trailblazer-option (>= 0.1.1, < 0.2.0)
       uber (< 0.2.0)
     retriable (3.1.2)
-    rexml (3.3.6)
-      strscan
+    rexml (3.3.7)
     rouge (2.0.7)
     ruby2_keywords (0.0.5)
     rubyzip (2.3.2)
@@ -185,7 +184,6 @@ GEM
     simctl (1.6.10)
       CFPropertyList
       naturally
-    strscan (3.1.0)
     terminal-notifier (2.0.0)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)

Model/Accounts/AccountsBridge.swift

@@ -10,11 +10,28 @@ struct AccountsBridge: Defaults.Bridge {
             return nil
         }
 
+        // Parse the urlString to check for embedded username and password
+        var sanitizedUrlString = value.urlString
+        if var urlComponents = URLComponents(string: value.urlString) {
+            if let user = urlComponents.user, let password = urlComponents.password {
+                // Sanitize the embedded username and password
+                let sanitizedUser = user.addingPercentEncoding(withAllowedCharacters: .urlUserAllowed) ?? user
+                let sanitizedPassword = password.addingPercentEncoding(withAllowedCharacters: .urlPasswordAllowed) ?? password
+
+                // Update the URL components with sanitized credentials
+                urlComponents.user = sanitizedUser
+                urlComponents.password = sanitizedPassword
+
+                // Reconstruct the sanitized URL
+                sanitizedUrlString = urlComponents.string ?? value.urlString
+            }
+        }
+
         return [
             "id": value.id,
             "instanceID": value.instanceID ?? "",
             "name": value.name,
-            "apiURL": value.urlString,
+            "apiURL": sanitizedUrlString,
             "username": value.username,
             "password": value.password ?? ""
         ]

Model/Applications/InvidiousAPI.swift

@@ -247,27 +247,27 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
     }
 
     func feed(_ page: Int?) -> Resource? {
-        resource(baseURL: account.url, path: "\(Self.basePath)/auth/feed")
+        resourceWithAuthCheck(baseURL: account.url, path: "\(Self.basePath)/auth/feed")
             .withParam("page", String(page ?? 1))
     }
 
     var feed: Resource? {
-        resource(baseURL: account.url, path: basePathAppending("auth/feed"))
+        resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/feed"))
     }
 
     var subscriptions: Resource? {
-        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+        resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
     }
 
     func subscribe(_ channelID: String, onCompletion: @escaping () -> Void = {}) {
-        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+        resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
             .child(channelID)
             .request(.post)
             .onCompletion { _ in onCompletion() }
     }
 
     func unsubscribe(_ channelID: String, onCompletion: @escaping () -> Void) {
-        resource(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
+        resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/subscriptions"))
             .child(channelID)
             .request(.delete)
             .onCompletion { _ in onCompletion() }
@@ -308,11 +308,11 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
             return nil
         }
 
-        return resource(baseURL: account.url, path: basePathAppending("auth/playlists"))
+        return resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/playlists"))
     }
 
     func playlist(_ id: String) -> Resource? {
-        resource(baseURL: account.url, path: basePathAppending("auth/playlists/\(id)"))
+        resourceWithAuthCheck(baseURL: account.url, path: basePathAppending("auth/playlists/\(id)"))
     }
 
     func playlistVideos(_ id: String) -> Resource? {
@@ -445,6 +445,9 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
         urlComponents.scheme = instanceURLComponents.scheme
         urlComponents.host = instanceURLComponents.host
+        urlComponents.user = instanceURLComponents.user
+        urlComponents.password = instanceURLComponents.password
+        urlComponents.port = instanceURLComponents.port
 
         guard let url = urlComponents.url else {
             return nil
@@ -553,6 +556,30 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         )
     }
 
+    // Determines if the request requires Basic Auth credentials to be removed
+    private func needsBasicAuthRemoval(for path: String) -> Bool {
+        return path.hasPrefix("\(Self.basePath)/auth/")
+    }
+
+    // Creates a resource URL with consideration for removing Basic Auth credentials
+    private func createResourceURL(baseURL: URL, path: String) -> URL {
+        var resourceURL = baseURL
+
+        // Remove Basic Auth credentials if required
+        if needsBasicAuthRemoval(for: path), var urlComponents = URLComponents(url: baseURL, resolvingAgainstBaseURL: false) {
+            urlComponents.user = nil
+            urlComponents.password = nil
+            resourceURL = urlComponents.url ?? baseURL
+        }
+
+        return resourceURL.appendingPathComponent(path)
+    }
+
+    func resourceWithAuthCheck(baseURL: URL, path: String) -> Resource {
+        let sanitizedURL = createResourceURL(baseURL: baseURL, path: path)
+        return super.resource(absoluteURL: sanitizedURL)
+    }
+
     private func extractThumbnails(from details: JSON) -> [Thumbnail] {
         details["videoThumbnails"].arrayValue.compactMap { json in
             guard let url = json["url"].url,
@@ -563,13 +590,20 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
                 return nil
             }
 
-            // some of instances are not configured properly and return thumbnails links
-            // with incorrect scheme
+            // Some instances are not configured properly and return thumbnail links
+            // with an incorrect scheme or a missing port.
             components.scheme = accountUrlComponents.scheme
+            components.port = accountUrlComponents.port
+
+            // If basic HTTP authentication is used,
+            // the username and password need to be prepended to the URL.
+            components.user = accountUrlComponents.user
+            components.password = accountUrlComponents.password
 
             guard let thumbnailUrl = components.url else {
                 return nil
             }
+            print("Final thumbnail URL: \(thumbnailUrl)")
 
             return Thumbnail(url: thumbnailUrl, quality: .init(rawValue: quality)!)
         }

Model/Applications/PeerTubeAPI.swift

@@ -515,7 +515,8 @@ final class PeerTubeAPI: Service, ObservableObject, VideosAPI {
             .dictionaryValue["files"]?.arrayValue.first?
             .dictionaryValue["fileUrl"]?.url
         {
-            streams.append(SingleAssetStream(instance: account.instance, avAsset: AVURLAsset(url: fileURL), resolution: .hd720p30, kind: .stream))
+            let resolution = Stream.Resolution.predefined(.hd720p30)
+            streams.append(SingleAssetStream(instance: account.instance, avAsset: AVURLAsset(url: fileURL), resolution: resolution, kind: .stream))
         }
 
         return streams

Model/Import Export Settings/Exporters/AdvancedSettingsGroupExporter.swift

@@ -5,6 +5,7 @@ final class AdvancedSettingsGroupExporter: SettingsGroupExporter {
     override var globalJSON: JSON {
         [
             "showPlayNowInBackendContextMenu": Defaults[.showPlayNowInBackendContextMenu],
+            "videoLoadingRetryCount": Defaults[.videoLoadingRetryCount],
             "showMPVPlaybackStats": Defaults[.showMPVPlaybackStats],
             "mpvEnableLogging": Defaults[.mpvEnableLogging],
             "mpvCacheSecs": Defaults[.mpvCacheSecs],
@@ -13,6 +14,7 @@ final class AdvancedSettingsGroupExporter: SettingsGroupExporter {
             "mpvDeinterlace": Defaults[.mpvDeinterlace],
             "mpvHWdec": Defaults[.mpvHWdec],
             "mpvDemuxerLavfProbeInfo": Defaults[.mpvDemuxerLavfProbeInfo],
+            "mpvSetRefreshToContentFPS": Defaults[.mpvSetRefreshToContentFPS],
             "mpvInitialAudioSync": Defaults[.mpvInitialAudioSync],
             "showCacheStatus": Defaults[.showCacheStatus],
             "feedCacheSize": Defaults[.feedCacheSize]

Model/Import Export Settings/Exporters/BrowsingSettingsGroupExporter.swift

@@ -11,6 +11,7 @@ final class BrowsingSettingsGroupExporter: SettingsGroupExporter {
             "favorites": Defaults[.favorites].compactMap { jsonFromString(FavoriteItem.bridge.serialize($0)) },
             "widgetsSettings": Defaults[.widgetsSettings].compactMap { widgetSettingsJSON($0) },
             "startupSection": Defaults[.startupSection].rawValue,
+            "showSearchSuggestions": Defaults[.showSearchSuggestions],
             "visibleSections": Defaults[.visibleSections].compactMap { $0.rawValue },
             "showOpenActionsToolbarItem": Defaults[.showOpenActionsToolbarItem],
             "accountPickerDisplaysAnonymousAccounts": Defaults[.accountPickerDisplaysAnonymousAccounts],

Model/Import Export Settings/Exporters/ControlsSettingsGroupExporter.swift

@@ -10,6 +10,7 @@ final class ConstrolsSettingsGroupExporter: SettingsGroupExporter {
             "seekGestureSpeed": Defaults[.seekGestureSpeed],
             "playerControlsLayout": Defaults[.playerControlsLayout].rawValue,
             "fullScreenPlayerControlsLayout": Defaults[.fullScreenPlayerControlsLayout].rawValue,
+            "playerControlsBackgroundOpacity": Defaults[.playerControlsBackgroundOpacity],
             "systemControlsCommands": Defaults[.systemControlsCommands].rawValue,
             "buttonBackwardSeekDuration": Defaults[.buttonBackwardSeekDuration],
             "buttonForwardSeekDuration": Defaults[.buttonForwardSeekDuration],

Model/Import Export Settings/Exporters/PlayerSettingsGroupExporter.swift

@@ -44,7 +44,7 @@ final class PlayerSettingsGroupExporter: SettingsGroupExporter {
         #endif
 
         #if os(iOS)
-            export["honorSystemOrientationLock"].bool = Defaults[.honorSystemOrientationLock]
+            export["isOrientationLocked"].bool = Defaults[.isOrientationLocked]
             export["enterFullscreenInLandscape"].bool = Defaults[.enterFullscreenInLandscape]
             export["rotateToLandscapeOnEnterFullScreen"].string = Defaults[.rotateToLandscapeOnEnterFullScreen].rawValue
         #endif

Model/Import Export Settings/Importers/AdvancedSettingsGroupImporter.swift

@@ -9,6 +9,10 @@ struct AdvancedSettingsGroupImporter {
             Defaults[.showPlayNowInBackendContextMenu] = showPlayNowInBackendContextMenu
         }
 
+        if let videoLoadingRetryCount = json["videoLoadingRetryCount"].int {
+            Defaults[.videoLoadingRetryCount] = videoLoadingRetryCount
+        }
+
         if let showMPVPlaybackStats = json["showMPVPlaybackStats"].bool {
             Defaults[.showMPVPlaybackStats] = showMPVPlaybackStats
         }
@@ -41,6 +45,10 @@ struct AdvancedSettingsGroupImporter {
             Defaults[.mpvDemuxerLavfProbeInfo] = mpvDemuxerLavfProbeInfo
         }
 
+        if let mpvSetRefreshToContentFPS = json["mpvSetRefreshToContentFPS"].bool {
+            Defaults[.mpvSetRefreshToContentFPS] = mpvSetRefreshToContentFPS
+        }
+
         if let mpvInitialAudioSync = json["mpvInitialAudioSync"].bool {
             Defaults[.mpvInitialAudioSync] = mpvInitialAudioSync
         }

Model/Import Export Settings/Importers/BrowsingSettingsGroupImporter.swift

@@ -46,6 +46,10 @@ struct BrowsingSettingsGroupImporter {
             Defaults[.startupSection] = startupSection
         }
 
+        if let showSearchSuggestions = json["showSearchSuggestions"].bool {
+            Defaults[.showSearchSuggestions] = showSearchSuggestions
+        }
+
         if let visibleSections = json["visibleSections"].array {
             let sections = visibleSections.compactMap { visibleSectionJSON in
                 if let visibleSectionString = visibleSectionJSON.rawString(options: []),

Model/Import Export Settings/Importers/ControlsSettingsGroupImporter.swift

@@ -33,6 +33,10 @@ struct ConstrolsSettingsGroupImporter {
             Defaults[.fullScreenPlayerControlsLayout] = fullScreenPlayerControlsLayout
         }
 
+        if let playerControlsBackgroundOpacity = json["playerControlsBackgroundOpacity"].double {
+            Defaults[.playerControlsBackgroundOpacity] = playerControlsBackgroundOpacity
+        }
+
         if let systemControlsCommandsString = json["systemControlsCommands"].string,
            let systemControlsCommands = SystemControlsCommands(rawValue: systemControlsCommandsString)
         {

Model/Import Export Settings/Importers/PlayerSettingsGroupImporter.swift

@@ -97,8 +97,8 @@ struct PlayerSettingsGroupImporter {
         #endif
 
         #if os(iOS)
-            if let honorSystemOrientationLock = json["honorSystemOrientationLock"].bool {
-                Defaults[.honorSystemOrientationLock] = honorSystemOrientationLock
+            if let isOrientationLocked = json["isOrientationLocked"].bool {
+                Defaults[.isOrientationLocked] = isOrientationLocked
             }
 
             if let enterFullscreenInLandscape = json["enterFullscreenInLandscape"].bool {

Model/Player/Backends/AVPlayerBackend.swift

@@ -102,7 +102,7 @@ final class AVPlayerBackend: PlayerBackend {
 
     private var frequentTimeObserver: Any?
     private var infrequentTimeObserver: Any?
-    private var playerTimeControlStatusObserver: Any?
+    private var playerTimeControlStatusObserver: NSKeyValueObservation?
 
     private var statusObservation: NSKeyValueObservation?
 
@@ -119,10 +119,30 @@ final class AVPlayerBackend: PlayerBackend {
         #if os(iOS)
             controller.player = avPlayer
         #endif
+        logger.info("AVPlayerBackend initialized.")
+    }
+
+    deinit {
+        // Invalidate any observers to avoid memory leaks
+        statusObservation?.invalidate()
+        playerTimeControlStatusObserver?.invalidate()
+
+        // Remove any time observers added to AVPlayer
+        if let frequentObserver = frequentTimeObserver {
+            avPlayer.removeTimeObserver(frequentObserver)
+        }
+        if let infrequentObserver = infrequentTimeObserver {
+            avPlayer.removeTimeObserver(infrequentObserver)
+        }
+
+        // Remove notification observers
+        removeItemDidPlayToEndTimeObserver()
+
+        logger.info("AVPlayerBackend deinitialized.")
     }
 
     func canPlay(_ stream: Stream) -> Bool {
-        stream.kind == .hls || stream.kind == .stream || (stream.kind == .adaptive && stream.format == .mp4)
+        stream.kind == .hls || stream.kind == .stream
     }
 
     func playStream(
@@ -344,7 +364,11 @@ final class AVPlayerBackend: PlayerBackend {
 
         let startPlaying = {
             #if !os(macOS)
-                try? AVAudioSession.sharedInstance().setActive(true)
+                do {
+                    try AVAudioSession.sharedInstance().setActive(true)
+                } catch {
+                    self.logger.error("Error setting up audio session: \(error)")
+                }
             #endif
 
             self.setRate(self.model.currentRate)
@@ -779,7 +803,7 @@ final class AVPlayerBackend: PlayerBackend {
                     opened = true
                     controller.startPictureInPicture()
                 } else {
-                    print("PiP not possible, waited \(delay) seconds")
+                    self.logger.info("PiP not possible, waited \(delay) seconds")
                 }
             }
         }

Model/Player/Backends/MPVBackend.swift

@@ -11,6 +11,7 @@ import SwiftUI
 final class MPVBackend: PlayerBackend {
     static var timeUpdateInterval = 0.5
     static var networkStateUpdateInterval = 0.1
+    static var refreshRateUpdateInterval = 0.5
 
     private var logger = Logger(label: "mpv-backend")
 
@@ -24,7 +25,9 @@ final class MPVBackend: PlayerBackend {
     var video: Video?
     var captions: Captions? { didSet {
         guard let captions else {
-            client?.removeSubs()
+            if client?.areSubtitlesAdded == true {
+                client?.removeSubs()
+            }
             return
         }
         addSubTrack(captions.url)
@@ -89,6 +92,7 @@ final class MPVBackend: PlayerBackend {
 
     private var clientTimer: Repeater!
     private var networkStateTimer: Repeater!
+    private var refreshRateTimer: Repeater!
 
     private var onFileLoaded: (() -> Void)?
 
@@ -184,27 +188,30 @@ final class MPVBackend: PlayerBackend {
     }
 
     init() {
-        // swiftlint:disable shorthand_optional_binding
         clientTimer = .init(interval: .seconds(Self.timeUpdateInterval), mode: .infinite) { [weak self] _ in
-            guard let self = self, self.model.activeBackend == .mpv else {
+            guard let self, self.model.activeBackend == .mpv else {
                 return
             }
             self.getTimeUpdates()
         }
 
         networkStateTimer = .init(interval: .seconds(Self.networkStateUpdateInterval), mode: .infinite) { [weak self] _ in
-            guard let self = self, self.model.activeBackend == .mpv else {
+            guard let self, self.model.activeBackend == .mpv else {
                 return
             }
             self.updateNetworkState()
         }
-        // swiftlint:enable shorthand_optional_binding
+
+        refreshRateTimer = .init(interval: .seconds(Self.refreshRateUpdateInterval), mode: .infinite) { [weak self] _ in
+            guard let self, self.model.activeBackend == .mpv else { return }
+            self.checkAndUpdateRefreshRate()
+        }
     }
 
     typealias AreInIncreasingOrder = (Stream, Stream) -> Bool
 
     func canPlay(_ stream: Stream) -> Bool {
-        stream.resolution != .unknown && stream.format != .av1
+        stream.format != .av1
     }
 
     func playStream(_ stream: Stream, of video: Video, preservingTime: Bool, upgrading: Bool) {
@@ -248,13 +255,6 @@ final class MPVBackend: PlayerBackend {
             #if !os(macOS)
                 do {
                     try AVAudioSession.sharedInstance().setActive(true)
-
-                    NotificationCenter.default.addObserver(
-                        self,
-                        selector: #selector(self.handleAudioSessionInterruption(_:)),
-                        name: AVAudioSession.interruptionNotification,
-                        object: nil
-                    )
                 } catch {
                     self.logger.error("Error setting up audio session: \(error)")
                 }
@@ -350,8 +350,17 @@ final class MPVBackend: PlayerBackend {
         startClientUpdates()
     }
 
+    func startRefreshRateUpdates() {
+        refreshRateTimer.start()
+    }
+
+    func stopRefreshRateUpdates() {
+        refreshRateTimer.pause()
+    }
+
     func play() {
         startClientUpdates()
+        startRefreshRateUpdates()
 
         if controls.presentingControls {
             startControlsUpdates()
@@ -379,6 +388,7 @@ final class MPVBackend: PlayerBackend {
 
     func pause() {
         stopClientUpdates()
+        stopRefreshRateUpdates()
 
         client?.pause()
         isPaused = true
@@ -398,6 +408,8 @@ final class MPVBackend: PlayerBackend {
     }
 
     func stop() {
+        stopClientUpdates()
+        stopRefreshRateUpdates()
         client?.stop()
         isPlaying = false
         isPaused = false
@@ -479,6 +491,52 @@ final class MPVBackend: PlayerBackend {
         }
     }
 
+    private func checkAndUpdateRefreshRate() {
+        guard let screenRefreshRate = client?.getScreenRefreshRate() else {
+            logger.warning("Failed to get screen refresh rate.")
+            return
+        }
+
+        let contentFps = client?.currentContainerFps ?? screenRefreshRate
+
+        guard Defaults[.mpvSetRefreshToContentFPS] else {
+            // If the current refresh rate doesn't match the screen refresh rate, reset it
+            if client?.currentRefreshRate != screenRefreshRate {
+                client?.updateRefreshRate(to: screenRefreshRate)
+                client?.currentRefreshRate = screenRefreshRate
+                #if !os(macOS)
+                    notifyViewToUpdateDisplayLink(with: screenRefreshRate)
+                #endif
+                logger.info("Reset refresh rate to screen's rate: \(screenRefreshRate) Hz")
+            }
+            return
+        }
+
+        // Adjust the refresh rate to match the content if it differs
+        if screenRefreshRate != contentFps {
+            client?.updateRefreshRate(to: contentFps)
+            client?.currentRefreshRate = contentFps
+            #if !os(macOS)
+                notifyViewToUpdateDisplayLink(with: contentFps)
+            #endif
+            logger.info("Adjusted screen refresh rate to match content: \(contentFps) Hz")
+        } else if client?.currentRefreshRate != screenRefreshRate {
+            // Ensure the refresh rate is set back to the screen's rate if no adjustment is needed
+            client?.updateRefreshRate(to: screenRefreshRate)
+            client?.currentRefreshRate = screenRefreshRate
+            #if !os(macOS)
+                notifyViewToUpdateDisplayLink(with: screenRefreshRate)
+            #endif
+            logger.info("Checked and reset refresh rate to screen's rate: \(screenRefreshRate) Hz")
+        }
+    }
+
+    #if !os(macOS)
+        private func notifyViewToUpdateDisplayLink(with refreshRate: Int) {
+            NotificationCenter.default.post(name: .updateDisplayLinkFrameRate, object: nil, userInfo: ["refreshRate": refreshRate])
+        }
+    #endif
+
     func handle(_ event: UnsafePointer<mpv_event>!) {
         logger.info(.init(stringLiteral: "RECEIVED  event: \(String(cString: mpv_event_name(event.pointee.event_id)))"))
 
@@ -559,7 +617,9 @@ final class MPVBackend: PlayerBackend {
     }
 
     func addSubTrack(_ url: URL) {
-        client?.removeSubs()
+        if client?.areSubtitlesAdded == true {
+            client?.removeSubs()
+        }
         client?.addSubTrack(url)
     }
 
@@ -649,33 +709,4 @@ final class MPVBackend: PlayerBackend {
             logger.info("MPV backend received unhandled property: \(name)")
         }
     }
-
-    #if !os(macOS)
-        @objc func handleAudioSessionInterruption(_ notification: Notification) {
-            logger.info("Audio session interruption received.")
-
-            guard let info = notification.userInfo,
-                  let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt
-            else {
-                logger.info("AVAudioSessionInterruptionTypeKey is missing or not a UInt in userInfo.")
-                return
-            }
-
-            let type = AVAudioSession.InterruptionType(rawValue: typeValue)
-
-            logger.info("Interruption type received: \(String(describing: type))")
-
-            switch type {
-            case .began:
-                pause()
-                logger.info("Audio session interrupted.")
-            default:
-                break
-            }
-        }
-
-        deinit {
-            NotificationCenter.default.removeObserver(self, name: AVAudioSession.interruptionNotification, object: nil)
-        }
-    #endif
 }

Model/Player/Backends/MPVClient.swift

@@ -6,6 +6,8 @@ import Logging
 #if !os(macOS)
     import Siesta
     import UIKit
+#else
+    import AppKit
 #endif
 
 final class MPVClient: ObservableObject {
@@ -14,6 +16,8 @@ final class MPVClient: ObservableObject {
     }
 
     private var logger = Logger(label: "mpv-client")
+    private var needsDrawingCooldown = false
+    private var needsDrawingWorkItem: DispatchWorkItem?
 
     var mpv: OpaquePointer!
     var mpvGL: OpaquePointer!
@@ -27,6 +31,7 @@ final class MPVClient: ObservableObject {
     var backend: MPVBackend!
 
     var seeking = false
+    var currentRefreshRate = 60
 
     func create(frame: CGRect? = nil) {
         #if !os(macOS)
@@ -37,7 +42,7 @@ final class MPVClient: ObservableObject {
 
         mpv = mpv_create()
         if mpv == nil {
-            print("failed creating context\n")
+            logger.critical("failed creating context\n")
             exit(1)
         }
 
@@ -74,6 +79,27 @@ final class MPVClient: ObservableObject {
         checkError(mpv_set_option_string(mpv, "user-agent", UserAgentManager.shared.userAgent))
         checkError(mpv_set_option_string(mpv, "initial-audio-sync", Defaults[.mpvInitialAudioSync] ? "yes" : "no"))
 
+        // Enable VSYNC – needed for `video-sync`
+        checkError(mpv_set_option_string(mpv, "opengl-swapinterval", "1"))
+        checkError(mpv_set_option_string(mpv, "video-sync", "display-resample"))
+        checkError(mpv_set_option_string(mpv, "interpolation", "yes"))
+        checkError(mpv_set_option_string(mpv, "tscale", "mitchell"))
+        checkError(mpv_set_option_string(mpv, "tscale-window", "blackman"))
+        checkError(mpv_set_option_string(mpv, "vd-lavc-framedrop", "nonref"))
+        checkError(mpv_set_option_string(mpv, "display-fps-override", "\(String(getScreenRefreshRate()))"))
+
+        // CPU //
+
+        // Determine number of threads based on system core count
+        let numberOfCores = ProcessInfo.processInfo.processorCount
+        let threads = numberOfCores * 2
+
+        // Log the number of cores and threads
+        logger.info("Number of CPU cores: \(numberOfCores)")
+
+        // Set the number of threads dynamically
+        checkError(mpv_set_option_string(mpv, "vd-lavc-threads", "\(threads)"))
+
         // GPU //
 
         checkError(mpv_set_option_string(mpv, "hwdec", Defaults[.mpvHWdec]))
@@ -81,7 +107,6 @@ final class MPVClient: ObservableObject {
 
         // We set set everything to OpenGL so MPV doesn't have to probe for other APIs.
         checkError(mpv_set_option_string(mpv, "gpu-api", "opengl"))
-        checkError(mpv_set_option_string(mpv, "opengl-swapinterval", "0"))
 
         #if !os(macOS)
             checkError(mpv_set_option_string(mpv, "opengl-es", "yes"))
@@ -112,7 +137,7 @@ final class MPVClient: ObservableObject {
             get_proc_address_ctx: nil
         )
 
-        queue = DispatchQueue(label: "mpv")
+        queue = DispatchQueue(label: "mpv", qos: .userInteractive, attributes: [.concurrent])
 
         withUnsafeMutablePointer(to: &initParams) { initParams in
             var params = [
@@ -122,7 +147,7 @@ final class MPVClient: ObservableObject {
             ]
 
             if mpv_render_context_create(&mpvGL, mpv, &params) < 0 {
-                print("failed to initialize mpv GL context")
+                logger.critical("failed to initialize mpv GL context")
                 exit(1)
             }
 
@@ -318,6 +343,37 @@ final class MPVClient: ObservableObject {
         mpv.isNil ? false : getFlag("eof-reached")
     }
 
+    var currentContainerFps: Int {
+        guard !mpv.isNil else { return 30 }
+        let fps = getDouble("container-fps")
+        return Int(fps.rounded())
+    }
+
+    var areSubtitlesAdded: Bool {
+        guard !mpv.isNil else { return false }
+
+        // Retrieve the number of tracks
+        let trackCount = getInt("track-list/count")
+        guard trackCount > 0 else { return false }
+
+        for index in 0 ..< trackCount {
+            // Get the type of each track
+            if let trackType = getString("track-list/\(index)/type"), trackType == "sub" {
+                // Check if the subtitle track is currently selected
+                let selected = getInt("track-list/\(index)/selected")
+                if selected == 1 {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    func logCurrentFps() {
+        let fps = currentContainerFps
+        logger.info("Current container FPS: \(fps)")
+    }
+
     func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)? = nil) {
         guard !seeking else {
             logger.warning("ignoring seek, another in progress")
@@ -361,7 +417,7 @@ final class MPVClient: ObservableObject {
                 return
             }
 
-            DispatchQueue.main.async { [weak self] in
+            DispatchQueue.main.async(qos: .userInteractive) { [weak self] in
                 guard let self else { return }
                 let model = self.backend.model
                 let aspectRatio = self.aspectRatio > 0 && self.aspectRatio < VideoPlayerView.defaultAspectRatio ? self.aspectRatio : VideoPlayerView.defaultAspectRatio
@@ -389,10 +445,30 @@ final class MPVClient: ObservableObject {
     }
 
     func setNeedsDrawing(_ needsDrawing: Bool) {
+        // Check if we are currently in a cooldown period
+        guard !needsDrawingCooldown else {
+            logger.info("Not drawing, cooldown in progress")
+            return
+        }
+
         logger.info("needs drawing: \(needsDrawing)")
+
+        // Set the cooldown flag to true and cancel any existing work item
+        needsDrawingCooldown = true
+        needsDrawingWorkItem?.cancel()
+
         #if !os(macOS)
             glView?.needsDrawing = needsDrawing
         #endif
+
+        // Create a new DispatchWorkItem to reset the cooldown flag after 0.1 seconds
+        let workItem = DispatchWorkItem { [weak self] in
+            self?.needsDrawingCooldown = false
+        }
+        needsDrawingWorkItem = workItem
+
+        // Schedule the cooldown reset after 0.1 seconds
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: workItem)
     }
 
     func command(
@@ -420,6 +496,45 @@ final class MPVClient: ObservableObject {
         }
     }
 
+    func updateRefreshRate(to refreshRate: Int) {
+        setString("display-fps-override", "\(String(refreshRate))")
+        logger.info("Updated refresh rate during playback to: \(refreshRate) Hz")
+    }
+
+    // Retrieve the screen's current refresh rate dynamically.
+    func getScreenRefreshRate() -> Int {
+        var refreshRate = 60 // Default to 60 Hz in case of failure
+
+        #if os(macOS)
+            // macOS implementation using NSScreen
+            if let screen = NSScreen.main,
+               let displayID = screen.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? CGDirectDisplayID,
+               let mode = CGDisplayCopyDisplayMode(displayID),
+               mode.refreshRate > 0
+            {
+                refreshRate = Int(mode.refreshRate)
+                logger.info("Screen refresh rate: \(refreshRate) Hz")
+            } else {
+                logger.warning("Failed to get refresh rate from NSScreen.")
+            }
+        #else
+            // iOS implementation using UIScreen with a failover
+            let mainScreen = UIScreen.main
+            refreshRate = mainScreen.maximumFramesPerSecond
+
+            // Failover: if maximumFramesPerSecond is 0 or an unexpected value
+            if refreshRate <= 0 {
+                refreshRate = 60 // Fallback to 60 Hz
+                logger.warning("Failed to get refresh rate from UIScreen, falling back to 60 Hz.")
+            } else {
+                logger.info("Screen refresh rate: \(refreshRate) Hz")
+            }
+        #endif
+
+        currentRefreshRate = refreshRate
+        return refreshRate
+    }
+
     func addVideoTrack(_ url: URL) {
         command("video-add", args: [url.absoluteString])
     }

Model/Player/Backends/PlayerBackend.swift

@@ -153,7 +153,9 @@ extension PlayerBackend {
         // Filter out non-HLS streams and streams with resolution more than maxResolution
         let nonHLSStreams = streams.filter {
             let isHLS = $0.kind == .hls
-            let isWithinResolution = $0.resolution <= maxResolution.value
+            // Check if the stream's resolution is within the maximum allowed resolution
+            let isWithinResolution = $0.resolution.map { $0 <= maxResolution.value } ?? false
+
             logger.info("Stream ID: \($0.id) - Kind: \(String(describing: $0.kind)) - Resolution: \(String(describing: $0.resolution)) - Bitrate: \($0.bitrate ?? 0)")
             logger.info("Is HLS: \(isHLS), Is within resolution: \(isWithinResolution)")
             return !isHLS && isWithinResolution
@@ -187,6 +189,7 @@ extension PlayerBackend {
         }
 
         let filteredStreams = adjustedStreams.filter { stream in
+            // Check if the stream's resolution is within the maximum allowed resolution
             let isWithinResolution = stream.resolution <= maxResolution.value
             logger.info("Filtered stream ID: \(stream.id) - Is within max resolution: \(isWithinResolution)")
             return isWithinResolution

Model/Player/PlayerModel.swift

@@ -47,7 +47,7 @@ final class PlayerModel: ObservableObject {
 
     static var shared = PlayerModel()
 
-    let logger = Logger(label: "stream.yattee.app")
+    let logger = Logger(label: "stream.yattee.player.model")
 
     var playerItem: AVPlayerItem?
 
@@ -130,7 +130,15 @@ final class PlayerModel: ObservableObject {
 
     #if os(iOS)
         @Published var lockedOrientation: UIInterfaceOrientationMask?
-        @Default(.rotateToLandscapeOnEnterFullScreen) private var rotateToLandscapeOnEnterFullScreen
+        @Published var isOrientationLocked: Bool {
+            didSet {
+                Defaults[.isOrientationLocked] = isOrientationLocked
+            }
+        }
+
+        @Default(.rotateToLandscapeOnEnterFullScreen) var rotateToLandscapeOnEnterFullScreen
+        @Default(.lockPortraitWhenBrowsing) var lockPortraitWhenBrowsing
+        var fullscreenInitiatedByButton = false
     #endif
 
     @Published var currentChapterIndex: Int?
@@ -195,14 +203,35 @@ final class PlayerModel: ObservableObject {
     var rateToRestore: Float?
     private var remoteCommandCenterConfigured = false
 
+    // Used in the PlayerModel extension in PlayerQueue
+    var retryAttempts = [String: Int]()
+
     #if os(macOS)
         var keyPressMonitor: Any?
     #endif
 
     init() {
+        #if os(iOS)
+            isOrientationLocked = Defaults[.isOrientationLocked]
+
+            if isOrientationLocked, lockPortraitWhenBrowsing {
+                lockedOrientation = UIInterfaceOrientationMask.portrait
+                Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
+            } else if isOrientationLocked {
+                lockOrientationAction()
+            }
+        #endif
         #if !os(macOS)
             mpvBackend.controller = mpvController
             mpvBackend.client = mpvController.client
+
+            // Register for audio session interruption notifications
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(handleAudioSessionInterruption(_:)),
+                name: AVAudioSession.interruptionNotification,
+                object: nil
+            )
         #endif
 
         playbackMode = Defaults[.playbackMode]
@@ -219,6 +248,12 @@ final class PlayerModel: ObservableObject {
         currentRate = playerRate
     }
 
+    #if !os(macOS)
+        deinit {
+            NotificationCenter.default.removeObserver(self, name: AVAudioSession.interruptionNotification, object: nil)
+        }
+    #endif
+
     func show() {
         #if os(macOS)
             if presentingPlayer {
@@ -502,7 +537,10 @@ final class PlayerModel: ObservableObject {
     }
 
     private func handlePresentationChange() {
-        backend.setNeedsDrawing(presentingPlayer)
+        #if os(macOS)
+            // TODO: Check whether this is needed on macOS
+            backend.setNeedsDrawing(presentingPlayer)
+        #endif
 
         #if os(iOS)
             if presentingPlayer, activeBackend == .appleAVPlayer, avPlayerUsesSystemControls, Constants.isIPhone {
@@ -531,13 +569,11 @@ final class PlayerModel: ObservableObject {
 
         if !presentingPlayer {
             #if os(iOS)
-                if Defaults[.lockPortraitWhenBrowsing] {
+                if lockPortraitWhenBrowsing {
                     Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
                 } else {
-                    Orientation.lockOrientation(.allButUpsideDown)
+                    Orientation.lockOrientation(.all)
                 }
-
-                OrientationModel.shared.stopOrientationUpdates()
             #endif
         }
     }
@@ -644,32 +680,37 @@ final class PlayerModel: ObservableObject {
     }
 
     func closeCurrentItem(finished: Bool = false) {
-        pause()
-        videoBeingOpened = nil
-        advancing = false
-        forceBackendOnPlay = nil
-
+        guard !closing else { return }
         closing = true
-        controls.presentingControls = false
 
-        self.prepareCurrentItemForHistory(finished: finished)
+        if playingFullScreen { exitFullScreen() }
 
-        self.hide()
-
-        Delay.by(0.8) { [weak self] in
+        Delay.by(0.3) { [weak self] in
             guard let self else { return }
-            self.closePiP()
+            pause()
+            videoBeingOpened = nil
+            advancing = false
+            forceBackendOnPlay = nil
 
-            withAnimation {
-                self.currentItem = nil
+            controls.presentingControls = false
+
+            self.prepareCurrentItemForHistory(finished: finished)
+            self.hide()
+
+            Delay.by(0.7) { [weak self] in
+                guard let self else { return }
+                if playingInPictureInPicture { self.closePiP() }
+
+                withAnimation {
+                    self.currentItem = nil
+                }
+
+                self.updateNowPlayingInfo()
+                self.backend.closeItem()
+                self.aspectRatio = VideoPlayerView.defaultAspectRatio
+                self.resetAutoplay()
+                self.closing = false
             }
-            self.updateNowPlayingInfo()
-
-            self.backend.closeItem()
-            self.aspectRatio = VideoPlayerView.defaultAspectRatio
-            self.resetAutoplay()
-            self.closing = false
-            self.playingFullScreen = false
         }
     }
 
@@ -678,38 +719,24 @@ final class PlayerModel: ObservableObject {
         avPlayerBackend.startPictureInPictureOnPlay = false
         avPlayerBackend.startPictureInPictureOnSwitch = false
 
-        if activeBackend == .appleAVPlayer {
+        guard activeBackend != .appleAVPlayer else {
             avPlayerBackend.tryStartingPictureInPicture()
             return
         }
 
-        // First, we need to create an array with supported formats.
-        let formatOrderPiP: [QualityProfile.Format] = [.hls, .stream, .mp4]
+        avPlayerBackend.startPictureInPictureOnSwitch = true
 
-        guard let video = currentVideo else { return }
-        guard let stream = avPlayerBackend.bestPlayable(availableStreams, maxResolution: .hd720p30, formatOrder: formatOrderPiP) else { return }
-
-        if avPlayerBackend.video == video {
-            if activeBackend != .appleAVPlayer {
-                avPlayerBackend.startPictureInPictureOnSwitch = true
-            }
-            changeActiveBackend(from: activeBackend, to: .appleAVPlayer)
-        } else {
-            avPlayerBackend.startPictureInPictureOnPlay = true
-            playStream(stream, of: video, preservingTime: true, upgrading: true, withBackend: avPlayerBackend)
-        }
-
-        var retryCount = 0
-        _ = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] timer in
-            if let pipController = self?.pipController, pipController.isPictureInPictureActive, self?.avPlayerBackend.isPlaying == true {
-                self?.exitFullScreen()
-                self?.controls.objectWillChange.send()
-                timer.invalidate()
-            } else if retryCount < 3, self?.activeBackend == .appleAVPlayer, self?.avPlayerBackend.startPictureInPictureOnSwitch == false {
-                // If PiP didn't start, try starting it again up to 3 times,
-                self?.avPlayerBackend.startPictureInPictureOnSwitch = true
-                self?.avPlayerBackend.tryStartingPictureInPicture()
-                retryCount += 1
+        saveTime {
+            self.changeActiveBackend(from: .mpv, to: .appleAVPlayer)
+            _ = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] timer in
+                if let pipController = self?.pipController, pipController.isPictureInPictureActive, self?.avPlayerBackend.isPlaying == true {
+                    self?.exitFullScreen()
+                    self?.controls.objectWillChange.send()
+                    timer.invalidate()
+                } else if self?.activeBackend == .appleAVPlayer, self?.avPlayerBackend.startPictureInPictureOnSwitch == false {
+                    self?.avPlayerBackend.startPictureInPictureOnSwitch = true
+                    self?.avPlayerBackend.tryStartingPictureInPicture()
+                }
             }
         }
     }
@@ -739,19 +766,27 @@ final class PlayerModel: ObservableObject {
             show()
         #endif
 
-        if previousActiveBackend == .mpv {
-            saveTime {
-                self.changeActiveBackend(from: self.activeBackend, to: .mpv, isInClosePip: true)
-                _ = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] timer in
-                    if self?.activeBackend == .mpv, self?.mpvBackend.isPlaying == true {
-                        self?.backend.closePiP()
-                        self?.controls.resetTimer()
-                        timer.invalidate()
-                    }
+        avPlayerBackend.closePiP()
+        _ = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] timer in
+            if self?.activeBackend == .appleAVPlayer, self?.avPlayerBackend.isPlaying == true, self?.playingInPictureInPicture == false {
+                timer.invalidate()
+            }
+        }
+
+        guard previousActiveBackend == .mpv else { return }
+
+        saveTime {
+            self.changeActiveBackend(from: .appleAVPlayer, to: .mpv, isInClosePip: true)
+            _ = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] timer in
+                if self?.activeBackend == .mpv, self?.mpvBackend.isPlaying == true {
+                    timer.invalidate()
                 }
             }
-        } else {
-            backend.closePiP()
+        }
+
+        // We need to remove the itme from the player, if not it will be displayed when next video goe to PiP.
+        Delay.by(1.0) {
+            self.avPlayerBackend.closeItem()
         }
     }
 
@@ -764,7 +799,7 @@ final class PlayerModel: ObservableObject {
     }
 
     func toggleFullScreenAction() {
-        toggleFullscreen(playingFullScreen, showControls: false)
+        toggleFullscreen(playingFullScreen, showControls: false, initiatedByButton: true)
     }
 
     func togglePiPAction() {
@@ -777,20 +812,21 @@ final class PlayerModel: ObservableObject {
 
     #if os(iOS)
         var lockOrientationImage: String {
-            lockedOrientation.isNil ? "lock.rotation.open" : "lock.rotation"
+            isOrientationLocked ? "lock.rotation" : "lock.rotation.open"
         }
 
         func lockOrientationAction() {
-            if lockedOrientation.isNil {
+            // This makes toggling orientation lock more robust
+            if lockedOrientation.isNil || !isOrientationLocked {
+                isOrientationLocked = true
                 let orientationMask = OrientationTracker.shared.currentInterfaceOrientationMask
                 lockedOrientation = orientationMask
                 let orientation = OrientationTracker.shared.currentInterfaceOrientation
-                Orientation.lockOrientation(orientationMask, andRotateTo: .landscapeLeft)
-                // iOS 16 workaround
-                Orientation.lockOrientation(orientationMask, andRotateTo: orientation)
+                Orientation.lockOrientation(orientationMask, andRotateTo: playingFullScreen ? nil : orientation)
             } else {
+                isOrientationLocked = false
                 lockedOrientation = nil
-                Orientation.lockOrientation(.allButUpsideDown, andRotateTo: OrientationTracker.shared.currentInterfaceOrientation)
+                Orientation.lockOrientation(.all)
             }
         }
     #endif
@@ -880,26 +916,29 @@ final class PlayerModel: ObservableObject {
     }
 
     func updateRemoteCommandCenter() {
-        let skipForwardCommand = MPRemoteCommandCenter.shared().skipForwardCommand
-        let skipBackwardCommand = MPRemoteCommandCenter.shared().skipBackwardCommand
-        let previousTrackCommand = MPRemoteCommandCenter.shared().previousTrackCommand
-        let nextTrackCommand = MPRemoteCommandCenter.shared().nextTrackCommand
+        let commandCenter = MPRemoteCommandCenter.shared()
+        let skipForwardCommand = commandCenter.skipForwardCommand
+        let skipBackwardCommand = commandCenter.skipBackwardCommand
+        let previousTrackCommand = commandCenter.previousTrackCommand
+        let nextTrackCommand = commandCenter.nextTrackCommand
 
         if !remoteCommandCenterConfigured {
             remoteCommandCenterConfigured = true
 
-            #if !os(macOS)
-                try? AVAudioSession.sharedInstance().setCategory(
-                    .playback,
-                    mode: .moviePlayback
-                )
-
-                UIApplication.shared.beginReceivingRemoteControlEvents()
-            #endif
-
             let interval = TimeInterval(systemControlsSeekDuration) ?? 10
             let preferredIntervals = [NSNumber(value: interval)]
 
+            // Remove existing targets to avoid duplicates
+            skipForwardCommand.removeTarget(nil)
+            skipBackwardCommand.removeTarget(nil)
+            previousTrackCommand.removeTarget(nil)
+            nextTrackCommand.removeTarget(nil)
+            commandCenter.playCommand.removeTarget(nil)
+            commandCenter.pauseCommand.removeTarget(nil)
+            commandCenter.togglePlayPauseCommand.removeTarget(nil)
+            commandCenter.changePlaybackPositionCommand.removeTarget(nil)
+
+            // Re-add targets for handling commands
             skipForwardCommand.preferredIntervals = preferredIntervals
             skipBackwardCommand.preferredIntervals = preferredIntervals
 
@@ -923,22 +962,22 @@ final class PlayerModel: ObservableObject {
                 return .success
             }
 
-            MPRemoteCommandCenter.shared().playCommand.addTarget { [weak self] _ in
+            commandCenter.playCommand.addTarget { [weak self] _ in
                 self?.play()
                 return .success
             }
 
-            MPRemoteCommandCenter.shared().pauseCommand.addTarget { [weak self] _ in
+            commandCenter.pauseCommand.addTarget { [weak self] _ in
                 self?.pause()
                 return .success
             }
 
-            MPRemoteCommandCenter.shared().togglePlayPauseCommand.addTarget { [weak self] _ in
+            commandCenter.togglePlayPauseCommand.addTarget { [weak self] _ in
                 self?.togglePlay()
                 return .success
             }
 
-            MPRemoteCommandCenter.shared().changePlaybackPositionCommand.addTarget { [weak self] remoteEvent in
+            commandCenter.changePlaybackPositionCommand.addTarget { [weak self] remoteEvent in
                 guard let event = remoteEvent as? MPChangePlaybackPositionCommandEvent else { return .commandFailed }
 
                 self?.backend.seek(to: event.positionTime, seekType: .userInteracted)
@@ -973,25 +1012,43 @@ final class PlayerModel: ObservableObject {
         }
     #else
         func handleEnterForeground() {
-            setNeedsDrawing(presentingPlayer)
+            DispatchQueue.global(qos: .userInteractive).async { [weak self] in
+                guard let self = self else { return }
 
-            if !musicMode, activeBackend == .appleAVPlayer {
-                avPlayerBackend.bindPlayerToLayer()
+                if !self.musicMode, self.activeBackend == .mpv {
+                    self.mpvBackend.addVideoTrackFromStream()
+                    self.mpvBackend.setVideoToAuto()
+                    self.mpvBackend.controls.resetTimer()
+                } else if !self.musicMode, self.activeBackend == .appleAVPlayer {
+                    self.avPlayerBackend.bindPlayerToLayer()
+                }
             }
+            #if os(iOS)
+                OrientationTracker.shared.startDeviceOrientationTracking()
+            #endif
 
             guard closePiPAndOpenPlayerOnEnteringForeground, playingInPictureInPicture else {
                 return
             }
 
             show()
-            closePiP()
+            // Needs to be delayed a bit, otherwise the PiP windows stays open
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                self?.closePiP()
+            }
         }
 
         func handleEnterBackground() {
+            #if os(iOS)
+                OrientationTracker.shared.stopDeviceOrientationTracking()
+            #endif
+
             if Defaults[.pauseOnEnteringBackground], !playingInPictureInPicture, !musicMode {
                 pause()
-            } else if !playingInPictureInPicture {
+            } else if !playingInPictureInPicture, activeBackend == .appleAVPlayer {
                 avPlayerBackend.removePlayerFromLayer()
+            } else if activeBackend == .mpv, !musicMode {
+                mpvBackend.setVideoToNo()
             }
         }
     #endif
@@ -1017,18 +1074,22 @@ final class PlayerModel: ObservableObject {
             guard activeBackend == .mpv else { return }
         #endif
 
-        #if os(iOS)
-            if activeBackend == .appleAVPlayer, avPlayerUsesSystemControls {
-                return
-            }
-        #endif
-
         guard let video = currentItem?.video else {
             MPNowPlayingInfoCenter.default().nowPlayingInfo = .none
             return
         }
 
         let currentTime = (backend.currentTime?.seconds.isFinite ?? false) ? backend.currentTime!.seconds : 0
+
+        // Determine the media type based on musicMode
+        let mediaType: NSNumber
+        if musicMode {
+            mediaType = MPMediaType.anyAudio.rawValue as NSNumber
+        } else {
+            mediaType = MPMediaType.anyVideo.rawValue as NSNumber
+        }
+
+        // Prepare the Now Playing info dictionary
         var nowPlayingInfo: [String: AnyObject] = [
             MPMediaItemPropertyTitle: video.displayTitle as AnyObject,
             MPMediaItemPropertyArtist: video.displayAuthor as AnyObject,
@@ -1036,7 +1097,7 @@ final class PlayerModel: ObservableObject {
             MPNowPlayingInfoPropertyElapsedPlaybackTime: currentTime as AnyObject,
             MPNowPlayingInfoPropertyPlaybackQueueCount: queue.count as AnyObject,
             MPNowPlayingInfoPropertyPlaybackQueueIndex: 1 as AnyObject,
-            MPMediaItemPropertyMediaType: MPMediaType.anyVideo.rawValue as AnyObject
+            MPMediaItemPropertyMediaType: mediaType
         ]
 
         if !currentArtwork.isNil {
@@ -1057,7 +1118,7 @@ final class PlayerModel: ObservableObject {
 
     func updateCurrentArtwork() {
         guard let video = currentVideo,
-              let thumbnailURL = video.thumbnailURL(quality: .medium)
+              let thumbnailURL = video.thumbnailURL(quality: Constants.isIPhone ? .medium : .maxres)
         else {
             return
         }
@@ -1079,7 +1140,7 @@ final class PlayerModel: ObservableObject {
         task.resume()
     }
 
-    func toggleFullscreen(_ isFullScreen: Bool, showControls: Bool = true) {
+    func toggleFullscreen(_ isFullScreen: Bool, showControls: Bool = true, initiatedByButton: Bool = false) {
         controls.presentingControls = showControls && isFullScreen
 
         #if os(macOS)
@@ -1091,18 +1152,27 @@ final class PlayerModel: ObservableObject {
         #if os(iOS)
             if playingFullScreen {
                 if activeBackend == .appleAVPlayer, avPlayerUsesSystemControls {
+                    fullscreenInitiatedByButton = initiatedByButton
                     avPlayerBackend.controller.enterFullScreen(animated: true)
                     return
                 }
-                guard rotateToLandscapeOnEnterFullScreen.isRotating else { return }
+                let lockOrientation = rotateToLandscapeOnEnterFullScreen.interfaceOrientation
                 if currentVideoIsLandscape {
-                    let delay = activeBackend == .appleAVPlayer && avPlayerUsesSystemControls ? 0.8 : 0
-                    // not sure why but first rotation call is ignore so doing rotate to same orientation first
-                    Delay.by(delay) {
-                        let orientation = OrientationTracker.shared.currentDeviceOrientation.isLandscape ? OrientationTracker.shared.currentInterfaceOrientation : self.rotateToLandscapeOnEnterFullScreen.interaceOrientation
-                        Orientation.lockOrientation(.allButUpsideDown, andRotateTo: OrientationTracker.shared.currentInterfaceOrientation)
-                        Orientation.lockOrientation(.allButUpsideDown, andRotateTo: orientation)
+                    if initiatedByButton {
+                        Orientation.lockOrientation(isOrientationLocked
+                            ? (lockOrientation == .landscapeRight ? .landscapeRight : .landscapeLeft)
+                            : .landscape)
                     }
+                    let orientation = OrientationTracker.shared.currentDeviceOrientation.isLandscape
+                        ? OrientationTracker.shared.currentInterfaceOrientation
+                        : rotateToLandscapeOnEnterFullScreen.interfaceOrientation
+
+                    Orientation.lockOrientation(
+                        isOrientationLocked
+                            ? (lockOrientation == .landscapeRight ? .landscapeRight : .landscapeLeft)
+                            : .all,
+                        andRotateTo: orientation
+                    )
                 }
             } else {
                 if activeBackend == .appleAVPlayer, avPlayerUsesSystemControls {
@@ -1110,10 +1180,12 @@ final class PlayerModel: ObservableObject {
                     avPlayerBackend.controller.dismiss(animated: true)
                     return
                 }
-                let rotationOrientation = Constants.isIPhone ? UIInterfaceOrientation.portrait : nil
-                Orientation.lockOrientation(.allButUpsideDown, andRotateTo: rotationOrientation)
+                if lockPortraitWhenBrowsing {
+                    lockedOrientation = UIInterfaceOrientationMask.portrait
+                }
+                let rotationOrientation = lockPortraitWhenBrowsing ? UIInterfaceOrientation.portrait : nil
+                Orientation.lockOrientation(lockPortraitWhenBrowsing ? .portrait : .all, andRotateTo: rotationOrientation)
             }
-
         #endif
     }
 
@@ -1203,9 +1275,48 @@ final class PlayerModel: ObservableObject {
         return nil
     }
 
+    #if !os(macOS)
+        @objc func handleAudioSessionInterruption(_ notification: Notification) {
+            logger.info("Audio session interruption received.")
+            logger.info("Notification received: \(notification)")
+
+            guard let info = notification.userInfo,
+                  let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
+                  let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+            else {
+                logger.info("AVAudioSessionInterruptionTypeKey is missing or not a UInt in userInfo.")
+                return
+            }
+
+            logger.info("Interruption type received: \(type)")
+
+            switch type {
+            case .began:
+                logger.info("Audio session interrupted.")
+                // We need to call pause() to set all variables correctly, and play()
+                // directly afterwards, because the .began interrupt is sent after audio
+                // ducking ended and playback would pause. Audio ducking usually happens
+                // when using headphones.
+                pause()
+                play()
+            case .ended:
+                logger.info("Audio session interruption ended.")
+                // We need to call pause() to set all variables correctly.
+                // Otherwise, playback does not resume when the interruption ends.
+                pause()
+                play()
+            default:
+                break
+            }
+        }
+    #endif
+
     #if os(macOS)
         private func assignKeyPressMonitor() {
-            keyPressMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { keyEvent -> NSEvent? in
+            keyPressMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] keyEvent -> NSEvent? in
+                // Check if the player window is the key window
+                guard let self, let window = Windows.playerWindow, window.isKeyWindow else { return keyEvent }
+
                 switch keyEvent.keyCode {
                 case 124:
                     if !self.liveStreamInAVPlayer {
@@ -1240,7 +1351,7 @@ final class PlayerModel: ObservableObject {
         }
 
         private func destroyKeyPressMonitor() {
-            if let keyPressMonitor = keyPressMonitor {
+            if let keyPressMonitor {
                 NSEvent.removeMonitor(keyPressMonitor)
             }
         }

Model/Player/PlayerQueue.swift

@@ -359,6 +359,31 @@ extension PlayerModel {
     }
 
     private func videoLoadFailureHandler(_ error: RequestError, video: Video? = nil) {
+        guard let video else {
+            presentErrorAlert(error)
+            return
+        }
+
+        let videoID = video.videoID
+        let currentRetry = retryAttempts[videoID] ?? 0
+
+        if currentRetry < Defaults[.videoLoadingRetryCount] {
+            retryAttempts[videoID] = currentRetry + 1
+
+            logger.info("Retry attempt \(currentRetry + 1) for video \(videoID) due to error: \(error)")
+
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                guard let self else { return }
+                self.enqueueVideo(video, play: true, prepending: true, loadDetails: true)
+            }
+            return
+        }
+
+        retryAttempts[videoID] = 0
+        presentErrorAlert(error, video: video)
+    }
+
+    private func presentErrorAlert(_ error: RequestError, video: Video? = nil) {
         var message = error.userMessage
         if let errorDictionary = error.json.dictionaryObject,
            let errorMessage = errorDictionary["message"] ?? errorDictionary["error"],

Model/QualityProfile.swift

@@ -6,12 +6,12 @@ struct QualityProfile: Hashable, Identifiable, Defaults.Serializable {
     static var defaultProfile = Self(id: "default", backend: .mpv, resolution: .hd720p60, formats: [.stream], order: Array(Format.allCases.indices))
 
     enum Format: String, CaseIterable, Identifiable, Defaults.Serializable {
-        case hls
-        case stream
         case avc1
+        case stream
+        case webm
         case mp4
         case av1
-        case webm
+        case hls
 
         var id: String {
             rawValue
@@ -30,18 +30,18 @@ struct QualityProfile: Hashable, Identifiable, Defaults.Serializable {
 
         var streamFormat: Stream.Format? {
             switch self {
-            case .hls:
-                return nil
-            case .stream:
-                return nil
             case .avc1:
                 return .avc1
+            case .stream:
+                return nil
+            case .webm:
+                return .webm
             case .mp4:
                 return .mp4
             case .av1:
                 return .av1
-            case .webm:
-                return .webm
+            case .hls:
+                return nil
             }
         }
     }
@@ -59,14 +59,16 @@ struct QualityProfile: Hashable, Identifiable, Defaults.Serializable {
     }
 
     var formatsDescription: String {
-        if formats.count == Format.allCases.count {
+        switch formats.count {
+        case Format.allCases.count:
             return "Any format".localized()
-        }
-        if formats.count <= 3 {
+        case 0:
+            return "No format selected".localized()
+        case 1 ... 3:
             return formats.map(\.description).joined(separator: ", ")
+        default:
+            return String(format: "%@ formats".localized(), String(formats.count))
         }
-
-        return String(format: "%@ formats".localized(), String(formats.count))
     }
 
     func isPreferred(_ stream: Stream) -> Bool {
@@ -74,7 +76,8 @@ struct QualityProfile: Hashable, Identifiable, Defaults.Serializable {
             return true
         }
 
-        let resolutionMatch = !stream.resolution.isNil && resolution.value >= stream.resolution
+        let defaultResolution = Stream.Resolution.custom(height: 720, refreshRate: 30)
+        let resolutionMatch = resolution.value ?? defaultResolution >= stream.resolution
 
         if resolutionMatch, formats.contains(.stream), stream.kind == .stream {
             return true

Model/Search/SearchModel.swift

@@ -18,6 +18,8 @@ final class SearchModel: ObservableObject {
 
     @Published var focused = false
 
+    @Default(.showSearchSuggestions) private var showSearchSuggestions
+
     #if os(iOS)
         var textField: UITextField!
     #elseif os(macOS)
@@ -102,7 +104,7 @@ final class SearchModel: ObservableObject {
     }}
 
     func loadSuggestions(_ query: String) {
-        guard accounts.app.supportsSearchSuggestions else {
+        guard accounts.app.supportsSearchSuggestions, showSearchSuggestions else {
             querySuggestions.removeAll()
             return
         }

Model/Stream.swift

@@ -4,288 +4,126 @@ import Foundation
 
 // swiftlint:disable:next final_class
 class Stream: Equatable, Hashable, Identifiable {
-    enum Resolution: String, CaseIterable, Comparable, Defaults.Serializable {
-        // Some 16:19 and 16:10 resolutions are also used in 2:1 videos
+    enum Resolution: Comparable, Codable, Defaults.Serializable {
+        case predefined(PredefinedResolution)
+        case custom(height: Int, refreshRate: Int)
 
-        // 8K UHD (16:9) Resolutions
-        case hd4320p60
-        case hd4320p50
-        case hd4320p48
-        case hd4320p30
-        case hd4320p25
-        case hd4320p24
+        enum PredefinedResolution: String, CaseIterable, Codable {
+            // 8K UHD (16:9) Resolutions
+            case hd4320p60, hd4320p30
 
-        // 5K (16:9) Resolutions
-        case hd2560p60
-        case hd2560p50
-        case hd2560p48
-        case hd2560p30
-        case hd2560p25
-        case hd2560p24
+            // 4K UHD (16:9) Resolutions
+            case hd2160p60, hd2160p30
 
-        // 2:1 Aspect Ratio (Univisium) Resolutions
-        case hd2880p60
-        case hd2880p50
-        case hd2880p48
-        case hd2880p30
-        case hd2880p25
-        case hd2880p24
+            // 1440p (16:9) Resolutions
+            case hd1440p60, hd1440p30
 
-        // 16:10 Resolutions
-        case hd2400p60
-        case hd2400p50
-        case hd2400p48
-        case hd2400p30
-        case hd2400p25
-        case hd2400p24
+            // 1080p (Full HD, 16:9) Resolutions
+            case hd1080p60, hd1080p30
 
-        // 16:9 Resolutions
-        case hd2160p60
-        case hd2160p50
-        case hd2160p48
-        case hd2160p30
-        case hd2160p25
-        case hd2160p24
+            // 720p (HD, 16:9) Resolutions
+            case hd720p60, hd720p30
 
-        // 16:10 Resolutions
-        case hd1600p60
-        case hd1600p50
-        case hd1600p48
-        case hd1600p30
-        case hd1600p25
-        case hd1600p24
-
-        // 16:9 Resolutions
-        case hd1440p60
-        case hd1440p50
-        case hd1440p48
-        case hd1440p30
-        case hd1440p25
-        case hd1440p24
-
-        // 16:10 Resolutions
-        case hd1280p60
-        case hd1280p50
-        case hd1280p48
-        case hd1280p30
-        case hd1280p25
-        case hd1280p24
-
-        // 16:10 Resolutions
-        case hd1200p60
-        case hd1200p50
-        case hd1200p48
-        case hd1200p30
-        case hd1200p25
-        case hd1200p24
-
-        // 16:9 Resolutions
-        case hd1080p60
-        case hd1080p50
-        case hd1080p48
-        case hd1080p30
-        case hd1080p25
-        case hd1080p24
-
-        // 16:10 Resolutions
-        case hd1050p60
-        case hd1050p50
-        case hd1050p48
-        case hd1050p30
-        case hd1050p25
-        case hd1050p24
-
-        // 16:9 Resolutions
-        case hd960p60
-        case hd960p50
-        case hd960p48
-        case hd960p30
-        case hd960p25
-        case hd960p24
-
-        // 16:10 Resolutions
-        case hd900p60
-        case hd900p50
-        case hd900p48
-        case hd900p30
-        case hd900p25
-        case hd900p24
-
-        // 16:10 Resolutions
-        case hd800p60
-        case hd800p50
-        case hd800p48
-        case hd800p30
-        case hd800p25
-        case hd800p24
-
-        // 16:9 Resolutions
-        case hd720p60
-        case hd720p50
-        case hd720p48
-        case hd720p30
-        case hd720p25
-        case hd720p24
-
-        // Standard Definition (SD) Resolutions
-        case sd854p30
-        case sd854p25
-        case sd768p30
-        case sd768p25
-        case sd640p30
-        case sd640p25
-        case sd480p30
-        case sd480p25
-
-        case sd428p30
-        case sd428p25
-        case sd360p30
-        case sd360p25
-        case sd320p30
-        case sd320p25
-        case sd240p30
-        case sd240p25
-        case sd214p30
-        case sd214p25
-        case sd144p30
-        case sd144p25
-        case sd128p30
-        case sd128p25
-
-        case unknown
+            // Standard Definition (SD) Resolutions
+            case sd480p30
+            case sd360p30
+            case sd240p30
+            case sd144p30
+        }
 
         var name: String {
-            "\(height)p\(refreshRate != -1 && refreshRate != 30 ? ", \(refreshRate) fps" : "")"
+            switch self {
+            case let .predefined(predefined):
+                return predefined.rawValue
+            case let .custom(height, refreshRate):
+                return "\(height)p\(refreshRate != 30 ? ", \(refreshRate) fps" : "")"
+            }
         }
 
         var height: Int {
-            if self == .unknown {
-                return -1
+            switch self {
+            case let .predefined(predefined):
+                return predefined.height
+            case let .custom(height, _):
+                return height
             }
-
-            let resolutionPart = rawValue.components(separatedBy: "p").first!
-            return Int(resolutionPart.components(separatedBy: CharacterSet.decimalDigits.inverted).joined())!
         }
 
         var refreshRate: Int {
-            if self == .unknown {
-                return -1
+            switch self {
+            case let .predefined(predefined):
+                return predefined.refreshRate
+            case let .custom(_, refreshRate):
+                return refreshRate
             }
-
-            let refreshRatePart = rawValue.components(separatedBy: "p")[1]
-
-            if refreshRatePart.isEmpty {
-                return 30
-            }
-
-            return Int(refreshRatePart.components(separatedBy: CharacterSet.decimalDigits.inverted).joined()) ?? -1
         }
 
-        // These values are an approximation.
-        // https://support.google.com/youtube/answer/1722171?hl=en#zippy=%2Cbitrate
-
         var bitrate: Int {
             switch self {
-            // 8K UHD (16:9) Resolutions
-            case .hd4320p60, .hd4320p50, .hd4320p48, .hd4320p30, .hd4320p25, .hd4320p24:
-                return 85_000_000 // 85 Mbit/s
-
-            // 5K (16:9) Resolutions
-            case .hd2880p60, .hd2880p50, .hd2880p48, .hd2880p30, .hd2880p25, .hd2880p24:
-                return 45_000_000 // 45 Mbit/s
-
-            // 2:1 Aspect Ratio (Univisium) Resolutions
-            case .hd2560p60, .hd2560p50, .hd2560p48, .hd2560p30, .hd2560p25, .hd2560p24:
-                return 30_000_000 // 30 Mbit/s
-
-            // 16:10 Resolutions
-            case .hd2400p60, .hd2400p50, .hd2400p48, .hd2400p30, .hd2400p25, .hd2400p24:
-                return 35_000_000 // 35 Mbit/s
-
-            // 4K UHD (16:9) Resolutions
-            case .hd2160p60, .hd2160p50, .hd2160p48, .hd2160p30, .hd2160p25, .hd2160p24:
-                return 56_000_000 // 56 Mbit/s
-
-            // 16:10 Resolutions
-            case .hd1600p60, .hd1600p50, .hd1600p48, .hd1600p30, .hd1600p25, .hd1600p24:
-                return 20_000_000 // 20 Mbit/s
-
-            // 1440p (16:9) Resolutions
-            case .hd1440p60, .hd1440p50, .hd1440p48, .hd1440p30, .hd1440p25, .hd1440p24:
-                return 24_000_000 // 24 Mbit/s
-
-            // 1280p (16:10) Resolutions
-            case .hd1280p60, .hd1280p50, .hd1280p48, .hd1280p30, .hd1280p25, .hd1280p24:
-                return 15_000_000 // 15 Mbit/s
-
-            // 1200p (16:10) Resolutions
-            case .hd1200p60, .hd1200p50, .hd1200p48, .hd1200p30, .hd1200p25, .hd1200p24:
-                return 18_000_000 // 18 Mbit/s
-
-            // 1080p (16:9) Resolutions
-            case .hd1080p60, .hd1080p50, .hd1080p48, .hd1080p30, .hd1080p25, .hd1080p24:
-                return 12_000_000 // 12 Mbit/s
-
-            // 1050p (16:10) Resolutions
-            case .hd1050p60, .hd1050p50, .hd1050p48, .hd1050p30, .hd1050p25, .hd1050p24:
-                return 10_000_000 // 10 Mbit/s
-
-            // 960p Resolutions
-            case .hd960p60, .hd960p50, .hd960p48, .hd960p30, .hd960p25, .hd960p24:
-                return 8_000_000 // 8 Mbit/s
-
-            // 900p (16:10) Resolutions
-            case .hd900p60, .hd900p50, .hd900p48, .hd900p30, .hd900p25, .hd900p24:
-                return 7_000_000 // 7 Mbit/s
-
-            // 800p (16:10) Resolutions
-            case .hd800p60, .hd800p50, .hd800p48, .hd800p30, .hd800p25, .hd800p24:
-                return 6_000_000 // 6 Mbit/s
-
-            // 720p (16:9) Resolutions
-            case .hd720p60, .hd720p50, .hd720p48, .hd720p30, .hd720p25, .hd720p24:
-                return 9_500_000 // 9.5 Mbit/s
-
-            // Standard Definition (SD) Resolutions
-            case .sd854p30, .sd854p25, .sd768p30, .sd768p25, .sd640p30, .sd640p25:
-                return 4_000_000 // 4 Mbit/s
-
-            case .sd480p30, .sd480p25:
-                return 2_500_000 // 2.5 Mbit/s
-
-            case .sd428p30, .sd428p25:
-                return 2_000_000 // 2 Mbit/s
-
-            case .sd360p30, .sd360p25:
-                return 1_500_000 // 1.5 Mbit/s
-
-            case .sd320p30, .sd320p25:
-                return 1_200_000 // 1.2 Mbit/s
-
-            case .sd240p30, .sd240p25:
-                return 1_000_000 // 1 Mbit/s
-
-            case .sd214p30, .sd214p25:
-                return 800_000 // 0.8 Mbit/s
-
-            case .sd144p30, .sd144p25:
-                return 600_000 // 0.6 Mbit/s
-
-            case .sd128p30, .sd128p25:
-                return 400_000 // 0.4 Mbit/s
-
-            case .unknown:
-                return 0
+            case let .predefined(predefined):
+                return predefined.bitrate
+            case let .custom(height, refreshRate):
+                // Find the closest predefined resolution based on height and refresh rate
+                let closestPredefined = Stream.Resolution.PredefinedResolution.allCases.min {
+                    abs($0.height - height) + abs($0.refreshRate - refreshRate) <
+                        abs($1.height - height) + abs($1.refreshRate - refreshRate)
+                }
+                // Return the bitrate of the closest predefined resolution or a default bitrate if no close match is found
+                return closestPredefined?.bitrate ?? 5_000_000
             }
         }
 
         static func from(resolution: String, fps: Int? = nil) -> Self {
-            allCases.first { $0.rawValue.contains(resolution) && $0.refreshRate == (fps ?? 30) } ?? .unknown
+            if let predefined = PredefinedResolution(rawValue: resolution) {
+                return .predefined(predefined)
+            }
+
+            // Attempt to parse height and refresh rate
+            if let height = Int(resolution.components(separatedBy: "p").first ?? ""), height > 0 {
+                let refreshRate = fps ?? 30
+                return .custom(height: height, refreshRate: refreshRate)
+            }
+
+            // Default behavior if parsing fails
+            return .custom(height: 720, refreshRate: 30)
         }
 
         static func < (lhs: Self, rhs: Self) -> Bool {
             lhs.height == rhs.height ? (lhs.refreshRate < rhs.refreshRate) : (lhs.height < rhs.height)
         }
+
+        enum CodingKeys: String, CodingKey {
+            case predefined
+            case custom
+            case height
+            case refreshRate
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+
+            if let predefinedValue = try? container.decode(PredefinedResolution.self, forKey: .predefined) {
+                self = .predefined(predefinedValue)
+            } else if let height = try? container.decode(Int.self, forKey: .height),
+                      let refreshRate = try? container.decode(Int.self, forKey: .refreshRate)
+            {
+                self = .custom(height: height, refreshRate: refreshRate)
+            } else {
+                // Set default resolution to 720p 30 if decoding fails
+                self = .custom(height: 720, refreshRate: 30)
+            }
+        }
+
+        func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            switch self {
+            case let .predefined(predefinedValue):
+                try container.encode(predefinedValue, forKey: .predefined)
+            case let .custom(height, refreshRate):
+                try container.encode(height, forKey: .height)
+                try container.encode(refreshRate, forKey: .refreshRate)
+            }
+        }
     }
 
     enum Kind: String, Comparable {
@@ -478,3 +316,97 @@ class Stream: Equatable, Hashable, Identifiable {
         }
     }
 }
+
+extension Stream.Resolution.PredefinedResolution {
+    var height: Int {
+        switch self {
+        // 8K UHD (16:9) Resolutions
+        case .hd4320p60, .hd4320p30:
+            return 4320
+
+        // 4K UHD (16:9) Resolutions
+        case .hd2160p60, .hd2160p30:
+            return 2160
+
+        // 1440p (16:9) Resolutions
+        case .hd1440p60, .hd1440p30:
+            return 1440
+
+        // 1080p (Full HD, 16:9) Resolutions
+        case .hd1080p60, .hd1080p30:
+            return 1080
+
+        // 720p (HD, 16:9) Resolutions
+        case .hd720p60, .hd720p30:
+            return 720
+
+        // Standard Definition (SD) Resolutions
+        case .sd480p30:
+            return 480
+
+        case .sd360p30:
+            return 360
+
+        case .sd240p30:
+            return 240
+
+        case .sd144p30:
+            return 144
+        }
+    }
+
+    var refreshRate: Int {
+        switch self {
+        // 60 fps Resolutions
+        case .hd4320p60, .hd2160p60, .hd1440p60, .hd1080p60, .hd720p60:
+            return 60
+
+        // 30 fps Resolutions
+        case .hd4320p30, .hd2160p30, .hd1440p30, .hd1080p30, .hd720p30,
+             .sd480p30, .sd360p30, .sd240p30, .sd144p30:
+            return 30
+        }
+    }
+
+    // These values are an approximation.
+    // https://support.google.com/youtube/answer/1722171?hl=en#zippy=%2Cbitrate
+
+    var bitrate: Int {
+        switch self {
+        // 8K UHD (16:9) Resolutions
+        case .hd4320p60:
+            return 180_000_000 // Midpoint between 120 Mbps and 240 Mbps
+        case .hd4320p30:
+            return 120_000_000 // Midpoint between 80 Mbps and 160 Mbps
+        // 4K UHD (16:9) Resolutions
+        case .hd2160p60:
+            return 60_500_000 // Midpoint between 53 Mbps and 68 Mbps
+        case .hd2160p30:
+            return 40_000_000 // Midpoint between 35 Mbps and 45 Mbps
+        // 1440p (2K) Resolutions
+        case .hd1440p60:
+            return 24_000_000 // 24 Mbps
+        case .hd1440p30:
+            return 16_000_000 // 16 Mbps
+        // 1080p (Full HD, 16:9) Resolutions
+        case .hd1080p60:
+            return 12_000_000 // 12 Mbps
+        case .hd1080p30:
+            return 8_000_000 // 8 Mbps
+        // 720p (HD, 16:9) Resolutions
+        case .hd720p60:
+            return 7_500_000 // 7.5 Mbps
+        case .hd720p30:
+            return 5_000_000 // 5 Mbps
+        // Standard Definition (SD) Resolutions
+        case .sd480p30:
+            return 2_500_000 // 2.5 Mbps
+        case .sd360p30:
+            return 1_000_000 // 1 Mbps
+        case .sd240p30:
+            return 1_000_000 // 1 Mbps
+        case .sd144p30:
+            return 600_000 // 0.6 Mbps
+        }
+    }
+}

Model/ThumbnailsModel.swift

@@ -5,10 +5,27 @@ final class ThumbnailsModel: ObservableObject {
     static var shared = ThumbnailsModel()
 
     @Published var unloadable = Set<URL>()
+    private var retryCounts = [URL: Int]()
+    private let maxRetries = 3
+    private let retryDelay: TimeInterval = 1.0
 
     func insertUnloadable(_ url: URL) {
-        DispatchQueue.main.async {
-            self.unloadable.insert(url)
+        let retries = (retryCounts[url] ?? 0) + 1
+
+        if retries >= maxRetries {
+            DispatchQueue.main.async {
+                self.unloadable.insert(url)
+                self.retryCounts.removeValue(forKey: url)
+            }
+        } else {
+            DispatchQueue.main.async {
+                self.retryCounts[url] = retries
+            }
+            DispatchQueue.global().asyncAfter(deadline: .now() + retryDelay) {
+                DispatchQueue.main.async {
+                    self.retryCounts[url] = retries
+                }
+            }
         }
     }
 

Shared/Assets.xcassets/Invidious.imageset/Contents.json

@@ -1,15 +1,17 @@
 {
   "images" : [
     {
-      "filename" : "Invidious.svg",
+      "filename" : "Invidious_512x512@1x.png",
       "idiom" : "universal",
       "scale" : "1x"
     },
     {
+      "filename" : "Invidious_512x512@2x.png",
       "idiom" : "universal",
       "scale" : "2x"
     },
     {
+      "filename" : "Invidious_512x512@3x.png",
       "idiom" : "universal",
       "scale" : "3x"
     }

Shared/Assets.xcassets/Invidious.imageset/Invidious.svg

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="512pt" height="512pt" version="1.0" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg"><g><rect x="-.0072516" y=".00056299" width="512.01" height="512.02" fill="#575757" stroke-width=".063019"/><path d="m247.17 455.95c-19.792-0.78921-38.719-4.2564-57.154-10.47-60.968-20.55-108.68-68.579-127-127.86-7.8955-25.538-10.062-53.943-6.2586-82.067 3.7105-27.439 13.603-53.515 29.342-77.344 12.069-18.273 29.138-36.277 47.228-49.816 36.891-27.61 85.944-42.49 132.38-40.157 25.88 1.3001 49.939 6.765 73.106 16.606 8.1948 3.481 20.024 9.6845 27.696 14.525 14.15 8.9272 22.367 15.498 34.482 27.573 13.254 13.211 22.128 24.276 30.398 37.906 7.2081 11.879 14.099 27.15 18.229 40.397 1.5996 5.1305 4.442 16.456 5.6852 22.653 2.3908 11.917 2.6998 15.722 2.7049 33.312 6e-3 18.515-0.46256 24.413-2.9166 36.758-9.3274 46.92-35.58 88.167-74.872 117.64-22.814 17.112-50.027 29.535-78.547 35.858-16.714 3.7059-35.421 5.2453-54.498 4.4846zm-35.1-78.786c-5.3e-4 -0.52647-0.0741-2.0564-0.16311-3.3999l-0.16178-2.4427-4.7018-0.26271c-4.0477-0.22614-4.7968-0.33363-5.3847-0.77253-2.0235-1.5108-1.4679-6.0695 2.2494-18.457 0.8637-2.8781 3.3371-11.321 5.4966-18.762 2.1594-7.4409 5.2002-17.836 6.7573-23.101 1.5571-5.2648 4.1948-14.282 5.8615-20.038 1.6667-5.7562 3.6145-12.4 4.3284-14.764 0.71391-2.3641 3.2583-11.037 5.6542-19.272 4.9475-17.007 8.1626-27.723 8.9438-29.811 0.51852-1.3858 0.54785-1.4139 0.99761-0.95317 0.25486 0.26106 3.8462 7.3667 7.9807 15.79 4.1345 8.4236 13.089 26.573 19.898 40.331 17.188 34.73 37.849 76.578 43.261 87.622l4.5356 9.257 11.359-0.0895c6.2475-0.0492 11.615-0.19623 11.929-0.32672 0.5614-0.23385 0.54167-0.2959-1.3723-4.3176-1.068-2.2442-8.1436-16.601-15.724-31.904-48.687-98.293-61.22-123.86-67.889-138.48-4.7022-10.309-6.9031-14.807-7.7139-15.762-0.82931-0.97742-1.6319-1.0638-2.3704-0.25525-1.1993 1.313-4.1046 10.063-9.3869 28.27-2.0569 7.0899-6.5372 22.425-9.9562 34.077-6.6396 22.629-8.5182 29.037-14.33 48.883-2.0354 6.9495-4.7977 16.369-6.1385 20.931-1.3408 4.5628-4.033 13.81-5.9826 20.549-4.304 14.877-6.136 20.889-7.3886 24.25-2.1371 5.7334-2.5723 6.3292-4.9216 6.7384-0.88855 0.15472-2.4102 0.28196-3.3815 0.28275-2.1993 3e-3 -3.5494 0.36339-4.0558 1.0863-0.42176 0.60215-0.56421 4.8802-0.18251 5.4812 0.20573 0.32388 2.4672 0.37414 23.34 0.51873l8.6151 0.0597-7e-4 -0.95723zm36.751-205.59c4.3282-0.92335 8.4607-4.943 9.4374-9.1796 0.36569-1.5862 0.32543-4.9758-0.077-6.4799-0.85108-3.1813-3.2688-6.291-6.039-7.7675-3.8111-2.0313-9.456-2.0295-13.272 5e-3 -5.9828 3.1888-8.1556 11.089-4.7878 17.408 2.6995 5.0648 8.3611 7.3754 14.738 6.015z" fill="#f0f0f0" stroke-width=".025526"/></g><g transform="matrix(.069892 0 0 -.069892 44.236 474.48)"><path d="m2787 4669c-124-65-123-255 3-319 86-44 196-16 247 62 58 87 26 211-67 258-51 26-132 26-183-1z" fill="#00b6f0" stroke="#00b6f0" stroke-width="4.25"/><path d="m2882 4108c-12-16-63-166-102-303-30-104-101-350-165-565-20-69-58-199-85-290-26-91-64-221-85-290-20-69-58-199-85-290-26-91-64-221-85-290-20-69-57-195-81-280-59-207-93-299-115-310-10-6-35-10-56-10-73 0-84-8-81-54l3-41 228-3 228-2-3 47-3 48-73 3c-66 3-74 5-84 27-13 28 0 104 37 225 13 41 47 156 75 255s66 230 85 290c18 61 56 191 85 290 28 99 66 230 85 290 18 61 56 191 85 290 85 297 123 419 131 429 5 5 17-11 28-35 10-24 192-393 403-819s447-902 523-1058l139-282h168c92 0 168 4 168 8s-75 158-166 342c-588 1183-969 1958-1033 2100-29 63-69 151-89 195-44 95-58 110-80 83z" fill="#575757"/></g></svg>

Shared/Assets.xcassets/SearchTextFieldBackground.colorset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "1.000",
+          "green" : "1.000",
+          "red" : "1.000"
+        }
+      },
+      "idiom" : "universal"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0.110",
+          "green" : "0.110",
+          "red" : "0.118"
+        }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

Shared/Constants.swift

@@ -39,6 +39,38 @@ enum Constants {
         #endif
     }
 
+    static var isTvOS: Bool {
+        #if os(tvOS)
+            true
+        #else
+            false
+        #endif
+    }
+
+    static var isMacOS: Bool {
+        #if os(macOS)
+            true
+        #else
+            false
+        #endif
+    }
+
+    static var isIOS: Bool {
+        #if os(iOS)
+            true
+        #else
+            false
+        #endif
+    }
+
+    static var detailsVisibility: Bool {
+        #if os(iOS)
+            false
+        #else
+            true
+        #endif
+    }
+
     static var progressViewScale: Double {
         #if os(macOS)
             0.4
@@ -71,11 +103,11 @@ enum Constants {
         #endif
     }
 
-    static var detailsVisibility: Bool {
-        #if os(iOS)
-            false
+    static var contentViewMinWidth: Double {
+        #if os(macOS)
+            835
         #else
-            true
+            0
         #endif
     }
 

Shared/Defaults.swift

@@ -15,19 +15,20 @@ extension Defaults.Keys {
     static let favorites = Key<[FavoriteItem]>("favorites", default: [])
     static let widgetsSettings = Key<[WidgetSettings]>("widgetsSettings", default: [])
     static let startupSection = Key<StartupSection>("startupSection", default: .home)
+    static let showSearchSuggestions = Key<Bool>("showSearchSuggestions", default: true)
     static let visibleSections = Key<Set<VisibleSection>>("visibleSections", default: [.subscriptions, .trending, .playlists])
 
     static let showOpenActionsToolbarItem = Key<Bool>("showOpenActionsToolbarItem", default: false)
     #if os(iOS)
         static let showDocuments = Key<Bool>("showDocuments", default: false)
-        static let lockPortraitWhenBrowsing = Key<Bool>("lockPortraitWhenBrowsing", default: UIDevice.current.userInterfaceIdiom == .phone)
+        static let lockPortraitWhenBrowsing = Key<Bool>("lockPortraitWhenBrowsing", default: Constants.isIPhone)
     #endif
 
     #if !os(tvOS)
         #if os(macOS)
             static let accountPickerDisplaysUsernameDefault = true
         #else
-            static let accountPickerDisplaysUsernameDefault = UIDevice.current.userInterfaceIdiom == .pad
+            static let accountPickerDisplaysUsernameDefault = Constants.isIPad
         #endif
         static let accountPickerDisplaysUsername = Key<Bool>("accountPickerDisplaysUsername", default: accountPickerDisplaysUsernameDefault)
     #endif
@@ -41,9 +42,9 @@ extension Defaults.Keys {
     static let showChannelAvatarInVideosListing = Key<Bool>("showChannelAvatarInVideosListing", default: true)
 
     static let playerButtonSingleTapGesture = Key<PlayerTapGestureAction>("playerButtonSingleTapGesture", default: .togglePlayer)
-    static let playerButtonDoubleTapGesture = Key<PlayerTapGestureAction>("playerButtonDoubleTapGesture", default: .nothing)
-    static let playerButtonShowsControlButtonsWhenMinimized = Key<Bool>("playerButtonShowsControlButtonsWhenMinimized", default: false)
-    static let playerButtonIsExpanded = Key<Bool>("playerButtonIsExpanded", default: false)
+    static let playerButtonDoubleTapGesture = Key<PlayerTapGestureAction>("playerButtonDoubleTapGesture", default: .togglePlayerVisibility)
+    static let playerButtonShowsControlButtonsWhenMinimized = Key<Bool>("playerButtonShowsControlButtonsWhenMinimized", default: true)
+    static let playerButtonIsExpanded = Key<Bool>("playerButtonIsExpanded", default: true)
     static let playerBarMaxWidth = Key<String>("playerBarMaxWidth", default: "600")
     static let channelOnThumbnail = Key<Bool>("channelOnThumbnail", default: false)
     static let timeOnThumbnail = Key<Bool>("timeOnThumbnail", default: true)
@@ -64,7 +65,7 @@ extension Defaults.Keys {
     static let closeVideoOnEOF = Key<Bool>("closeVideoOnEOF", default: false)
 
     #if !os(macOS)
-        static let pauseOnEnteringBackground = Key<Bool>("pauseOnEnteringBackground", default: true)
+        static let pauseOnEnteringBackground = Key<Bool>("pauseOnEnteringBackground", default: false)
     #endif
 
     #if os(iOS)
@@ -79,7 +80,7 @@ extension Defaults.Keys {
 
     static let showChapters = Key<Bool>("showChapters", default: true)
     static let showChapterThumbnails = Key<Bool>("showChapterThumbnails", default: true)
-    static let showChapterThumbnailsOnlyWhenDifferent = Key<Bool>("showChapterThumbnailsOnlyWhenDifferent", default: true)
+    static let showChapterThumbnailsOnlyWhenDifferent = Key<Bool>("showChapterThumbnailsOnlyWhenDifferent", default: false)
     static let expandChapters = Key<Bool>("expandChapters", default: true)
     static let showRelated = Key<Bool>("showRelated", default: true)
     static let showInspector = Key<ShowInspectorSetting>("showInspector", default: .onlyLocal)
@@ -93,12 +94,9 @@ extension Defaults.Keys {
     static let enableReturnYouTubeDislike = Key<Bool>("enableReturnYouTubeDislike", default: false)
 
     #if os(iOS)
-        static let honorSystemOrientationLock = Key<Bool>("honorSystemOrientationLock", default: true)
-        static let enterFullscreenInLandscape = Key<Bool>("enterFullscreenInLandscape", default: UIDevice.current.userInterfaceIdiom == .phone)
-        static let rotateToLandscapeOnEnterFullScreen = Key<FullScreenRotationSetting>(
-            "rotateToLandscapeOnEnterFullScreen",
-            default: UIDevice.current.userInterfaceIdiom == .phone ? .landscapeRight : .disabled
-        )
+        static let isOrientationLocked = Key<Bool>("isOrientationLocked", default: Constants.isIPhone)
+        static let enterFullscreenInLandscape = Key<Bool>("enterFullscreenInLandscape", default: Constants.isIPhone)
+        static let rotateToLandscapeOnEnterFullScreen = Key<FullScreenRotationSetting>("rotateToLandscapeOnEnterFullScreen", default: .landscapeRight)
     #endif
 
     static let closePiPOnNavigation = Key<Bool>("closePiPOnNavigation", default: false)
@@ -116,14 +114,14 @@ extension Defaults.Keys {
 
     // MARK: GROUP - Controls
 
-    static let avPlayerUsesSystemControls = Key<Bool>("avPlayerUsesSystemControls", default: true)
+    static let avPlayerUsesSystemControls = Key<Bool>("avPlayerUsesSystemControls", default: Constants.isTvOS)
     static let horizontalPlayerGestureEnabled = Key<Bool>("horizontalPlayerGestureEnabled", default: true)
     static let seekGestureSensitivity = Key<Double>("seekGestureSensitivity", default: 30.0)
     static let seekGestureSpeed = Key<Double>("seekGestureSpeed", default: 0.5)
 
     #if os(iOS)
-        static let playerControlsLayoutDefault = UIDevice.current.userInterfaceIdiom == .pad ? PlayerControlsLayout.medium : .small
-        static let fullScreenPlayerControlsLayoutDefault = UIDevice.current.userInterfaceIdiom == .pad ? PlayerControlsLayout.medium : .small
+        static let playerControlsLayoutDefault = Constants.isIPad ? PlayerControlsLayout.medium : .small
+        static let fullScreenPlayerControlsLayoutDefault = Constants.isIPad ? PlayerControlsLayout.medium : .small
     #elseif os(tvOS)
         static let playerControlsLayoutDefault = PlayerControlsLayout.tvRegular
         static let fullScreenPlayerControlsLayoutDefault = PlayerControlsLayout.tvRegular
@@ -134,6 +132,7 @@ extension Defaults.Keys {
 
     static let playerControlsLayout = Key<PlayerControlsLayout>("playerControlsLayout", default: playerControlsLayoutDefault)
     static let fullScreenPlayerControlsLayout = Key<PlayerControlsLayout>("fullScreenPlayerControlsLayout", default: fullScreenPlayerControlsLayoutDefault)
+    static let playerControlsBackgroundOpacity = Key<Double>("playerControlsBackgroundOpacity", default: 0.2)
 
     static let systemControlsCommands = Key<SystemControlsCommands>("systemControlsCommands", default: .restartAndAdvanceToNext)
 
@@ -175,61 +174,152 @@ extension Defaults.Keys {
 
     // MARK: GROUP - Quality
 
-    static let hd2160pMPVProfile = QualityProfile(id: "hd2160pMPVProfile", backend: .mpv, resolution: .hd2160p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
-    static let hd1080pMPVProfile = QualityProfile(id: "hd1080pMPVProfile", backend: .mpv, resolution: .hd1080p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
-    static let hd720pMPVProfile = QualityProfile(id: "hd720pMPVProfile", backend: .mpv, resolution: .hd720p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
-    static let hd720pAVPlayerProfile = QualityProfile(id: "hd720pAVPlayerProfile", backend: .appleAVPlayer, resolution: .hd720p30, formats: [.hls, .stream], order: Array(QualityProfile.Format.allCases.indices))
-    static let sd360pAVPlayerProfile = QualityProfile(id: "sd360pAVPlayerProfile", backend: .appleAVPlayer, resolution: .sd360p30, formats: [.hls, .stream], order: Array(QualityProfile.Format.allCases.indices))
+    static let hd2160p60MPVProfile = QualityProfile(id: "hd2160p60MPVProfile", backend: .mpv, resolution: .hd2160p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let hd1080p60MPVProfile = QualityProfile(id: "hd1080p60MPVProfile", backend: .mpv, resolution: .hd1080p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let hd1080pMPVProfile = QualityProfile(id: "hd1080pMPVProfile", backend: .mpv, resolution: .hd1080p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let hd720p60MPVProfile = QualityProfile(id: "hd720p60MPVProfile", backend: .mpv, resolution: .hd720p60, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let hd720pMPVProfile = QualityProfile(id: "hd720pMPVProfile", backend: .mpv, resolution: .hd720p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let sd360pMPVProfile = QualityProfile(id: "sd360pMPVProfile", backend: .mpv, resolution: .sd360p30, formats: QualityProfile.Format.allCases, order: Array(QualityProfile.Format.allCases.indices))
+    static let hd720pAVPlayerProfile = QualityProfile(id: "hd720pAVPlayerProfile", backend: .appleAVPlayer, resolution: .hd720p30, formats: [.stream, .hls], order: Array(QualityProfile.Format.allCases.indices))
+    static let sd360pAVPlayerProfile = QualityProfile(id: "sd360pAVPlayerProfile", backend: .appleAVPlayer, resolution: .sd360p30, formats: [.stream, .hls], order: Array(QualityProfile.Format.allCases.indices))
 
     #if os(iOS)
-        static let qualityProfilesDefault = UIDevice.current.userInterfaceIdiom == .pad ? [
-            hd2160pMPVProfile,
-            hd1080pMPVProfile,
-            hd720pMPVProfile,
-            hd720pAVPlayerProfile,
-            sd360pAVPlayerProfile
-        ] : [
-            hd1080pMPVProfile,
-            hd720pMPVProfile,
-            hd720pAVPlayerProfile,
-            sd360pAVPlayerProfile
-        ]
+        enum QualityProfiles {
+            // iPad-specific settings
+            enum iPad {
+                static let qualityProfilesDefault = [
+                    hd1080p60MPVProfile,
+                    hd1080pMPVProfile,
+                    hd720p60MPVProfile,
+                    hd720pMPVProfile
+                ]
+
+                static let batteryCellularProfileDefault = hd720pMPVProfile.id
+                static let batteryNonCellularProfileDefault = hd720p60MPVProfile.id
+                static let chargingCellularProfileDefault = hd1080pMPVProfile.id
+                static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
+            }
+
+            // iPhone-specific settings
+            enum iPhone {
+                static let qualityProfilesDefault = [
+                    hd1080p60MPVProfile,
+                    hd1080pMPVProfile,
+                    hd720p60MPVProfile,
+                    hd720pMPVProfile,
+                    sd360pMPVProfile
+                ]
+
+                static let batteryCellularProfileDefault = sd360pMPVProfile.id
+                static let batteryNonCellularProfileDefault = hd720p60MPVProfile.id
+                static let chargingCellularProfileDefault = hd720pMPVProfile.id
+                static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
+            }
+
+            // Access the correct profile based on device type
+            static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
+                if Constants.isIPad {
+                    return (
+                        qualityProfilesDefault: iPad.qualityProfilesDefault,
+                        batteryCellularProfileDefault: iPad.batteryCellularProfileDefault,
+                        batteryNonCellularProfileDefault: iPad.batteryNonCellularProfileDefault,
+                        chargingCellularProfileDefault: iPad.chargingCellularProfileDefault,
+                        chargingNonCellularProfileDefault: iPad.chargingNonCellularProfileDefault
+                    )
+                }
+
+                return (
+                    qualityProfilesDefault: iPhone.qualityProfilesDefault,
+                    batteryCellularProfileDefault: iPhone.batteryCellularProfileDefault,
+                    batteryNonCellularProfileDefault: iPhone.batteryNonCellularProfileDefault,
+                    chargingCellularProfileDefault: iPhone.chargingCellularProfileDefault,
+                    chargingNonCellularProfileDefault: iPhone.chargingNonCellularProfileDefault
+                )
+            }
+        }
 
-        static let batteryCellularProfileDefault = hd720pAVPlayerProfile.id
-        static let batteryNonCellularProfileDefault = hd720pAVPlayerProfile.id
-        static let chargingCellularProfileDefault = hd720pAVPlayerProfile.id
-        static let chargingNonCellularProfileDefault = hd1080pMPVProfile.id
     #elseif os(tvOS)
-        static let qualityProfilesDefault = [
-            hd2160pMPVProfile,
-            hd1080pMPVProfile,
-            hd720pMPVProfile,
-            hd720pAVPlayerProfile
-        ]
-        static let batteryCellularProfileDefault = hd1080pMPVProfile.id
-        static let batteryNonCellularProfileDefault = hd1080pMPVProfile.id
-        static let chargingCellularProfileDefault = hd1080pMPVProfile.id
-        static let chargingNonCellularProfileDefault = hd1080pMPVProfile.id
+        enum QualityProfiles {
+            // tvOS-specific settings
+            enum tvOS {
+                static let qualityProfilesDefault = [
+                    hd2160p60MPVProfile,
+                    hd1080p60MPVProfile,
+                    hd720p60MPVProfile,
+                    hd720pAVPlayerProfile
+                ]
+
+                static let batteryCellularProfileDefault = hd1080p60MPVProfile.id
+                static let batteryNonCellularProfileDefault = hd1080p60MPVProfile.id
+                static let chargingCellularProfileDefault = hd1080p60MPVProfile.id
+                static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
+            }
+
+            // Access the correct profile based on device type
+            static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
+                (
+                    qualityProfilesDefault: tvOS.qualityProfilesDefault,
+                    batteryCellularProfileDefault: tvOS.batteryCellularProfileDefault,
+                    batteryNonCellularProfileDefault: tvOS.batteryNonCellularProfileDefault,
+                    chargingCellularProfileDefault: tvOS.chargingCellularProfileDefault,
+                    chargingNonCellularProfileDefault: tvOS.chargingNonCellularProfileDefault
+                )
+            }
+        }
     #else
-        static let qualityProfilesDefault = [
-            hd2160pMPVProfile,
-            hd1080pMPVProfile,
-            hd720pMPVProfile,
-            hd720pAVPlayerProfile
-        ]
-        static let batteryCellularProfileDefault = hd1080pMPVProfile.id
-        static let batteryNonCellularProfileDefault = hd1080pMPVProfile.id
-        static let chargingCellularProfileDefault = hd1080pMPVProfile.id
-        static let chargingNonCellularProfileDefault = hd1080pMPVProfile.id
+        enum QualityProfiles {
+            // macOS-specific settings
+            enum macOS {
+                static let qualityProfilesDefault = [
+                    hd2160p60MPVProfile,
+                    hd1080p60MPVProfile,
+                    hd1080pMPVProfile,
+                    hd720p60MPVProfile
+                ]
+
+                static let batteryCellularProfileDefault = hd1080p60MPVProfile.id
+                static let batteryNonCellularProfileDefault = hd1080p60MPVProfile.id
+                static let chargingCellularProfileDefault = hd1080p60MPVProfile.id
+                static let chargingNonCellularProfileDefault = hd1080p60MPVProfile.id
+            }
+
+            // Access the correct profile for other platforms
+            static var currentProfile: (qualityProfilesDefault: [QualityProfile], batteryCellularProfileDefault: String, batteryNonCellularProfileDefault: String, chargingCellularProfileDefault: String, chargingNonCellularProfileDefault: String) {
+                (
+                    qualityProfilesDefault: macOS.qualityProfilesDefault,
+                    batteryCellularProfileDefault: macOS.batteryCellularProfileDefault,
+                    batteryNonCellularProfileDefault: macOS.batteryNonCellularProfileDefault,
+                    chargingCellularProfileDefault: macOS.chargingCellularProfileDefault,
+                    chargingNonCellularProfileDefault: macOS.chargingNonCellularProfileDefault
+                )
+            }
+        }
     #endif
 
-    static let batteryCellularProfile = Key<QualityProfile.ID>("batteryCellularProfile", default: batteryCellularProfileDefault)
-    static let batteryNonCellularProfile = Key<QualityProfile.ID>("batteryNonCellularProfile", default: batteryNonCellularProfileDefault)
-    static let chargingCellularProfile = Key<QualityProfile.ID>("chargingCellularProfile", default: chargingCellularProfileDefault)
-    static let chargingNonCellularProfile = Key<QualityProfile.ID>("chargingNonCellularProfile", default: chargingNonCellularProfileDefault)
-    static let forceAVPlayerForLiveStreams = Key<Bool>("forceAVPlayerForLiveStreams", default: true)
-
-    static let qualityProfiles = Key<[QualityProfile]>("qualityProfiles", default: qualityProfilesDefault)
+    static let batteryCellularProfile = Key<QualityProfile.ID>(
+        "batteryCellularProfile",
+        default: QualityProfiles.currentProfile.batteryCellularProfileDefault
+    )
+    static let batteryNonCellularProfile = Key<QualityProfile.ID>(
+        "batteryNonCellularProfile",
+        default: QualityProfiles.currentProfile.batteryNonCellularProfileDefault
+    )
+    static let chargingCellularProfile = Key<QualityProfile.ID>(
+        "chargingCellularProfile",
+        default: QualityProfiles.currentProfile.chargingCellularProfileDefault
+    )
+    static let chargingNonCellularProfile = Key<QualityProfile.ID>(
+        "chargingNonCellularProfile",
+        default: QualityProfiles.currentProfile.chargingNonCellularProfileDefault
+    )
+    static let forceAVPlayerForLiveStreams = Key<Bool>(
+        "forceAVPlayerForLiveStreams",
+        default: true
+    )
+    static let qualityProfiles = Key<[QualityProfile]>(
+        "qualityProfiles",
+        default: QualityProfiles.currentProfile.qualityProfilesDefault
+    )
 
     // MARK: GROUP - History
 
@@ -269,6 +359,7 @@ extension Defaults.Keys {
     // MARK: Group - Advanced
 
     static let showPlayNowInBackendContextMenu = Key<Bool>("showPlayNowInBackendContextMenu", default: false)
+    static let videoLoadingRetryCount = Key<Int>("videoLoadingRetryCount", default: 10)
 
     static let showMPVPlaybackStats = Key<Bool>("showMPVPlaybackStats", default: false)
     static let mpvEnableLogging = Key<Bool>("mpvEnableLogging", default: false)
@@ -279,6 +370,7 @@ extension Defaults.Keys {
     static let mpvHWdec = Key<String>("hwdec", default: "auto-safe")
     static let mpvDemuxerLavfProbeInfo = Key<String>("mpvDemuxerLavfProbeInfo", default: "no")
     static let mpvInitialAudioSync = Key<Bool>("mpvInitialAudioSync", default: true)
+    static let mpvSetRefreshToContentFPS = Key<Bool>("mpvSetRefreshToContentFPS", default: false)
 
     static let showCacheStatus = Key<Bool>("showCacheStatus", default: false)
     static let feedCacheSize = Key<String>("feedCacheSize", default: "50")
@@ -335,18 +427,34 @@ enum ResolutionSetting: String, CaseIterable, Defaults.Serializable {
     case sd240p30
     case sd144p30
 
-    var value: Stream.Resolution! {
-        .init(rawValue: rawValue)
+    var value: Stream.Resolution {
+        if let predefined = Stream.Resolution.PredefinedResolution(rawValue: rawValue) {
+            return .predefined(predefined)
+        }
+        // Provide a default value of 720p 30
+        return .custom(height: 720, refreshRate: 30)
     }
 
     var description: String {
-        switch self {
-        case .hd2160p60:
-            return "4K, 60fps"
-        case .hd2160p30:
-            return "4K"
+        let resolution = value
+        let height = resolution.height
+        let refreshRate = resolution.refreshRate
+
+        // Superscript labels
+        let superscript4K = "⁴ᴷ"
+        let superscriptHD = "ᴴᴰ"
+
+        // Special handling for specific resolutions
+        switch height {
+        case 2160:
+            // 4K superscript after the refresh rate
+            return refreshRate == 30 ? "2160p \(superscript4K)" : "2160p\(refreshRate) \(superscript4K)"
+        case 1440, 1080:
+            // HD superscript after the refresh rate
+            return refreshRate == 30 ? "\(height)p \(superscriptHD)" : "\(height)p\(refreshRate) \(superscriptHD)"
         default:
-            return value.name
+            // Default formatting for other resolutions
+            return refreshRate == 30 ? "\(height)p" : "\(height)p\(refreshRate)"
         }
     }
 }
@@ -521,26 +629,19 @@ enum PlayerTapGestureAction: String, CaseIterable, Defaults.Serializable {
 }
 
 enum FullScreenRotationSetting: String, CaseIterable, Defaults.Serializable {
-    case disabled
     case landscapeLeft
     case landscapeRight
 
     #if os(iOS)
-        var interaceOrientation: UIInterfaceOrientation {
+        var interfaceOrientation: UIInterfaceOrientation {
             switch self {
             case .landscapeLeft:
                 return .landscapeLeft
             case .landscapeRight:
                 return .landscapeRight
-            default:
-                return .portrait
             }
         }
     #endif
-
-    var isRotating: Bool {
-        self != .disabled
-    }
 }
 
 struct WidgetSettings: Defaults.Serializable {

Shared/Home/HomeView.swift

@@ -152,7 +152,7 @@ struct HomeView: View {
         #endif
         #if os(macOS)
         .background(Color.secondaryBackground)
-        .frame(minWidth: 360)
+        .frame(minWidth: Constants.contentViewMinWidth)
         .toolbar {
             ToolbarItemGroup(placement: .automatic) {
                 HideWatchedButtons()

Shared/Navigation/ContentView.swift

@@ -169,7 +169,7 @@ struct ContentView: View {
             .statusBarHidden(player.playingFullScreen)
         #endif
         #if os(macOS)
-        .frame(minWidth: 1200)
+        .frame(minWidth: 1200, minHeight: 600)
         #endif
     }
 

Shared/Player/AppleAVPlayerView.swift

@@ -4,11 +4,6 @@ import SwiftUI
 
 #if !os(macOS)
     final class AppleAVPlayerViewControllerDelegate: NSObject, AVPlayerViewControllerDelegate {
-        #if os(iOS)
-            @Default(.rotateToLandscapeOnEnterFullScreen) private var rotateToLandscapeOnEnterFullScreen
-            @Default(.avPlayerUsesSystemControls) private var avPlayerUsesSystemControls
-        #endif
-
         var player: PlayerModel { .shared }
 
         func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(_: AVPlayerViewController) -> Bool {
@@ -17,15 +12,23 @@ import SwiftUI
 
         #if os(iOS)
             func playerViewController(_: AVPlayerViewController, willBeginFullScreenPresentationWithAnimationCoordinator _: UIViewControllerTransitionCoordinator) {
-                guard rotateToLandscapeOnEnterFullScreen.isRotating else { return }
-                if PlayerModel.shared.currentVideoIsLandscape {
-                    let delay = PlayerModel.shared.activeBackend == .appleAVPlayer && avPlayerUsesSystemControls ? 0.8 : 0
-                    // not sure why but first rotation call is ignore so doing rotate to same orientation first
-                    Delay.by(delay) {
-                        let orientation = OrientationTracker.shared.currentDeviceOrientation.isLandscape ? OrientationTracker.shared.currentInterfaceOrientation : self.rotateToLandscapeOnEnterFullScreen.interaceOrientation
-                        Orientation.lockOrientation(.allButUpsideDown, andRotateTo: OrientationTracker.shared.currentInterfaceOrientation)
-                        Orientation.lockOrientation(.allButUpsideDown, andRotateTo: orientation)
+                let lockOrientation = player.rotateToLandscapeOnEnterFullScreen.interfaceOrientation
+                if player.currentVideoIsLandscape {
+                    if player.fullscreenInitiatedByButton {
+                        Orientation.lockOrientation(player.isOrientationLocked
+                            ? (lockOrientation == .landscapeRight ? .landscapeRight : .landscapeLeft)
+                            : .landscape)
                     }
+                    let orientation = OrientationTracker.shared.currentDeviceOrientation.isLandscape
+                        ? OrientationTracker.shared.currentInterfaceOrientation
+                        : player.rotateToLandscapeOnEnterFullScreen.interfaceOrientation
+
+                    Orientation.lockOrientation(
+                        player.isOrientationLocked
+                            ? (lockOrientation == .landscapeRight ? .landscapeRight : .landscapeLeft)
+                            : .all,
+                        andRotateTo: orientation
+                    )
                 }
             }
 
@@ -37,11 +40,11 @@ import SwiftUI
                     }
                     if !context.isCancelled {
                         #if os(iOS)
-                            self.player.lockedOrientation = nil
-
-                            if Constants.isIPhone {
-                                Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
+                            if self.player.lockPortraitWhenBrowsing {
+                                self.player.lockedOrientation = UIInterfaceOrientationMask.portrait
                             }
+                            let rotationOrientation = self.player.lockPortraitWhenBrowsing ? UIInterfaceOrientation.portrait : nil
+                            Orientation.lockOrientation(self.player.lockPortraitWhenBrowsing ? .portrait : .all, andRotateTo: rotationOrientation)
 
                             if wasPlaying {
                                 self.player.play()

Shared/Player/Controls/PlayerControls.swift

@@ -29,6 +29,7 @@ struct PlayerControls: View {
 
     @Default(.playerControlsLayout) private var regularPlayerControlsLayout
     @Default(.fullScreenPlayerControlsLayout) private var fullScreenPlayerControlsLayout
+    @Default(.playerControlsBackgroundOpacity) private var playerControlsBackgroundOpacity
     @Default(.buttonBackwardSeekDuration) private var buttonBackwardSeekDuration
     @Default(.buttonForwardSeekDuration) private var buttonForwardSeekDuration
 
@@ -248,31 +249,36 @@ struct PlayerControls: View {
         return [player.playerSize.height - inset, 500].min()!
     }
 
-    @ViewBuilder var controlsBackground: some View {
-        ZStack {
-            if player.musicMode,
-               let url = controlsBackgroundURL
-            {
-                ThumbnailView(url: url)
-                    .frame(maxWidth: .infinity, maxHeight: .infinity)
-                    .transition(.opacity)
-                    .animation(.default)
-            } else if player.videoForDisplay == nil {
-                Color.black
+    @ViewBuilder
+    var controlsBackground: some View {
+        GeometryReader { geometry in
+            ZStack {
+                if player.musicMode,
+                   let video = player.videoForDisplay
+                {
+                    let thumbnail = thumbnails.best(video)
+                    if let url = thumbnail.url,
+                       let quality = thumbnail.quality
+                    {
+                        let aspectRatio = (quality == .default || quality == .high) ? Constants.aspectRatio4x3 : Constants.aspectRatio16x9
+
+                        ThumbnailView(url: url)
+                            .aspectRatio(aspectRatio, contentMode: .fill)
+                            .frame(width: geometry.size.width, height: geometry.size.height)
+                            .transition(.opacity)
+                            .animation(.default)
+                            .clipped()
+                    }
+                } else if player.videoForDisplay == nil {
+                    Color.black
+                } else if model.presentingControls {
+                    Color.black.opacity(playerControlsBackgroundOpacity)
+                        .edgesIgnoringSafeArea(.all)
+                }
             }
         }
     }
 
-    var controlsBackgroundURL: URL? {
-        if let video = player.videoForDisplay,
-           let url = thumbnails.best(video).url
-        {
-            return url
-        }
-
-        return nil
-    }
-
     var timeline: some View {
         TimelineView(context: .player).foregroundColor(.primary)
     }
@@ -381,13 +387,13 @@ struct PlayerControls: View {
     }
 
     private var pipButton: some View {
-        button("PiP", systemImage: player.pipImage, action: player.togglePiPAction)
+        button("PiP", systemImage: player.pipImage, active: player.playingInPictureInPicture, action: player.togglePiPAction)
             .disabled(!player.pipPossible)
     }
 
     #if os(iOS)
         private var lockOrientationButton: some View {
-            button("Lock Rotation", systemImage: player.lockOrientationImage, active: !player.lockedOrientation.isNil, action: player.lockOrientationAction)
+            button("Lock Rotation", systemImage: player.lockOrientationImage, active: player.isOrientationLocked, action: player.lockOrientationAction)
         }
     #endif
 

Shared/Player/MPV/MPVOGLView.swift

@@ -6,9 +6,10 @@ import OpenGLES
 final class MPVOGLView: GLKView {
     private var logger = Logger(label: "stream.yattee.mpv.oglview")
     private var defaultFBO: GLint?
+    private var displayLink: CADisplayLink?
 
     var mpvGL: UnsafeMutableRawPointer?
-    var queue = DispatchQueue(label: "stream.yattee.opengl")
+    var queue = DispatchQueue(label: "stream.yattee.opengl", qos: .userInteractive)
     var needsDrawing = true
 
     override init(frame: CGRect) {
@@ -29,6 +30,69 @@ final class MPVOGLView: GLKView {
         enableSetNeedsDisplay = false
 
         fillBlack()
+        setupDisplayLink()
+        setupNotifications()
+    }
+
+    required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        setupDisplayLink()
+        setupNotifications()
+    }
+
+    private func setupDisplayLink() {
+        displayLink = CADisplayLink(target: self, selector: #selector(updateFrame))
+        displayLink?.add(to: .main, forMode: .common)
+    }
+
+    // Set up observers to detect display changes and custom refresh rate updates.
+    private func setupNotifications() {
+        NotificationCenter.default.addObserver(self, selector: #selector(updateDisplayLinkFromNotification(_:)), name: .updateDisplayLinkFrameRate, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(screenDidChange), name: UIScreen.didConnectNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(screenDidChange), name: UIScreen.didDisconnectNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(screenDidChange), name: UIScreen.modeDidChangeNotification, object: nil)
+    }
+
+    @objc private func screenDidChange(_: Notification) {
+        // Update the display link refresh rate when the screen configuration changes
+        updateDisplayLinkFrameRate()
+    }
+
+    // Update the display link frame rate from the notification.
+    @objc private func updateDisplayLinkFromNotification(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let refreshRate = userInfo["refreshRate"] as? Int else { return }
+        displayLink?.preferredFramesPerSecond = refreshRate
+        logger.info("Updated CADisplayLink frame rate to: \(refreshRate) from backend notification.")
+    }
+
+    // Update the display link's preferred frame rate based on the current screen refresh rate.
+    private func updateDisplayLinkFrameRate() {
+        guard let displayLink else { return }
+        let refreshRate = getScreenRefreshRate()
+        displayLink.preferredFramesPerSecond = refreshRate
+        logger.info("Updated CADisplayLink preferred frames per second to: \(refreshRate)")
+    }
+
+    // Retrieve the screen's current refresh rate dynamically.
+    private func getScreenRefreshRate() -> Int {
+        // Use the main screen's maximumFramesPerSecond property
+        let refreshRate = UIScreen.main.maximumFramesPerSecond
+        logger.info("Screen refresh rate: \(refreshRate) Hz")
+        return refreshRate
+    }
+
+    @objc private func updateFrame() {
+        // Trigger the drawing process if needed
+        if needsDrawing {
+            setNeedsDisplay()
+        }
+    }
+
+    deinit {
+        // Invalidate the display link and remove observers to avoid memory leaks
+        displayLink?.invalidate()
+        NotificationCenter.default.removeObserver(self)
     }
 
     func fillBlack() {
@@ -37,35 +101,40 @@ final class MPVOGLView: GLKView {
     }
 
     override func draw(_: CGRect) {
-        guard needsDrawing, let mpvGL else {
-            return
-        }
+        guard needsDrawing, let mpvGL else { return }
 
+        // Bind the default framebuffer
         glGetIntegerv(UInt32(GL_FRAMEBUFFER_BINDING), &defaultFBO!)
 
+        // Get the current viewport dimensions
         var dims: [GLint] = [0, 0, 0, 0]
         glGetIntegerv(GLenum(GL_VIEWPORT), &dims)
 
+        // Set up the OpenGL FBO data
         var data = mpv_opengl_fbo(
             fbo: Int32(defaultFBO!),
             w: Int32(dims[2]),
             h: Int32(dims[3]),
             internal_format: 0
         )
+
+        // Flip Y coordinate for proper rendering
         var flip: CInt = 1
-        withUnsafeMutablePointer(to: &flip) { flip in
-            withUnsafeMutablePointer(to: &data) { data in
+
+        // Render with the provided OpenGL FBO parameters
+        withUnsafeMutablePointer(to: &flip) { flipPtr in
+            withUnsafeMutablePointer(to: &data) { dataPtr in
                 var params = [
-                    mpv_render_param(type: MPV_RENDER_PARAM_OPENGL_FBO, data: data),
-                    mpv_render_param(type: MPV_RENDER_PARAM_FLIP_Y, data: flip),
+                    mpv_render_param(type: MPV_RENDER_PARAM_OPENGL_FBO, data: dataPtr),
+                    mpv_render_param(type: MPV_RENDER_PARAM_FLIP_Y, data: flipPtr),
                     mpv_render_param()
                 ]
                 mpv_render_context_render(OpaquePointer(mpvGL), &params)
             }
         }
     }
-
-    required init?(coder aDecoder: NSCoder) {
-        super.init(coder: aDecoder)
-    }
+}
+
+extension Notification.Name {
+    static let updateDisplayLinkFrameRate = Notification.Name("updateDisplayLinkFrameRate")
 }

Shared/Player/PlayerBackendView.swift

@@ -43,7 +43,7 @@ struct PlayerBackendView: View {
                 Color.clear
                     .onAppear { player.playerSize = proxy.size }
                     .onChange(of: proxy.size) { _ in player.playerSize = proxy.size }
-                    .onChange(of: player.controls.presentingOverlays) { _ in player.playerSize = proxy.size }
+                    .onChange(of: player.currentItem?.id) { _ in player.playerSize = proxy.size }
             })
 
             #if !os(tvOS)

Shared/Player/PlayerDragGesture.swift

@@ -8,7 +8,7 @@ extension VideoPlayerView {
             .updating($dragGestureOffset) { value, state, _ in
                 guard isVerticalDrag else { return }
                 var translation = value.translation
-                translation.height = max(0, translation.height)
+                translation.height = max(-translation.height, translation.height)
                 state = translation
             }
         #endif
@@ -18,7 +18,8 @@ extension VideoPlayerView {
             .onChanged { value in
                 guard player.presentingPlayer,
                       !controlsOverlayModel.presenting,
-                      dragGestureState else { return }
+                      dragGestureState,
+                      !disableToggleGesture else { return }
 
                 if player.controls.presentingControls, !player.musicMode {
                     player.controls.presentingControls = false
@@ -55,47 +56,83 @@ extension VideoPlayerView {
                             player.seek.gestureStart = time
                         }
                         let timeSeek = (time / player.playerSize.width) * horizontalDrag * seekGestureSpeed
-
                         player.seek.gestureSeek = timeSeek
                     }
                     return
                 }
 
-                guard verticalDrag > 0 else { return }
-                viewDragOffset = verticalDrag
-
-                if verticalDrag > 60,
-                   player.playingFullScreen
-                {
-                    player.exitFullScreen(showControls: false)
-                    #if os(iOS)
-                        if Constants.isIPhone {
-                            Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
-                        }
-                    #endif
+                // Toggle fullscreen on upward drag only when not disabled
+                if verticalDrag < -50 {
+                    player.toggleFullScreenAction()
+                    disableGestureTemporarily()
+                    return
                 }
+
+                // Ignore downward swipes when in fullscreen
+                guard verticalDrag > 0 && !player.playingFullScreen else {
+                    return
+                }
+                viewDragOffset = verticalDrag
             }
             .onEnded { _ in
                 onPlayerDragGestureEnded()
             }
     }
 
+    var detailsDragGesture: some Gesture {
+        DragGesture(minimumDistance: 30)
+            .onChanged { value in
+                handleDetailsDragChange(value)
+            }
+            .onEnded { value in
+                handleDetailsDragEnd(value)
+            }
+    }
+
+    private func handleDetailsDragChange(_ value: DragGesture.Value) {
+        let maxOffset = -player.playerSize.height
+
+        // Continuous drag update for smooth movement of VideoDetails
+        if fullScreenDetails {
+            // Allow only downward dragging when in fullscreen
+            if value.translation.height > 0 {
+                detailViewDragOffset = min(value.translation.height, abs(maxOffset))
+            }
+        } else {
+            // Allow only upward dragging when not in fullscreen
+            if value.translation.height < 0 {
+                detailViewDragOffset = max(value.translation.height, maxOffset)
+            }
+        }
+    }
+
+    private func handleDetailsDragEnd(_ value: DragGesture.Value) {
+        if value.translation.height < -50, !fullScreenDetails {
+            // Swipe up to enter fullscreen
+            withAnimation(Constants.overlayAnimation) {
+                fullScreenDetails = true
+                detailViewDragOffset = 0
+            }
+        } else if value.translation.height > 50, fullScreenDetails {
+            // Swipe down to exit fullscreen
+            withAnimation(Constants.overlayAnimation) {
+                fullScreenDetails = false
+                detailViewDragOffset = 0
+            }
+        } else {
+            // Reset offset if drag was not significant
+            withAnimation(Constants.overlayAnimation) {
+                detailViewDragOffset = 0
+            }
+        }
+    }
+
     func onPlayerDragGestureEnded() {
         if horizontalPlayerGestureEnabled, isHorizontalDrag {
             isHorizontalDrag = false
             player.seek.onSeekGestureEnd()
         }
 
-        if viewDragOffset > 60,
-           player.playingFullScreen
-        {
-            #if os(iOS)
-                player.lockedOrientation = nil
-            #endif
-            player.exitFullScreen(showControls: false)
-            viewDragOffset = 0
-            return
-        }
         isVerticalDrag = false
 
         guard player.presentingPlayer,
@@ -117,4 +154,11 @@ extension VideoPlayerView {
             }
         }
     }
+
+    private func disableGestureTemporarily() {
+        disableToggleGesture = true
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
+            disableToggleGesture = false
+        }
+    }
 }

Shared/Player/Video Details/VideoActions.swift

@@ -155,10 +155,10 @@ struct VideoActions: View {
                 case .fullScreen:
                     actionButton("Fullscreen", systemImage: player.fullscreenImage, action: player.toggleFullScreenAction)
                 case .pip:
-                    actionButton("PiP", systemImage: player.pipImage, action: player.togglePiPAction)
+                    actionButton("PiP", systemImage: player.pipImage, active: player.playingInPictureInPicture, action: player.togglePiPAction)
                 #if os(iOS)
                     case .lockOrientation:
-                        actionButton("Lock", systemImage: player.lockOrientationImage, active: player.lockedOrientation != nil, action: player.lockOrientationAction)
+                        actionButton("Lock", systemImage: player.lockOrientationImage, active: player.isOrientationLocked, action: player.lockOrientationAction)
                 #endif
                 case .restart:
                     actionButton("Replay", systemImage: "backward.end.fill", action: player.replayAction)

Shared/Player/Video Details/VideoDetails.swift

@@ -223,7 +223,7 @@ struct VideoDetails: View {
             .frame(maxWidth: .infinity, alignment: .leading)
             .contentShape(Rectangle())
             .padding(.horizontal, 16)
-            // swiftlint:disable trailing_closure
+
             // TODO: when setting tvOS minimum to 16, the platform modifier can be removed
             #if !os(tvOS)
                 .simultaneousGesture( // Simultaneous gesture to prioritize button tap
@@ -234,7 +234,7 @@ struct VideoDetails: View {
                     }
                 )
             #endif
-            // swiftlint:enable trailing_closure
+
             if VideoActions().isAnyActionVisible() {
                 VideoActions(video: player.videoForDisplay)
                     .padding(.vertical, 5)

Shared/Player/VideoPlayerView.swift

@@ -24,13 +24,12 @@ struct VideoPlayerView: View {
         #if os(macOS)
             335
         #else
-            200
+            140
         #endif
     }
 
     @State private var playerSize: CGSize = .zero { didSet { updateSidebarQueue() } }
     @State private var hoveringPlayer = false
-    @State private var fullScreenDetails = false
     @State private var sidebarQueue = defaultSidebarQueueValue
 
     @Environment(\.colorScheme) private var colorScheme
@@ -47,11 +46,20 @@ struct VideoPlayerView: View {
     #if !os(tvOS)
         @GestureState var dragGestureState = false
         @GestureState var dragGestureOffset = CGSize.zero
-        @State var isHorizontalDrag = false // swiftlint:disable:this swiftui_state_private
-        @State var isVerticalDrag = false // swiftlint:disable:this swiftui_state_private
-        @State var viewDragOffset = Self.hiddenOffset // swiftlint:disable:this swiftui_state_private
+        // swiftlint:disable private_swiftui_state
+        @State var isHorizontalDrag = false
+        @State var isVerticalDrag = false
+        @State var viewDragOffset = Self.hiddenOffset
+        @State var detailViewDragOffset: Double = 0
+        // swiftlint:enable private_swiftui_state
+
     #endif
 
+    // swiftlint:disable private_swiftui_state
+    @State var disableToggleGesture = false
+    @State var fullScreenDetails = false
+    // swiftlint:enable private_swiftui_state
+
     @ObservedObject var player = PlayerModel.shared // swiftlint:disable:this swiftui_state_private
 
     #if os(macOS)
@@ -104,9 +112,6 @@ struct VideoPlayerView: View {
                 .onChange(of: geometry.size) { _ in
                     self.playerSize = geometry.size
                 }
-                .onChange(of: fullScreenDetails) { value in
-                    player.backend.setNeedsDrawing(!value)
-                }
             #if os(iOS)
                 .onChange(of: player.presentingPlayer) { newValue in
                     if newValue {
@@ -120,19 +125,6 @@ struct VideoPlayerView: View {
                         }
                     #endif
                     viewDragOffset = 0
-
-                    Delay.by(0.2) {
-                        orientationModel.configureOrientationUpdatesBasedOnAccelerometer()
-
-                        if let orientationMask = player.lockedOrientation {
-                            Orientation.lockOrientation(
-                                orientationMask,
-                                andRotateTo: orientationMask == .landscapeLeft ? .landscapeLeft : orientationMask == .landscapeRight ? .landscapeRight : .portrait
-                            )
-                        } else {
-                            Orientation.lockOrientation(.allButUpsideDown)
-                        }
-                    }
                 }
                 .onAnimationCompleted(for: viewDragOffset) {
                     guard !dragGestureState else { return }
@@ -306,13 +298,18 @@ struct VideoPlayerView: View {
                                 playerSize: player.playerSize,
                                 fullScreen: fullScreenDetails
                             ))
+                            #if os(macOS)
+                            // TODO: Check whether this is needed on macOS.
                             .onDisappear {
                                 if player.presentingPlayer {
                                     player.setNeedsDrawing(true)
                                 }
                             }
+                            #endif
                             .id(player.currentVideo?.cacheKey)
                             .transition(.opacity)
+                            .offset(y: detailViewDragOffset)
+                            .gesture(detailsDragGesture)
                         } else {
                             VStack {}
                         }

Shared/Search/SearchTextField.swift

@@ -1,64 +1,99 @@
-import Repeat
 import SwiftUI
 
 struct SearchTextField: View {
     private var navigation = NavigationModel.shared
     @ObservedObject private var state = SearchModel.shared
 
-    var body: some View {
-        ZStack {
-            #if os(macOS)
+    #if os(macOS)
+        var body: some View {
+            ZStack {
                 fieldBorder
-            #endif
 
-            HStack(spacing: 0) {
-                #if os(macOS)
+                HStack(spacing: 0) {
                     Image(systemName: "magnifyingglass")
                         .resizable()
                         .scaledToFill()
                         .frame(width: 12, height: 12)
-                        .padding(.horizontal, 8)
+                        .padding(.horizontal, 6)
                         .opacity(0.8)
-                #endif
-                TextField("Search...", text: $state.queryText) {
-                    state.changeQuery { query in
-                        query.query = state.queryText
-                        navigation.hideKeyboard()
-                    }
-                    RecentsModel.shared.addQuery(state.queryText)
-                }
-                .disableAutocorrection(true)
-                #if os(macOS)
-                    .frame(maxWidth: 190)
-                    .textFieldStyle(.plain)
-                #else
-                    .frame(minWidth: 200)
-                    .textFieldStyle(.roundedBorder)
-                    .padding(.horizontal, 5)
-                    .padding(.trailing, state.queryText.isEmpty ? 0 : 10)
-                #endif
 
-                if !state.queryText.isEmpty {
-                    clearButton
-                } else {
-                    #if os(macOS)
+                    GeometryReader { geometry in
+                        TextField("Search...", text: $state.queryText) {
+                            state.changeQuery { query in
+                                query.query = state.queryText
+                                navigation.hideKeyboard()
+                            }
+                            RecentsModel.shared.addQuery(state.queryText)
+                        }
+                        .disableAutocorrection(true)
+                        .frame(maxWidth: geometry.size.width - 5)
+                        .textFieldStyle(.plain)
+                        .padding(.vertical, 8)
+                        .frame(height: 27, alignment: .center)
+                    }
+
+                    if !state.queryText.isEmpty {
+                        clearButton
+                    } else {
                         clearButton
                             .opacity(0)
-                    #endif
+                    }
                 }
             }
+            .transaction { t in t.animation = nil }
         }
-        .transaction { t in t.animation = nil }
-    }
+    #else
+        var body: some View {
+            ZStack {
+                HStack {
+                    HStack(spacing: 0) {
+                        Image(systemName: "magnifyingglass")
+                            .foregroundColor(.gray)
+                            .padding(.leading, 5)
+                            .padding(.trailing, 5)
+                            .imageScale(.medium)
+
+                        TextField("Search...", text: $state.queryText) {
+                            state.changeQuery { query in
+                                query.query = state.queryText
+                                navigation.hideKeyboard()
+                            }
+                            RecentsModel.shared.addQuery(state.queryText)
+                        }
+                        .disableAutocorrection(true)
+                        .textFieldStyle(.plain)
+                        .padding(.vertical, 7)
+
+                        if !state.queryText.isEmpty {
+                            clearButton
+                                .padding(.leading, 5)
+                                .padding(.trailing, 5)
+                        }
+                    }
+                    .background(
+                        RoundedRectangle(cornerRadius: 8)
+                            .fill(Color("SearchTextFieldBackground"))
+                    )
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 8)
+                            .stroke(Color(UIColor.secondarySystemBackground), lineWidth: 1)
+                    )
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                }
+                .padding(.horizontal, 0)
+            }
+            .transaction { t in t.animation = nil }
+        }
+    #endif
 
     private var fieldBorder: some View {
         RoundedRectangle(cornerRadius: 5, style: .continuous)
             .fill(Color.background)
-            .frame(width: 250, height: 32)
+            .frame(width: 250, height: 27)
             .overlay(
                 RoundedRectangle(cornerRadius: 5, style: .continuous)
                     .stroke(Color.gray.opacity(0.4), lineWidth: 1)
-                    .frame(width: 250, height: 31)
+                    .frame(width: 250, height: 27)
             )
     }
 
@@ -67,15 +102,14 @@ struct SearchTextField: View {
             self.state.queryText = ""
         }) {
             Image(systemName: "xmark.circle.fill")
-            #if os(macOS)
-                .imageScale(.small)
-            #else
                 .imageScale(.medium)
-            #endif
         }
         .buttonStyle(PlainButtonStyle())
         #if os(macOS)
-            .padding(.trailing, 10)
+            .padding(.trailing, 5)
+        #elseif os(iOS)
+            .padding(.trailing, 5)
+            .foregroundColor(.gray)
         #endif
             .opacity(0.7)
     }

Shared/Search/SearchView.swift

@@ -30,6 +30,7 @@ struct SearchView: View {
     @Default(.saveRecents) private var saveRecents
     @Default(.showHome) private var showHome
     @Default(.searchListingStyle) private var searchListingStyle
+    @Default(.showSearchSuggestions) private var showSearchSuggestions
 
     private var videos = [Video]()
 
@@ -38,9 +39,9 @@ struct SearchView: View {
         self.videos = videos
     }
 
-    var body: some View {
-        VStack {
-            #if os(iOS)
+    #if os(iOS)
+        var body: some View {
+            VStack {
                 VStack {
                     if accounts.app.supportsSearchSuggestions, state.query.query != state.queryText {
                         SearchSuggestions()
@@ -51,27 +52,155 @@ struct SearchView: View {
                 }
                 .backport
                 .scrollDismissesKeyboardInteractively()
-            #else
+            }
+            .environment(\.listingStyle, searchListingStyle)
+            .toolbar {
+                ToolbarItem(placement: .principal) {
+                    if #available(iOS 15, *) {
+                        FocusableSearchTextField()
+                    } else {
+                        SearchTextField()
+                    }
+                }
+                ToolbarItem(placement: .navigationBarTrailing) {
+                    searchMenu
+                }
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .ignoresSafeArea(.keyboard, edges: .bottom)
+            .navigationTitle("Search")
+            .onAppear {
+                if let query {
+                    state.queryText = query.query
+                    state.resetQuery(query)
+                    updateFavoriteItem()
+                }
+
+                if !videos.isEmpty {
+                    state.store.replace(ContentItem.array(of: videos))
+                }
+            }
+            .onChange(of: accounts.current) { _ in
+                state.reloadQuery()
+            }
+            .onChange(of: state.queryText) { newQuery in
+                if newQuery.isEmpty {
+                    favoriteItem = nil
+                    state.resetQuery()
+                } else {
+                    updateFavoriteItem()
+                }
+                state.loadSuggestions(newQuery)
+            }
+            .onChange(of: searchSortOrder) { order in
+                state.changeQuery { query in
+                    query.sortBy = order
+                    updateFavoriteItem()
+                }
+            }
+            .onChange(of: searchDate) { date in
+                state.changeQuery { query in
+                    query.date = date
+                    updateFavoriteItem()
+                }
+            }
+            .onChange(of: searchDuration) { duration in
+                state.changeQuery { query in
+                    query.duration = duration
+                    updateFavoriteItem()
+                }
+            }
+        }
+
+    #elseif os(tvOS)
+        var body: some View {
+            VStack {
                 ZStack {
                     results
-
-                    #if os(macOS)
-                        if accounts.app.supportsSearchSuggestions, state.query.query != state.queryText {
-                            HStack {
-                                Spacer()
-                                SearchSuggestions()
-                                    .borderLeading(width: 1, color: Color("ControlsBorderColor"))
-                                    .frame(maxWidth: 280)
-                                    .opacity(state.queryText.isEmpty ? 0 : 1)
-                            }
-                        }
-                    #endif
                 }
-            #endif
+            }
+            .environment(\.listingStyle, searchListingStyle)
+            .onAppear {
+                if let query {
+                    state.queryText = query.query
+                    state.resetQuery(query)
+                    updateFavoriteItem()
+                }
+
+                if !videos.isEmpty {
+                    state.store.replace(ContentItem.array(of: videos))
+                }
+            }
+            .onChange(of: accounts.current) { _ in
+                state.reloadQuery()
+            }
+            .onChange(of: state.queryText) { newQuery in
+                if newQuery.isEmpty {
+                    favoriteItem = nil
+                    state.resetQuery()
+                } else {
+                    updateFavoriteItem()
+                }
+                if showSearchSuggestions {
+                    state.loadSuggestions(newQuery)
+                }
+                searchDebounce.invalidate()
+                recentsDebounce.invalidate()
+
+                searchDebounce.debouncing(2) {
+                    state.changeQuery { query in
+                        query.query = newQuery
+                    }
+                }
+
+                recentsDebounce.debouncing(10) {
+                    recents.addQuery(newQuery)
+                }
+            }
+            .onChange(of: searchSortOrder) { order in
+                state.changeQuery { query in
+                    query.sortBy = order
+                    updateFavoriteItem()
+                }
+            }
+            .onChange(of: searchDate) { date in
+                state.changeQuery { query in
+                    query.date = date
+                    updateFavoriteItem()
+                }
+            }
+            .onChange(of: searchDuration) { duration in
+                state.changeQuery { query in
+                    query.duration = duration
+                    updateFavoriteItem()
+                }
+            }
+            .searchable(text: $state.queryText) {
+                if !state.queryText.isEmpty {
+                    ForEach(state.querySuggestions, id: \.self) { suggestion in
+                        Text(suggestion)
+                            .searchCompletion(suggestion)
+                    }
+                }
+            }
         }
-        .environment(\.listingStyle, searchListingStyle)
-        .toolbar {
-            #if os(macOS)
+
+    #elseif os(macOS)
+        var body: some View {
+            ZStack {
+                results
+                if accounts.app.supportsSearchSuggestions, state.query.query != state.queryText, showSearchSuggestions {
+                    HStack {
+                        Spacer()
+                        SearchSuggestions()
+                            .borderLeading(width: 1, color: Color("ControlsBorderColor"))
+                            .frame(maxWidth: 262)
+                            .opacity(state.queryText.isEmpty ? 0 : 1)
+                    }
+                }
+            }
+            .environment(\.listingStyle, searchListingStyle)
+            .toolbar {
                 ToolbarItemGroup(placement: toolbarPlacement) {
                     ListingStyleButtons(listingStyle: $searchListingStyle)
                     HideWatchedButtons()
@@ -84,7 +213,6 @@ struct SearchView: View {
                             HStack {
                                 Text("Sort:")
                                     .foregroundColor(.secondary)
-
                                 searchSortOrderPicker
                             }
                         }
@@ -101,94 +229,52 @@ struct SearchView: View {
                         SearchTextField()
                     }
                 }
-            #endif
-        }
-        .onAppear {
-            if let query {
-                state.queryText = query.query
-                state.resetQuery(query)
-                updateFavoriteItem()
             }
-
-            if !videos.isEmpty {
-                state.store.replace(ContentItem.array(of: videos))
-            }
-        }
-        .onChange(of: accounts.current) { _ in
-            state.reloadQuery()
-        }
-        .onChange(of: state.queryText) { newQuery in
-            if newQuery.isEmpty {
-                favoriteItem = nil
-                state.resetQuery()
-            } else {
-                updateFavoriteItem()
-            }
-
-            state.loadSuggestions(newQuery)
-
-            #if os(tvOS)
-                searchDebounce.invalidate()
-                recentsDebounce.invalidate()
-
-                searchDebounce.debouncing(2) {
-                    state.changeQuery { query in
-                        query.query = newQuery
-                    }
+            .onAppear {
+                if let query {
+                    state.queryText = query.query
+                    state.resetQuery(query)
+                    updateFavoriteItem()
                 }
 
-                recentsDebounce.debouncing(10) {
-                    recents.addQuery(newQuery)
-                }
-            #endif
-        }
-        .onChange(of: searchSortOrder) { order in
-            state.changeQuery { query in
-                query.sortBy = order
-                updateFavoriteItem()
-            }
-        }
-        .onChange(of: searchDate) { date in
-            state.changeQuery { query in
-                query.date = date
-                updateFavoriteItem()
-            }
-        }
-        .onChange(of: searchDuration) { duration in
-            state.changeQuery { query in
-                query.duration = duration
-                updateFavoriteItem()
-            }
-        }
-        #if os(tvOS)
-        .searchable(text: $state.queryText) {
-            if !state.queryText.isEmpty {
-                ForEach(state.querySuggestions, id: \.self) { suggestion in
-                    Text(suggestion)
-                        .searchCompletion(suggestion)
+                if !videos.isEmpty {
+                    state.store.replace(ContentItem.array(of: videos))
                 }
             }
-        }
-        #else
-        .ignoresSafeArea(.keyboard, edges: .bottom)
-                .navigationTitle("Search")
-        #endif
-        #if os(iOS)
-        .toolbar {
-            ToolbarItem(placement: .navigationBarLeading) {
-                searchMenu
+            .onChange(of: accounts.current) { _ in
+                state.reloadQuery()
             }
-            ToolbarItem(placement: .principal) {
-                if #available(iOS 15, *) {
-                    FocusableSearchTextField()
+            .onChange(of: state.queryText) { newQuery in
+                if newQuery.isEmpty {
+                    favoriteItem = nil
+                    state.resetQuery()
                 } else {
-                    SearchTextField()
+                    updateFavoriteItem()
+                }
+                state.loadSuggestions(newQuery)
+            }
+            .onChange(of: searchSortOrder) { order in
+                state.changeQuery { query in
+                    query.sortBy = order
+                    updateFavoriteItem()
                 }
             }
+            .onChange(of: searchDate) { date in
+                state.changeQuery { query in
+                    query.date = date
+                    updateFavoriteItem()
+                }
+            }
+            .onChange(of: searchDuration) { duration in
+                state.changeQuery { query in
+                    query.duration = duration
+                    updateFavoriteItem()
+                }
+            }
+            .frame(minWidth: Constants.contentViewMinWidth)
+            .navigationTitle("Search")
         }
-        .navigationBarTitleDisplayMode(.inline)
-        #endif
-    }
+    #endif
 
     #if os(iOS)
         var searchMenu: some View {
@@ -230,11 +316,10 @@ struct SearchView: View {
                 }
             } label: {
                 HStack {
-                    Image(systemName: "magnifyingglass")
                     Image(systemName: "chevron.down.circle.fill")
+                        .foregroundColor(.accentColor)
+                        .imageScale(.large)
                 }
-                .foregroundColor(.accentColor)
-                .imageScale(.medium)
             }
         }
     #endif

Shared/Settings/AdvancedSettings.swift

@@ -11,9 +11,11 @@ struct AdvancedSettings: View {
     @Default(.mpvHWdec) private var mpvHWdec
     @Default(.mpvDemuxerLavfProbeInfo) private var mpvDemuxerLavfProbeInfo
     @Default(.mpvInitialAudioSync) private var mpvInitialAudioSync
+    @Default(.mpvSetRefreshToContentFPS) private var mpvSetRefreshToContentFPS
     @Default(.showCacheStatus) private var showCacheStatus
     @Default(.feedCacheSize) private var feedCacheSize
     @Default(.showPlayNowInBackendContextMenu) private var showPlayNowInBackendContextMenu
+    @Default(.videoLoadingRetryCount) private var videoLoadingRetryCount
 
     @State private var filesToShare = [MPVClient.logFile]
     @State private var presentingShareSheet = false
@@ -64,6 +66,7 @@ struct AdvancedSettings: View {
     @ViewBuilder var advancedSettings: some View {
         Section(header: SettingsHeader(text: "Advanced")) {
             showPlayNowInBackendButtonsToggle
+            videoLoadingRetryCountField
         }
 
         Section(header: SettingsHeader(text: "MPV"), footer: mpvFooter) {
@@ -245,6 +248,12 @@ struct AdvancedSettings: View {
                 #endif
             }
 
+            Toggle(isOn: $mpvSetRefreshToContentFPS) {
+                HStack {
+                    Text("Sync refresh rate with content FPS – EXPERIMENTAL")
+                }
+            }
+
             if mpvEnableLogging {
                 logButton
             }
@@ -281,6 +290,19 @@ struct AdvancedSettings: View {
         Toggle("Show video context menu options to force selected backend", isOn: $showPlayNowInBackendContextMenu)
     }
 
+    private var videoLoadingRetryCountField: some View {
+        HStack {
+            Text("Maximum retries for video loading")
+                .frame(minWidth: 200, alignment: .leading)
+                .multilineTextAlignment(.leading)
+            TextField("Limit", value: $videoLoadingRetryCount, formatter: NumberFormatter())
+                .multilineTextAlignment(.trailing)
+            #if !os(macOS)
+                .keyboardType(.numberPad)
+            #endif
+        }
+    }
+
     var showMPVPlaybackStatsToggle: some View {
         Toggle("Show playback statistics", isOn: $showMPVPlaybackStats)
     }

Shared/Settings/BrowsingSettings.swift

@@ -10,6 +10,7 @@ struct BrowsingSettings: View {
     @Default(.showUnwatchedFeedBadges) private var showUnwatchedFeedBadges
     @Default(.keepChannelsWithUnwatchedFeedOnTop) private var keepChannelsWithUnwatchedFeedOnTop
     #if os(iOS)
+        @Default(.enterFullscreenInLandscape) private var enterFullscreenInLandscape
         @Default(.lockPortraitWhenBrowsing) private var lockPortraitWhenBrowsing
         @Default(.showDocuments) private var showDocuments
     #endif
@@ -19,6 +20,7 @@ struct BrowsingSettings: View {
     @Default(.showOpenActionsToolbarItem) private var showOpenActionsToolbarItem
     @Default(.visibleSections) private var visibleSections
     @Default(.startupSection) private var startupSection
+    @Default(.showSearchSuggestions) private var showSearchSuggestions
     @Default(.playerButtonSingleTapGesture) private var playerButtonSingleTapGesture
     @Default(.playerButtonDoubleTapGesture) private var playerButtonDoubleTapGesture
     @Default(.playerButtonShowsControlButtonsWhenMinimized) private var playerButtonShowsControlButtonsWhenMinimized
@@ -66,6 +68,7 @@ struct BrowsingSettings: View {
             homeSettings
             if !accounts.isEmpty {
                 startupSectionPicker
+                showSearchSuggestionsToggle
                 visibleSectionsSettings
             }
             let interface = interfaceSettings
@@ -161,14 +164,18 @@ struct BrowsingSettings: View {
             #if os(iOS)
                 Toggle("Show Documents", isOn: $showDocuments)
 
-                Toggle("Lock portrait mode", isOn: $lockPortraitWhenBrowsing)
-                    .onChange(of: lockPortraitWhenBrowsing) { lock in
-                        if lock {
-                            Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
-                        } else {
-                            Orientation.lockOrientation(.allButUpsideDown)
+                if Constants.isIPad {
+                    Toggle("Lock portrait mode", isOn: $lockPortraitWhenBrowsing)
+                        .onChange(of: lockPortraitWhenBrowsing) { lock in
+                            if lock {
+                                enterFullscreenInLandscape = true
+                                Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
+                            } else {
+                                enterFullscreenInLandscape = false
+                                Orientation.lockOrientation(.all)
+                            }
                         }
-                    }
+                }
             #endif
 
             if !accounts.isEmpty {
@@ -241,6 +248,10 @@ struct BrowsingSettings: View {
         }
     }
 
+    private var showSearchSuggestionsToggle: some View {
+        Toggle("Show search suggestions", isOn: $showSearchSuggestions)
+    }
+
     private func toggleSection(_ section: VisibleSection, value: Bool) {
         if value {
             visibleSections.insert(section)

Shared/Settings/InstanceForm.swift

@@ -86,6 +86,7 @@ struct InstanceForm: View {
                 .autocapitalization(.none)
                 .keyboardType(.URL)
             #endif
+                .disableAutocorrection(true)
 
             #if os(tvOS)
                 VStack {

Shared/Settings/PlayerControlsSettings.swift

@@ -38,6 +38,7 @@ struct PlayerControlsSettings: View {
     @Default(.playerControlsAdvanceToNextEnabled) private var playerControlsAdvanceToNextEnabled
     @Default(.playerControlsPlaybackModeEnabled) private var playerControlsPlaybackModeEnabled
     @Default(.playerControlsMusicModeEnabled) private var playerControlsMusicModeEnabled
+    @Default(.playerControlsBackgroundOpacity) private var playerControlsBackgroundOpacity
 
     private var player = PlayerModel.shared
 
@@ -76,6 +77,8 @@ struct PlayerControlsSettings: View {
                 playerControlsLayoutPicker
                 SettingsHeader(text: "Fullscreen size".localized(), secondary: true)
                 fullScreenPlayerControlsLayoutPicker
+                SettingsHeader(text: "Background opacity".localized(), secondary: true)
+                playerControlsBackgroundOpacityPicker
             }
         #endif
 
@@ -202,6 +205,15 @@ struct PlayerControlsSettings: View {
         .modifier(SettingsPickerModifier())
     }
 
+    private var playerControlsBackgroundOpacityPicker: some View {
+        Picker("Background opacity", selection: $playerControlsBackgroundOpacity) {
+            ForEach(Array(stride(from: 0.0, through: 1.0, by: 0.1)), id: \.self) { value in
+                Text("\(Int(value * 100))%").tag(value)
+            }
+        }
+        .modifier(SettingsPickerModifier())
+    }
+
     @ViewBuilder private var seekingSection: some View {
         seekingDurationSetting("System controls", $systemControlsSeekDuration)
             .foregroundColor(systemControlsCommands == .restartAndAdvanceToNext ? .secondary : .primary)

Shared/Settings/PlayerSettings.swift

@@ -18,8 +18,8 @@ struct PlayerSettings: View {
     @Default(.pauseOnHidingPlayer) private var pauseOnHidingPlayer
     @Default(.closeVideoOnEOF) private var closeVideoOnEOF
     #if os(iOS)
-        @Default(.honorSystemOrientationLock) private var honorSystemOrientationLock
         @Default(.enterFullscreenInLandscape) private var enterFullscreenInLandscape
+        @Default(.lockPortraitWhenBrowsing) private var lockPortraitWhenBrowsing
         @Default(.rotateToLandscapeOnEnterFullScreen) private var rotateToLandscapeOnEnterFullScreen
     #endif
     @Default(.closePiPOnNavigation) private var closePiPOnNavigation
@@ -87,7 +87,7 @@ struct PlayerSettings: View {
                 }
                 pauseOnHidingPlayerToggle
                 closeVideoOnEOFToggle
-                #if !os(tvOS)
+                #if os(macOS)
                     exitFullscreenOnEOFToggle
                 #endif
                 #if !os(macOS)
@@ -202,11 +202,12 @@ struct PlayerSettings: View {
             #endif
 
             #if os(iOS)
-                Section(header: SettingsHeader(text: "Orientation".localized())) {
-                    if idiom == .pad {
+                Section(header: SettingsHeader(text: "Fullscreen".localized())) {
+                    if Constants.isIPad {
                         enterFullscreenInLandscapeToggle
                     }
-                    honorSystemOrientationLockToggle
+
+                    exitFullscreenOnEOFToggle
                     rotateToLandscapeOnEnterFullScreenPicker
                 }
             #endif
@@ -318,20 +319,15 @@ struct PlayerSettings: View {
     #endif
 
     #if os(iOS)
-        private var honorSystemOrientationLockToggle: some View {
-            Toggle("Honor orientation lock", isOn: $honorSystemOrientationLock)
-                .disabled(!enterFullscreenInLandscape)
-        }
-
         private var enterFullscreenInLandscapeToggle: some View {
-            Toggle("Enter fullscreen in landscape", isOn: $enterFullscreenInLandscape)
+            Toggle("Enter fullscreen in landscape orientation", isOn: $enterFullscreenInLandscape)
+                .disabled(lockPortraitWhenBrowsing)
         }
 
         private var rotateToLandscapeOnEnterFullScreenPicker: some View {
-            Picker("Rotate when entering fullscreen on landscape video", selection: $rotateToLandscapeOnEnterFullScreen) {
-                Text("Landscape left").tag(FullScreenRotationSetting.landscapeRight)
-                Text("Landscape right").tag(FullScreenRotationSetting.landscapeLeft)
-                Text("No rotation").tag(FullScreenRotationSetting.disabled)
+            Picker("Default orientation", selection: $rotateToLandscapeOnEnterFullScreen) {
+                Text("Landscape left").tag(FullScreenRotationSetting.landscapeLeft)
+                Text("Landscape right").tag(FullScreenRotationSetting.landscapeRight)
             }
             .modifier(SettingsPickerModifier())
         }

Shared/Settings/QualityProfileForm.swift

@@ -301,7 +301,7 @@ struct QualityProfileForm: View {
     func isFormatDisabled(_ format: QualityProfile.Format) -> Bool {
         guard backend == .appleAVPlayer else { return false }
 
-        let avPlayerFormats = [QualityProfile.Format.hls, .stream, .mp4]
+        let avPlayerFormats = [.stream, QualityProfile.Format.hls]
 
         return !avPlayerFormats.contains(format)
     }
@@ -315,7 +315,9 @@ struct QualityProfileForm: View {
     func isResolutionDisabled(_ resolution: ResolutionSetting) -> Bool {
         guard backend == .appleAVPlayer else { return false }
 
-        return resolution.value > .hd720p30
+        let hd720p30 = Stream.Resolution.predefined(.hd720p30)
+
+        return resolution.value > hd720p30
     }
 
     func initializeForm() {

Shared/Subscriptions/SubscriptionsView.swift

@@ -38,12 +38,14 @@ struct SubscriptionsView: View {
                         }
                         .pickerStyle(.segmented)
                         .labelStyle(.titleOnly)
-
-                        subscriptionsMenu
                     }
                     .frame(maxWidth: 500)
                 }
 
+                ToolbarItem(placement: .navigationBarTrailing) {
+                    subscriptionsMenu
+                }
+
                 ToolbarItem {
                     RequestErrorButton(error: requestError)
                 }
@@ -88,7 +90,7 @@ struct SubscriptionsView: View {
                     SettingsButtons()
                 }
             } label: {
-                HStack(spacing: 12) {
+                HStack {
                     Image(systemName: "chevron.down.circle.fill")
                         .foregroundColor(.accentColor)
                         .imageScale(.large)

Shared/Videos/VerticalCells.swift

@@ -52,7 +52,7 @@ struct VerticalCells<Header: View>: View {
         .edgesIgnoringSafeArea(edgesIgnoringSafeArea)
         #if os(macOS)
             .background(Color.secondaryBackground)
-            .frame(minWidth: 360)
+            .frame(minWidth: Constants.contentViewMinWidth)
         #endif
     }
 

Shared/Views/VideoContextMenuView.swift

@@ -24,14 +24,42 @@ struct VideoContextMenuView: View {
 
     private var backgroundContext = PersistenceController.shared.container.newBackgroundContext()
 
+    @State private var isOverlayVisible = false
+
     init(video: Video) {
         self.video = video
         _watchRequest = video.watchFetchRequest
     }
 
     var body: some View {
-        if video.videoID != Video.fixtureID {
-            contextMenu
+        ZStack {
+            // Conditional overlay to block taps on underlying views
+            if isOverlayVisible {
+                Color.clear
+                    .contentShape(Rectangle())
+                #if !os(tvOS)
+                    // This is not available on tvOS < 16 so we leave out.
+                    // TODO: remove #if when setting the minimum deployment target to >= 16
+                    .onTapGesture {
+                        // Dismiss overlay without triggering other interactions
+                        isOverlayVisible = false
+                    }
+                #endif
+                    .ignoresSafeArea() // Ensure overlay covers the entire screen
+                    .accessibilityLabel("Dismiss context menu")
+                    .accessibilityHint("Tap to close the context")
+                    .accessibilityAddTraits(.isButton)
+            }
+
+            if video.videoID != Video.fixtureID {
+                contextMenu
+                    .onAppear {
+                        isOverlayVisible = true
+                    }
+                    .onDisappear {
+                        isOverlayVisible = false
+                    }
+            }
         }
     }
 

Shared/YatteeApp.swift

@@ -204,9 +204,14 @@ struct YatteeApp: App {
             }
 
             #if os(iOS)
-                DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
                     if Defaults[.lockPortraitWhenBrowsing] {
-                        Orientation.lockOrientation(.all, andRotateTo: .portrait)
+                        Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
+                    } else {
+                        let rotationOrientation =
+                            OrientationTracker.shared.currentDeviceOrientation.rawValue == 4 ? UIInterfaceOrientation.landscapeRight :
+                            (OrientationTracker.shared.currentDeviceOrientation.rawValue == 3 ? UIInterfaceOrientation.landscapeLeft : UIInterfaceOrientation.portrait)
+                        Orientation.lockOrientation(.all, andRotateTo: rotationOrientation)
                     }
                 }
             #endif
@@ -225,6 +230,17 @@ struct YatteeApp: App {
             DispatchQueue.global(qos: .userInitiated).async {
                 self.migrateQualityProfiles()
             }
+
+            #if os(iOS)
+                DispatchQueue.global(qos: .userInitiated).async {
+                    self.migrateRotateToLandscapeOnEnterFullScreen()
+                }
+
+                DispatchQueue.global(qos: .userInitiated).async {
+                    self.migrateLockPortraitWhenBrowsing()
+                }
+
+            #endif
         }
     }
 
@@ -253,6 +269,22 @@ struct YatteeApp: App {
         }
     }
 
+    #if os(iOS)
+        func migrateRotateToLandscapeOnEnterFullScreen() {
+            if Defaults[.rotateToLandscapeOnEnterFullScreen] != .landscapeRight || Defaults[.rotateToLandscapeOnEnterFullScreen] != .landscapeLeft {
+                Defaults[.rotateToLandscapeOnEnterFullScreen] = .landscapeRight
+            }
+        }
+
+        func migrateLockPortraitWhenBrowsing() {
+            if Constants.isIPhone {
+                Defaults[.lockPortraitWhenBrowsing] = true
+            } else if Constants.isIPad, Defaults[.lockPortraitWhenBrowsing] {
+                Defaults[.enterFullscreenInLandscape] = true
+            }
+        }
+    #endif
+
     var navigationStyle: NavigationStyle {
         #if os(iOS)
             return horizontalSizeClass == .compact ? .tab : .sidebar

Yattee.xcodeproj/project.pbxproj

@@ -4103,7 +4103,7 @@
 				CODE_SIGN_ENTITLEMENTS = "Open in Yattee/Open in Yattee.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = "Open in Yattee/Info.plist";
 				INFOPLIST_KEY_CFBundleDisplayName = "Open in Yattee";
@@ -4134,7 +4134,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = 78Z5H3M6RJ;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = "Open in Yattee/Info.plist";
@@ -4165,7 +4165,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
 				MACOSX_DEPLOYMENT_TARGET = 11.0;
@@ -4185,7 +4185,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
 				MACOSX_DEPLOYMENT_TARGET = 11.0;
@@ -4326,6 +4326,7 @@
 				ENABLE_USER_SCRIPT_SANDBOXING = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 3;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
 				GCC_WARN_UNDECLARED_SELECTOR = YES;
@@ -4348,7 +4349,7 @@
 				CODE_SIGN_ENTITLEMENTS = "iOS/Yattee (iOS).entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				ENABLE_PREVIEWS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"DEBUG=1",
@@ -4365,7 +4366,8 @@
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UIRequiresFullScreen = YES;
 				INFOPLIST_KEY_UIStatusBarHidden = NO;
-				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortraitUpsideDown";
+				INFOPLIST_KEY_UIStatusBarStyle = "";
+				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
 				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
@@ -4400,7 +4402,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = 78Z5H3M6RJ;
 				ENABLE_PREVIEWS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = "GLES_SILENCE_DEPRECATION=1";
@@ -4414,7 +4416,8 @@
 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
 				INFOPLIST_KEY_UIRequiresFullScreen = YES;
 				INFOPLIST_KEY_UIStatusBarHidden = NO;
-				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortraitUpsideDown";
+				INFOPLIST_KEY_UIStatusBarStyle = "";
+				INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
 				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
@@ -4452,7 +4455,7 @@
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEAD_CODE_STRIPPING = YES;
 				ENABLE_APP_SANDBOX = YES;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -4491,13 +4494,14 @@
 				"CODE_SIGN_IDENTITY[sdk=macosx*]" = "3rd Party Mac Developer Application";
 				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEAD_CODE_STRIPPING = YES;
 				"DEVELOPMENT_TEAM[sdk=macosx*]" = 78Z5H3M6RJ;
 				ENABLE_APP_SANDBOX = YES;
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SELECTED_FILES = readonly;
+				GCC_OPTIMIZATION_LEVEL = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = macOS/Info.plist;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.video";
@@ -4525,7 +4529,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -4548,7 +4552,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -4573,7 +4577,7 @@
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEAD_CODE_STRIPPING = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -4597,7 +4601,7 @@
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEAD_CODE_STRIPPING = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -4623,7 +4627,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEVELOPMENT_ASSET_PATHS = "";
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -4663,7 +4667,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "iPhone Distribution";
 				CODE_SIGN_STYLE = Manual;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				DEVELOPMENT_ASSET_PATHS = "";
 				"DEVELOPMENT_TEAM[sdk=appletvos*]" = 78Z5H3M6RJ;
 				ENABLE_PREVIEWS = YES;
@@ -4703,7 +4707,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
@@ -4726,7 +4730,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 192;
+				CURRENT_PROJECT_VERSION = 196;
 				GENERATE_INFOPLIST_FILE = YES;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",

Yattee.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,5 +1,5 @@
 {
-  "originHash" : "193e96313b1796c618e74a8b1c36659d0f16f66278ff8045f9e02c42590ae5aa",
+  "originHash" : "515d8e68c4a31658288fb3f94789ee539399b042082c08c39f4c03c27fd8860c",
   "pins" : [
     {
       "identity" : "activelabel.swift",
@@ -25,7 +25,7 @@
       "location" : "https://github.com/hyperoslo/Cache.git",
       "state" : {
         "branch" : "master",
-        "revision" : "d2e8f5a53c601b43371fdc90277d7f64b0e89a25"
+        "revision" : "81a0277cbc6b63f4e0cd6f42c4abefa1011bbfa9"
       }
     },
     {

Yattee.xcodeproj/xcshareddata/xcschemes/Yattee (iOS).xcscheme

@@ -66,6 +66,11 @@
             value = "Yes"
             isEnabled = "YES">
          </EnvironmentVariable>
+         <EnvironmentVariable
+            key = "IDELogRedirectionPolicy"
+            value = "oslogToStdio"
+            isEnabled = "YES">
+         </EnvironmentVariable>
       </EnvironmentVariables>
    </LaunchAction>
    <ProfileAction

iOS/AppDelegate.swift

@@ -1,22 +1,38 @@
+import AVFoundation
+import Defaults
 import Foundation
+import Logging
 import UIKit
 
 final class AppDelegate: UIResponder, UIApplicationDelegate {
     var orientationLock = UIInterfaceOrientationMask.all
 
+    private var logger = Logger(label: "stream.yattee.app.delegate")
     private(set) static var instance: AppDelegate!
 
     func application(_: UIApplication, supportedInterfaceOrientationsFor _: UIWindow?) -> UIInterfaceOrientationMask {
-        orientationLock
+        return orientationLock
     }
 
     func application(_: UIApplication, didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool { // swiftlint:disable:this discouraged_optional_collection
         Self.instance = self
-        #if os(iOS)
-            UIViewController.swizzleHomeIndicatorProperty()
 
+        #if !os(macOS)
+            UIViewController.swizzleHomeIndicatorProperty()
             OrientationTracker.shared.startDeviceOrientationTracking()
+            OrientationModel.shared.startOrientationUpdates()
+
+            // Configure the audio session for playback
+            do {
+                try AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
+            } catch {
+                logger.error("Failed to set audio session category: \(error)")
+            }
+
+            // Begin receiving remote control events
+            UIApplication.shared.beginReceivingRemoteControlEvents()
         #endif
+
         return true
     }
 

iOS/Orientation.swift

@@ -1,5 +1,4 @@
 import CoreMotion
-import Defaults
 import Logging
 import UIKit
 
@@ -35,7 +34,7 @@ enum Orientation {
             let rotateOrientationMask = rotateOrientation == .portrait ? UIInterfaceOrientationMask.portrait :
                 rotateOrientation == .landscapeLeft ? .landscapeLeft :
                 rotateOrientation == .landscapeRight ? .landscapeRight :
-                .allButUpsideDown
+                .all
 
             windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: rotateOrientationMask)) { error in
                 print("denied rotation \(error)")

iOS/OrientationModel.swift

@@ -1,91 +1,86 @@
 import Defaults
 import Foundation
+import Logging
 import Repeat
 import SwiftUI
 
 final class OrientationModel {
     static var shared = OrientationModel()
+    let logger = Logger(label: "stream.yattee.orientation.model")
 
     var orientation = UIInterfaceOrientation.portrait
     var lastOrientation: UIInterfaceOrientation?
     var orientationDebouncer = Debouncer(.milliseconds(300))
     var orientationObserver: Any?
 
+    @Default(.lockPortraitWhenBrowsing) private var lockPortraitWhenBrowsing
+    @Default(.enterFullscreenInLandscape) private var enterFullscreenInLandscape
+
     private var player = PlayerModel.shared
 
-    func configureOrientationUpdatesBasedOnAccelerometer() {
-        let currentOrientation = OrientationTracker.shared.currentInterfaceOrientation
-        if currentOrientation.isLandscape,
-           Defaults[.enterFullscreenInLandscape],
-           !Defaults[.honorSystemOrientationLock],
-           !player.playingFullScreen,
-           !player.currentItem.isNil,
-           player.lockedOrientation.isNil || player.lockedOrientation!.contains(.landscape),
-           !player.playingInPictureInPicture,
-           player.presentingPlayer
-        {
-            DispatchQueue.main.async {
-                self.player.controls.presentingControls = false
-                self.player.enterFullScreen(showControls: false)
-            }
-
-            player.onPresentPlayer.append {
-                Orientation.lockOrientation(.allButUpsideDown, andRotateTo: currentOrientation)
-            }
-        }
-
+    func startOrientationUpdates() {
+        // Ensure the orientation observer is active
         orientationObserver = NotificationCenter.default.addObserver(
             forName: OrientationTracker.deviceOrientationChangedNotification,
             object: nil,
             queue: .main
         ) { _ in
-            guard !Defaults[.honorSystemOrientationLock],
-                  self.player.presentingPlayer,
-                  !self.player.playingInPictureInPicture,
-                  self.player.lockedOrientation.isNil
+            self.logger.info("Notification received: Device orientation changed.")
+
+            // We only allow .portrait and are not showing the player
+            guard (!self.player.presentingPlayer && !self.lockPortraitWhenBrowsing) || self.player.presentingPlayer
             else {
                 return
             }
 
             let orientation = OrientationTracker.shared.currentInterfaceOrientation
+            self.logger.info("Current interface orientation: \(orientation)")
 
-            guard self.lastOrientation != orientation else {
+            // Always update lastOrientation to keep track of the latest state
+            if self.lastOrientation != orientation {
+                self.lastOrientation = orientation
+                self.logger.info("Orientation changed to: \(orientation)")
+            } else {
+                self.logger.info("Orientation has not changed.")
+            }
+
+            // Only take action if the player is active and presenting
+            guard (!self.player.isOrientationLocked && !self.player.playingInPictureInPicture) || (!self.lockPortraitWhenBrowsing && !self.player.presentingPlayer) || (!self.lockPortraitWhenBrowsing && self.player.presentingPlayer && !self.player.isOrientationLocked)
+            else {
+                self.logger.info("Only updating orientation without actions.")
                 return
             }
 
-            self.lastOrientation = orientation
-
             DispatchQueue.main.async {
-                guard Defaults[.enterFullscreenInLandscape],
-                      self.player.presentingPlayer
-                else {
-                    return
-                }
-
                 self.orientationDebouncer.callback = {
                     DispatchQueue.main.async {
                         if orientation.isLandscape {
-                            self.player.controls.presentingControls = false
-                            self.player.enterFullScreen(showControls: false)
+                            if self.enterFullscreenInLandscape, self.player.presentingPlayer {
+                                self.logger.info("Entering fullscreen because orientation is landscape.")
+                                self.player.controls.presentingControls = false
+                                self.player.enterFullScreen(showControls: false)
+                            }
                             Orientation.lockOrientation(OrientationTracker.shared.currentInterfaceOrientationMask, andRotateTo: orientation)
                         } else {
-                            self.player.exitFullScreen(showControls: false)
-                            Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
+                            self.logger.info("Exiting fullscreen because orientation is portrait.")
+                            if self.player.playingFullScreen {
+                                self.player.exitFullScreen(showControls: false)
+                            }
+                            if self.lockPortraitWhenBrowsing {
+                                Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
+                            } else {
+                                Orientation.lockOrientation(OrientationTracker.shared.currentInterfaceOrientationMask, andRotateTo: orientation)
+                            }
                         }
                     }
                 }
-
                 self.orientationDebouncer.call()
             }
         }
     }
 
-    func stopOrientationUpdates() {
-        guard let observer = orientationObserver else { return }
-        NotificationCenter.default.removeObserver(observer)
-    }
-
     func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation: UIInterfaceOrientation? = nil) {
+        logger.info("Locking orientation to: \(orientation), rotating to: \(String(describing: rotateOrientation)).")
         if let rotateOrientation {
             self.orientation = rotateOrientation
             lastOrientation = rotateOrientation