1
0
mirror of https://github.com/yattee/yattee.git synced 2024-12-14 22:30:32 +05:30
yattee/Model/Player/Backends/MPVBackend.swift

682 lines
19 KiB
Swift
Raw Normal View History

2022-02-17 01:53:11 +05:30
import AVFAudio
import CoreMedia
import Defaults
2022-02-17 01:53:11 +05:30
import Foundation
import Libmpv
2022-02-17 01:53:11 +05:30
import Logging
import MediaPlayer
2022-06-30 04:13:41 +05:30
import Repeat
2022-02-17 01:53:11 +05:30
import SwiftUI
final class MPVBackend: PlayerBackend {
static var timeUpdateInterval = 0.5
static var networkStateUpdateInterval = 0.1
2022-06-16 23:14:39 +05:30
2022-02-17 01:53:11 +05:30
private var logger = Logger(label: "mpv-backend")
var model: PlayerModel { .shared }
var controls: PlayerControlsModel { .shared }
var playerTime: PlayerTimeModel { .shared }
var networkState: NetworkStateModel { .shared }
var seek: SeekModel { .shared }
2022-02-17 01:53:11 +05:30
var stream: Stream?
var video: Video?
2022-07-05 22:50:25 +05:30
var captions: Captions? { didSet {
2022-09-28 19:57:01 +05:30
guard let captions else {
2023-02-24 22:49:55 +05:30
client?.removeSubs()
2022-07-05 22:50:25 +05:30
return
}
addSubTrack(captions.url)
}}
2022-02-17 01:53:11 +05:30
var currentTime: CMTime?
var loadedVideo = false
2022-02-28 02:01:17 +05:30
var isLoadingVideo = true { didSet {
DispatchQueue.main.async { [weak self] in
2022-09-28 19:57:01 +05:30
guard let self else {
2022-04-03 20:16:33 +05:30
return
}
self.controls.isLoadingVideo = self.isLoadingVideo
2022-06-25 05:09:29 +05:30
self.setNeedsNetworkStateUpdates(true)
self.model.objectWillChange.send()
2022-02-28 02:01:17 +05:30
}
}}
2022-02-17 01:53:11 +05:30
var hasStarted = false
var isPaused = false
2022-02-17 01:53:11 +05:30
var isPlaying = true { didSet {
2022-06-30 04:13:41 +05:30
networkStateTimer.start()
2022-02-17 01:53:11 +05:30
if isPlaying {
startClientUpdates()
} else {
stopControlsUpdates()
}
updateControlsIsPlaying()
2022-04-03 20:33:56 +05:30
#if os(macOS)
if isPlaying {
ScreenSaverManager.shared.disable(reason: "Yattee is playing video")
} else {
ScreenSaverManager.shared.enable()
}
MPNowPlayingInfoCenter.default().playbackState = isPlaying ? .playing : .paused
#else
2022-05-21 02:53:14 +05:30
DispatchQueue.main.async {
UIApplication.shared.isIdleTimerDisabled = self.model.presentingPlayer && self.isPlaying
}
2022-04-03 20:33:56 +05:30
#endif
2022-02-17 01:53:11 +05:30
}}
var isSeeking = false {
didSet {
DispatchQueue.main.async { [weak self] in
2022-09-28 19:57:01 +05:30
guard let self else { return }
self.model.isSeeking = self.isSeeking
}
}
}
2022-02-17 01:53:11 +05:30
var playerItemDuration: CMTime?
2022-02-28 02:01:17 +05:30
#if !os(macOS)
var controller: MPVViewController!
#endif
2022-02-17 01:53:11 +05:30
var client: MPVClient! { didSet { client.backend = self } }
2022-06-30 04:13:41 +05:30
private var clientTimer: Repeater!
private var networkStateTimer: Repeater!
2022-02-17 01:53:11 +05:30
private var onFileLoaded: (() -> Void)?
2023-09-23 18:37:27 +05:30
var controlsUpdates = false
2022-02-17 01:53:11 +05:30
private var timeObserverThrottle = Throttle(interval: 2)
2022-11-11 03:49:34 +05:30
var suggestedPlaybackRates: [Double] {
2022-11-19 04:15:49 +05:30
[0.25, 0.33, 0.5, 0.67, 0.75, 1, 1.25, 1.5, 1.75, 2, 3, 4]
2022-11-11 03:49:34 +05:30
}
func canPlayAtRate(_ rate: Double) -> Bool {
rate > 0 && rate <= 100
}
2022-06-08 02:57:48 +05:30
var tracks: Int {
client?.tracksCount ?? -1
}
2022-07-09 05:51:04 +05:30
var aspectRatio: Double {
client?.aspectRatio ?? VideoPlayerView.defaultAspectRatio
}
2022-06-16 23:14:39 +05:30
var frameDropCount: Int {
client?.frameDropCount ?? 0
}
var outputFps: Double {
client?.outputFps ?? 0
}
2022-11-10 22:41:28 +05:30
var formattedOutputFps: String {
String(format: "%.2ffps", outputFps)
}
var hwDecoder: String {
client?.hwDecoder ?? "unknown"
}
var bufferingState: Double {
client?.bufferingState ?? 0
}
var cacheDuration: Double {
client?.cacheDuration ?? 0
}
2022-11-10 22:41:28 +05:30
var videoFormat: String {
client?.videoFormat ?? "unknown"
}
var videoCodec: String {
client?.videoCodec ?? "unknown"
}
var currentVo: String {
client?.currentVo ?? "unknown"
}
var videoWidth: Double? {
if let width = client?.width, width != "unknown" {
return Double(width)
}
return nil
}
var videoHeight: Double? {
if let height = client?.height, height != "unknown" {
return Double(height)
}
return nil
}
var audioFormat: String {
client?.audioFormat ?? "unknown"
}
var audioCodec: String {
client?.audioCodec ?? "unknown"
}
var currentAo: String {
client?.currentAo ?? "unknown"
}
var audioChannels: String {
client?.audioChannels ?? "unknown"
}
var audioSampleRate: String {
client?.audioSampleRate ?? "unknown"
}
2022-09-02 04:35:31 +05:30
init() {
2023-12-05 04:37:36 +05:30
// 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 {
return
}
self.getTimeUpdates()
2022-06-30 04:13:41 +05:30
}
2022-06-25 05:02:21 +05:30
2022-06-30 04:13:41 +05:30
networkStateTimer = .init(interval: .seconds(Self.networkStateUpdateInterval), mode: .infinite) { [weak self] _ in
guard let self = self, self.model.activeBackend == .mpv else {
return
}
self.updateNetworkState()
2022-06-30 04:13:41 +05:30
}
2023-12-05 04:37:36 +05:30
// swiftlint:enable shorthand_optional_binding
}
typealias AreInIncreasingOrder = (Stream, Stream) -> Bool
2022-02-17 01:53:11 +05:30
func canPlay(_ stream: Stream) -> Bool {
stream.resolution != .unknown && stream.format != .av1
2022-02-17 01:53:11 +05:30
}
2022-08-27 01:47:21 +05:30
func playStream(_ stream: Stream, of video: Video, preservingTime: Bool, upgrading: Bool) {
2022-04-03 20:33:56 +05:30
#if !os(macOS)
if model.presentingPlayer {
2023-05-16 22:21:07 +05:30
DispatchQueue.main.async {
UIApplication.shared.isIdleTimerDisabled = true
}
2022-04-03 20:33:56 +05:30
}
#endif
2022-07-05 22:50:25 +05:30
var captions: Captions?
if Defaults[.captionsAutoShow] == true {
2024-05-20 18:10:25 +05:30
let captionsDefaultLanguageCode = Defaults[.captionsDefaultLanguageCode],
captionsFallbackLanguageCode = Defaults[.captionsFallbackLanguageCode]
// Try to get captions with the default language code first
captions = video.captions.first { $0.code == captionsDefaultLanguageCode } ??
video.captions.first { $0.code.contains(captionsDefaultLanguageCode) }
// If there are still no captions, try to get captions with the fallback language code
if captions.isNil && !captionsFallbackLanguageCode.isEmpty {
captions = video.captions.first { $0.code == captionsFallbackLanguageCode } ??
video.captions.first { $0.code.contains(captionsFallbackLanguageCode) }
}
} else {
captions = nil
2022-07-05 22:50:25 +05:30
}
2022-02-17 01:53:11 +05:30
let updateCurrentStream = {
DispatchQueue.main.async { [weak self] in
self?.stream = stream
self?.video = video
self?.model.stream = stream
2022-07-05 22:50:25 +05:30
self?.captions = captions
2022-02-17 01:53:11 +05:30
}
}
let startPlaying = {
#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)")
}
#endif
2022-02-17 01:53:11 +05:30
DispatchQueue.main.async { [weak self] in
2022-09-28 19:57:01 +05:30
guard let self else {
2022-02-17 01:53:11 +05:30
return
}
self.startClientUpdates()
if Defaults[.captionsAutoShow] { self.client?.setSubToAuto() } else { self.client?.setSubToNo() }
PlayerModel.shared.captions = self.captions
2022-02-17 01:53:11 +05:30
if !preservingTime,
2022-08-27 01:47:21 +05:30
!upgrading,
2022-02-17 01:53:11 +05:30
let segment = self.model.sponsorBlock.segments.first,
self.model.lastSkipped.isNil
{
self.seek(to: segment.endTime, seekType: .segmentSkip(segment.category)) { finished in
2022-02-17 01:53:11 +05:30
guard finished else {
return
}
self.model.lastSkipped = segment
self.play()
self.model.handleOnPlayStream(stream)
2022-02-17 01:53:11 +05:30
}
} else {
self.play()
self.model.handleOnPlayStream(stream)
2022-02-17 01:53:11 +05:30
}
}
}
let replaceItem: (CMTime?) -> Void = { [weak self] time in
2022-09-28 19:57:01 +05:30
guard let self else {
2022-02-17 01:53:11 +05:30
return
}
self.stop()
DispatchQueue.main.async { [weak self] in
2023-05-08 01:24:48 +05:30
guard let self, let client = self.client else {
return
2022-02-17 01:53:11 +05:30
}
if let url = stream.singleAssetURL {
self.onFileLoaded = {
updateCurrentStream()
startPlaying()
}
2022-11-12 07:35:56 +05:30
if video.isLocal, video.localStreamIsFile {
2022-12-04 17:51:50 +05:30
if url.startAccessingSecurityScopedResource() {
URLBookmarkModel.shared.saveBookmark(url)
}
2022-11-10 22:41:28 +05:30
}
client.loadFile(url, bitrate: stream.bitrate, kind: stream.kind, sub: captions?.url, time: time, forceSeekable: stream.kind == .hls) { [weak self] _ in
self?.isLoadingVideo = true
}
} else {
2022-06-08 02:50:24 +05:30
self.onFileLoaded = {
updateCurrentStream()
startPlaying()
2022-02-17 01:53:11 +05:30
}
2022-06-08 02:50:24 +05:30
let fileToLoad = self.model.musicMode ? stream.audioAsset.url : stream.videoAsset.url
let audioTrack = self.model.musicMode ? nil : stream.audioAsset.url
client.loadFile(fileToLoad, audio: audioTrack, bitrate: stream.bitrate, kind: stream.kind, sub: captions?.url, time: time, forceSeekable: stream.kind == .hls) { [weak self] _ in
self?.isLoadingVideo = true
self?.pause()
}
2022-02-17 01:53:11 +05:30
}
}
}
if preservingTime {
if model.preservedTime.isNil || upgrading {
2022-02-17 01:53:11 +05:30
model.saveTime {
replaceItem(self.model.preservedTime)
}
} else {
replaceItem(self.model.preservedTime)
}
} else {
replaceItem(nil)
}
2022-03-28 00:54:32 +05:30
startClientUpdates()
2022-02-17 01:53:11 +05:30
}
func play() {
startClientUpdates()
if controls.presentingControls {
2022-03-27 17:12:20 +05:30
startControlsUpdates()
}
2022-05-22 02:28:11 +05:30
setRate(model.currentRate)
// After the video has ended, hitting play restarts the video from the beginning.
2024-08-24 21:22:35 +05:30
if let currentTime, currentTime.seconds.formattedAsPlaybackTime() == model.playerTime.duration.seconds.formattedAsPlaybackTime() &&
currentTime.seconds > 0 && model.playerTime.duration.seconds > 0
{
seek(to: 0, seekType: .loopRestart)
}
2022-02-17 01:53:11 +05:30
client?.play()
isPlaying = true
isPaused = false
// Setting hasStarted to true the first time player started
if !hasStarted {
hasStarted = true
}
2022-02-17 01:53:11 +05:30
}
func pause() {
stopClientUpdates()
client?.pause()
isPaused = true
isPlaying = false
2022-02-17 01:53:11 +05:30
}
func togglePlay() {
2023-06-17 17:39:51 +05:30
if isPlaying {
pause()
} else {
play()
}
2022-02-17 01:53:11 +05:30
}
func cancelLoads() {
stop()
}
2022-02-17 01:53:11 +05:30
func stop() {
client?.stop()
isPlaying = false
isPaused = false
hasStarted = false
2022-02-17 01:53:11 +05:30
}
2022-08-29 17:25:23 +05:30
func seek(to time: CMTime, seekType _: SeekType, completionHandler: ((Bool) -> Void)?) {
client?.seek(to: time) { [weak self] _ in
self?.getTimeUpdates()
2022-02-17 01:53:11 +05:30
self?.updateControls()
completionHandler?(true)
}
}
func setRate(_ rate: Double) {
client?.setDoubleAsync("speed", rate)
2022-02-17 01:53:11 +05:30
}
func closeItem() {
pause()
stop()
2022-08-27 01:47:21 +05:30
self.video = nil
self.stream = nil
}
2022-02-17 01:53:11 +05:30
2022-08-19 04:10:46 +05:30
func closePiP() {}
2022-02-17 01:53:11 +05:30
func startControlsUpdates() {
2022-08-15 03:46:37 +05:30
guard model.presentingPlayer, model.controls.presentingControls, !model.controls.presentingOverlays else {
2022-08-14 22:23:03 +05:30
self.logger.info("ignored controls update start")
return
}
2022-02-17 01:53:11 +05:30
self.logger.info("starting controls updates")
controlsUpdates = true
}
func stopControlsUpdates() {
self.logger.info("stopping controls updates")
controlsUpdates = false
}
func startClientUpdates() {
2022-06-30 04:13:41 +05:30
clientTimer.start()
2022-02-17 01:53:11 +05:30
}
2022-04-17 15:02:04 +05:30
private var handleSegmentsThrottle = Throttle(interval: 1)
func getTimeUpdates() {
2022-02-17 01:53:11 +05:30
currentTime = client?.currentTime
playerItemDuration = client?.duration
if controlsUpdates {
updateControls()
}
2022-02-17 02:40:57 +05:30
model.updateNowPlayingInfo()
2022-04-17 15:02:04 +05:30
handleSegmentsThrottle.execute {
2022-09-28 19:57:01 +05:30
if let currentTime {
2022-04-17 15:02:04 +05:30
model.handleSegments(at: currentTime)
}
2022-02-17 01:53:11 +05:30
}
2022-02-17 02:40:57 +05:30
timeObserverThrottle.execute {
2023-06-08 01:55:10 +05:30
self.model.updateWatch(time: self.currentTime)
2022-02-17 01:53:11 +05:30
}
self.model.updateTime(self.currentTime!)
2022-02-17 01:53:11 +05:30
}
private func stopClientUpdates() {
2022-06-30 04:13:41 +05:30
clientTimer.pause()
2022-02-17 01:53:11 +05:30
}
private func updateControlsIsPlaying() {
guard model.activeBackend == .mpv else { return }
2022-02-17 01:53:11 +05:30
DispatchQueue.main.async { [weak self] in
self?.controls.isPlaying = self?.isPlaying ?? false
2022-02-17 01:53:11 +05:30
}
}
func handle(_ event: UnsafePointer<mpv_event>!) {
logger.info(.init(stringLiteral: "RECEIVED event: \(String(cString: mpv_event_name(event.pointee.event_id)))"))
2022-02-17 01:53:11 +05:30
switch event.pointee.event_id {
case MPV_EVENT_SHUTDOWN:
mpv_destroy(client.mpv)
client.mpv = nil
case MPV_EVENT_LOG_MESSAGE:
let logmsg = UnsafeMutablePointer<mpv_event_log_message>(OpaquePointer(event.pointee.data))
logger.info(.init(stringLiteral: "\(String(cString: (logmsg!.pointee.prefix)!)), "
2022-02-17 01:53:11 +05:30
+ "\(String(cString: (logmsg!.pointee.level)!)), "
+ "\(String(cString: (logmsg!.pointee.text)!))"))
case MPV_EVENT_FILE_LOADED:
onFileLoaded?()
2022-03-20 04:35:09 +05:30
startClientUpdates()
2022-02-17 01:53:11 +05:30
onFileLoaded = nil
2023-09-23 20:12:46 +05:30
case MPV_EVENT_PROPERTY_CHANGE:
let dataOpaquePtr = OpaquePointer(event.pointee.data)
if let property = UnsafePointer<mpv_event_property>(dataOpaquePtr)?.pointee {
let propertyName = String(cString: property.name)
handlePropertyChange(propertyName, property)
}
2022-03-28 00:52:13 +05:30
case MPV_EVENT_PLAYBACK_RESTART:
isLoadingVideo = false
isSeeking = false
2022-03-28 00:52:13 +05:30
onFileLoaded?()
startClientUpdates()
onFileLoaded = nil
2022-09-01 22:25:38 +05:30
case MPV_EVENT_VIDEO_RECONFIG:
model.updateAspectRatio()
case MPV_EVENT_SEEK:
isSeeking = true
2022-02-28 02:01:17 +05:30
2022-02-17 01:53:11 +05:30
case MPV_EVENT_END_FILE:
2022-11-11 02:50:44 +05:30
let reason = event!.pointee.data.load(as: mpv_end_file_reason.self)
if reason != MPV_END_FILE_REASON_STOP {
DispatchQueue.main.async { [weak self] in
guard let self else { return }
NavigationModel.shared.presentAlert(title: "Error while opening file")
self.model.closeCurrentItem(finished: true)
self.getTimeUpdates()
self.eofPlaybackModeAction()
}
} else {
DispatchQueue.main.async { [weak self] in self?.handleEndOfFile() }
}
2022-02-17 01:53:11 +05:30
default:
logger.info(.init(stringLiteral: "UNHANDLED event: \(String(cString: mpv_event_name(event.pointee.event_id)))"))
2022-02-17 01:53:11 +05:30
}
}
func handleEndOfFile() {
2022-07-04 02:48:27 +05:30
guard client.eofReached else {
2022-02-17 01:53:11 +05:30
return
}
2022-07-11 03:54:56 +05:30
eofPlaybackModeAction()
2022-02-17 01:53:11 +05:30
}
func setNeedsDrawing(_ needsDrawing: Bool) {
client?.setNeedsDrawing(needsDrawing)
}
2022-03-27 17:12:20 +05:30
func setSize(_ width: Double, _ height: Double) {
client?.setSize(width, height)
2022-03-27 17:12:20 +05:30
}
2022-06-08 02:50:24 +05:30
func addVideoTrack(_ url: URL) {
client?.addVideoTrack(url)
2022-06-08 02:50:24 +05:30
}
2022-07-05 22:50:25 +05:30
func addSubTrack(_ url: URL) {
client?.removeSubs()
client?.addSubTrack(url)
}
2022-06-08 02:50:24 +05:30
func setVideoToAuto() {
client?.setVideoToAuto()
2022-06-08 02:50:24 +05:30
}
func setVideoToNo() {
client?.setVideoToNo()
}
func updateNetworkState() {
DispatchQueue.main.async { [weak self] in
2023-02-24 22:49:55 +05:30
guard let self, let client = self.client else { return }
self.networkState.pausedForCache = client.pausedForCache
self.networkState.cacheDuration = client.cacheDuration
self.networkState.bufferingState = client.bufferingState
}
2022-06-25 05:02:21 +05:30
if !networkState.needsUpdates {
2022-06-30 04:13:41 +05:30
networkStateTimer.pause()
}
}
2022-06-25 05:09:29 +05:30
func setNeedsNetworkStateUpdates(_ needsUpdates: Bool) {
if needsUpdates {
2022-06-30 04:13:41 +05:30
networkStateTimer.start()
2022-06-25 05:09:29 +05:30
} else {
2022-06-30 04:13:41 +05:30
networkStateTimer.pause()
2022-06-25 05:09:29 +05:30
}
2022-06-08 02:50:24 +05:30
}
2022-08-21 02:01:03 +05:30
func startMusicMode() {
setVideoToNo()
}
func stopMusicMode() {
addVideoTrackFromStream()
setVideoToAuto()
controls.resetTimer()
}
func addVideoTrackFromStream() {
if let videoTrackURL = model.stream?.videoAsset?.url,
tracks < 2
{
logger.info("adding video track")
addVideoTrack(videoTrackURL)
}
setVideoToAuto()
}
func didChangeTo() {
setNeedsDrawing(model.presentingPlayer)
2022-08-21 02:01:03 +05:30
if model.musicMode {
startMusicMode()
} else {
stopMusicMode()
}
}
2023-09-23 20:12:46 +05:30
private func handlePropertyChange(_ name: String, _ property: mpv_event_property) {
switch name {
case "pause":
if let paused = UnsafePointer<Bool>(OpaquePointer(property.data))?.pointee {
if paused {
DispatchQueue.main.async { [weak self] in self?.handleEndOfFile() }
} else {
isLoadingVideo = false
isSeeking = false
}
isPlaying = !paused
networkStateTimer.start()
}
2023-09-23 21:35:13 +05:30
case "core-idle":
if let idle = UnsafePointer<Bool>(OpaquePointer(property.data))?.pointee {
if !idle {
isLoadingVideo = false
isSeeking = false
networkStateTimer.start()
}
}
2023-09-23 20:12:46 +05:30
default:
logger.info("MPV backend received unhandled property: \(name)")
}
}
2024-05-16 22:23:47 +05:30
#if !os(macOS)
@objc func handleAudioSessionInterruption(_ notification: Notification) {
logger.info("Audio session interruption received.")
2024-05-16 22:23:47 +05:30
guard let info = notification.userInfo,
let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt
else {
logger.info("AVAudioSessionInterruptionTypeKey is missing or not a UInt in userInfo.")
return
}
2024-05-16 22:23:47 +05:30
let type = AVAudioSession.InterruptionType(rawValue: typeValue)
2024-05-16 22:23:47 +05:30
logger.info("Interruption type received: \(String(describing: type))")
2024-05-16 22:23:47 +05:30
switch type {
case .began:
pause()
logger.info("Audio session interrupted.")
default:
break
}
}
2024-05-16 22:23:47 +05:30
deinit {
NotificationCenter.default.removeObserver(self, name: AVAudioSession.interruptionNotification, object: nil)
}
#endif
2022-02-17 01:53:11 +05:30
}