diff --git a/.gitignore b/.gitignore index 50564eb6..a0dcc489 100644 --- a/.gitignore +++ b/.gitignore @@ -97,3 +97,5 @@ iOSInjectionProject/ # User-specific xcconfig files Xcode-config/DEVELOPMENT_TEAM.xcconfig +# disable simulator libraries - to be removed when replaced with framework for mpv +Vendor/mpv/iOS/lib_sim diff --git a/Extensions/Comparable+Clamped.swift b/Extensions/Comparable+Clamped.swift new file mode 100644 index 00000000..00d2f8ef --- /dev/null +++ b/Extensions/Comparable+Clamped.swift @@ -0,0 +1,7 @@ +import Foundation + +extension Comparable { + func clamped(to limits: ClosedRange) -> Self { + min(max(self, limits.lowerBound), limits.upperBound) + } +} diff --git a/Model/Applications/InvidiousAPI.swift b/Model/Applications/InvidiousAPI.swift index 76b6ae72..34db34e6 100644 --- a/Model/Applications/InvidiousAPI.swift +++ b/Model/Applications/InvidiousAPI.swift @@ -466,7 +466,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI { return [] } - let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/mp4") && $0["encoding"].stringValue == "h264" } + let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/") } return videoAssetsURLs.map { Stream( @@ -474,7 +474,8 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI { videoAsset: AVURLAsset(url: $0["url"].url!), resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue), kind: .adaptive, - encoding: $0["encoding"].stringValue + encoding: $0["encoding"].stringValue, + videoFormat: $0["type"].stringValue ) } } diff --git a/Model/Applications/PipedAPI.swift b/Model/Applications/PipedAPI.swift index ee40b353..51310c88 100644 --- a/Model/Applications/PipedAPI.swift +++ b/Model/Applications/PipedAPI.swift @@ -481,11 +481,19 @@ final class PipedAPI: Service, ObservableObject, VideosAPI { streams.append(Stream(hlsURL: hlsURL)) } - guard let audioStream = compatibleAudioStreams(from: content).first else { + let audioStreams = content + .dictionaryValue["audioStreams"]? + .arrayValue + .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" } + .sorted { + $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0 + } ?? [] + + guard let audioStream = audioStreams.first else { return streams } - let videoStreams = compatibleVideoStream(from: content) + let videoStreams = content.dictionaryValue["videoStreams"]?.arrayValue ?? [] videoStreams.forEach { videoStream in guard let audioAssetUrl = audioStream.dictionaryValue["url"]?.url, @@ -499,10 +507,11 @@ final class PipedAPI: Service, ObservableObject, VideosAPI { let videoOnly = videoStream.dictionaryValue["videoOnly"]?.boolValue ?? true let resolution = Stream.Resolution.from(resolution: videoStream.dictionaryValue["quality"]!.stringValue) + let videoFormat = videoStream.dictionaryValue["format"]?.stringValue if videoOnly { streams.append( - Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive) + Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive, videoFormat: videoFormat) ) } else { streams.append( @@ -521,23 +530,6 @@ final class PipedAPI: Service, ObservableObject, VideosAPI { .compactMap(extractVideo(from:)) ?? [] } - private func compatibleAudioStreams(from content: JSON) -> [JSON] { - content - .dictionaryValue["audioStreams"]? - .arrayValue - .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" } - .sorted { - $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0 - } ?? [] - } - - private func compatibleVideoStream(from content: JSON) -> [JSON] { - content - .dictionaryValue["videoStreams"]? - .arrayValue - .filter { $0.dictionaryValue["format"] == "MPEG_4" } ?? [] - } - private func extractComment(from content: JSON) -> Comment? { let details = content.dictionaryValue let author = details["author"]?.stringValue ?? "" diff --git a/Model/HistoryModel.swift b/Model/HistoryModel.swift index 680d0d0a..0867bb0f 100644 --- a/Model/HistoryModel.swift +++ b/Model/HistoryModel.swift @@ -23,13 +23,14 @@ extension PlayerModel { } func updateWatch(finished: Bool = false) { - guard let id = currentVideo?.videoID else { + guard let id = currentVideo?.videoID, + Defaults[.saveHistory] + else { return } - let time = player.currentTime() - let seconds = time.seconds - currentItem.playbackTime = time + let time = backend.currentTime + let seconds = time?.seconds ?? 0 let watch: Watch! let watchFetchRequest = Watch.fetchRequest() diff --git a/Model/Player/Backends/AVPlayerBackend.swift b/Model/Player/Backends/AVPlayerBackend.swift new file mode 100644 index 00000000..990bb0c1 --- /dev/null +++ b/Model/Player/Backends/AVPlayerBackend.swift @@ -0,0 +1,613 @@ +import AVFoundation +import Defaults +import Foundation +import MediaPlayer +import UIKit + +final class AVPlayerBackend: PlayerBackend { + static let assetKeysToLoad = ["tracks", "playable", "duration"] + + var model: PlayerModel! + var controls: PlayerControlsModel! + + var stream: Stream? + var video: Video? + + var currentTime: CMTime? { + avPlayer.currentTime() + } + + var loadedVideo: Bool { + !avPlayer.currentItem.isNil + } + + var isLoadingVideo: Bool { + model.currentItem == nil || model.time == nil || !model.time!.isValid + } + + var isPlaying: Bool { + avPlayer.timeControlStatus == .playing + } + + var playerItemDuration: CMTime? { + avPlayer.currentItem?.asset.duration + } + + private(set) var avPlayer = AVPlayer() + var controller: AppleAVPlayerViewController? + + private var asset: AVURLAsset? + private var composition = AVMutableComposition() + private var loadedCompositionAssets = [AVMediaType]() + + private var currentArtwork: MPMediaItemArtwork? + private var frequentTimeObserver: Any? + private var infrequentTimeObserver: Any? + private var playerTimeControlStatusObserver: Any? + + private var statusObservation: NSKeyValueObservation? + + private var timeObserverThrottle = Throttle(interval: 2) + + init(model: PlayerModel, controls: PlayerControlsModel?) { + self.model = model + self.controls = controls + + addFrequentTimeObserver() + addInfrequentTimeObserver() + addPlayerTimeControlStatusObserver() + } + + func bestPlayable(_ streams: [Stream]) -> Stream? { + streams.first { $0.kind == .hls } ?? + streams.filter { $0.kind == .adaptive }.max { $0.resolution < $1.resolution } ?? + streams.first + } + + func canPlay(_ stream: Stream) -> Bool { + stream.kind == .hls || stream.kind == .stream || stream.videoFormat == "MPEG_4" || + (stream.videoFormat.starts(with: "video/mp4") && stream.encoding == "h264") + } + + func playStream( + _ stream: Stream, + of video: Video, + preservingTime: Bool, + upgrading: Bool + ) { + if let url = stream.singleAssetURL { + model.logger.info("playing stream with one asset\(stream.kind == .hls ? " (HLS)" : ""): \(url)") + loadSingleAsset(url, stream: stream, of: video, preservingTime: preservingTime) + } else { + model.logger.info("playing stream with many assets:") + model.logger.info("composition audio asset: \(stream.audioAsset.url)") + model.logger.info("composition video asset: \(stream.videoAsset.url)") + + loadComposition(stream, of: video, preservingTime: preservingTime) + } + + if !upgrading { + updateCurrentArtwork() + } + } + + func play() { + guard avPlayer.timeControlStatus != .playing else { + return + } + + avPlayer.play() + } + + func pause() { + guard avPlayer.timeControlStatus != .paused else { + return + } + + avPlayer.pause() + } + + func togglePlay() { + isPlaying ? pause() : play() + } + + func stop() { + avPlayer.replaceCurrentItem(with: nil) + } + + func seek(to time: CMTime, completionHandler: ((Bool) -> Void)?) { + avPlayer.seek( + to: time, + toleranceBefore: .secondsInDefaultTimescale(1), + toleranceAfter: .zero, + completionHandler: completionHandler ?? { _ in } + ) + } + + func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + if let currentTime = currentTime { + seek(to: currentTime + time, completionHandler: completionHandler) + } + } + + func setRate(_ rate: Float) { + avPlayer.rate = rate + } + + func closeItem() { + avPlayer.replaceCurrentItem(with: nil) + } + + func enterFullScreen() { + controller?.playerView + .perform(NSSelectorFromString("enterFullScreenAnimated:completionHandler:"), with: false, with: nil) + } + + func exitFullScreen() { + controller?.playerView + .perform(NSSelectorFromString("exitFullScreenAnimated:completionHandler:"), with: false, with: nil) + } + + #if os(tvOS) + func closePiP(wasPlaying: Bool) { + let item = avPlayer.currentItem + let time = avPlayer.currentTime() + + avPlayer.replaceCurrentItem(with: nil) + + guard !item.isNil else { + return + } + + avPlayer.seek(to: time) + avPlayer.replaceCurrentItem(with: item) + + guard wasPlaying else { + return + } + + DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in + self?.play() + } + } + #else + func closePiP(wasPlaying: Bool) { + controller?.playerView.player = nil + controller?.playerView.player = avPlayer + + guard wasPlaying else { + return + } + + DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in + self?.play() + } + } + #endif + + func updateControls() {} + func startControlsUpdates() {} + func stopControlsUpdates() {} + func setNeedsDrawing(_: Bool) {} + + private func loadSingleAsset( + _ url: URL, + stream: Stream, + of video: Video, + preservingTime: Bool = false + ) { + asset?.cancelLoading() + asset = AVURLAsset(url: url) + asset?.loadValuesAsynchronously(forKeys: Self.assetKeysToLoad) { [weak self] in + var error: NSError? + switch self?.asset?.statusOfValue(forKey: "duration", error: &error) { + case .loaded: + DispatchQueue.main.async { [weak self] in + self?.insertPlayerItem(stream, for: video, preservingTime: preservingTime) + } + case .failed: + DispatchQueue.main.async { [weak self] in + self?.model.playerError = error + } + default: + return + } + } + } + + private func loadComposition( + _ stream: Stream, + of video: Video, + preservingTime: Bool = false + ) { + loadedCompositionAssets = [] + loadCompositionAsset(stream.audioAsset, stream: stream, type: .audio, of: video, preservingTime: preservingTime, model: model) + loadCompositionAsset(stream.videoAsset, stream: stream, type: .video, of: video, preservingTime: preservingTime, model: model) + } + + private func loadCompositionAsset( + _ asset: AVURLAsset, + stream: Stream, + type: AVMediaType, + of video: Video, + preservingTime: Bool = false, + model: PlayerModel + ) { + asset.loadValuesAsynchronously(forKeys: Self.assetKeysToLoad) { [weak self] in + guard let self = self else { + return + } + model.logger.info("loading \(type.rawValue) track") + + let assetTracks = asset.tracks(withMediaType: type) + + guard let compositionTrack = self.composition.addMutableTrack( + withMediaType: type, + preferredTrackID: kCMPersistentTrackID_Invalid + ) else { + model.logger.critical("composition \(type.rawValue) addMutableTrack FAILED") + return + } + + guard let assetTrack = assetTracks.first else { + model.logger.critical("asset \(type.rawValue) track FAILED") + return + } + + try! compositionTrack.insertTimeRange( + CMTimeRange(start: .zero, duration: CMTime.secondsInDefaultTimescale(video.length)), + of: assetTrack, + at: .zero + ) + + model.logger.critical("\(type.rawValue) LOADED") + + guard model.streamSelection == stream else { + model.logger.critical("IGNORING LOADED") + return + } + + self.loadedCompositionAssets.append(type) + + if self.loadedCompositionAssets.count == 2 { + self.insertPlayerItem(stream, for: video, preservingTime: preservingTime) + } + } + } + + private func insertPlayerItem( + _ stream: Stream, + for video: Video, + preservingTime: Bool = false + ) { + removeItemDidPlayToEndTimeObserver() + + model.playerItem = playerItem(stream) + guard model.playerItem != nil else { + return + } + + addItemDidPlayToEndTimeObserver() + attachMetadata(to: model.playerItem!, video: video, for: stream) + + DispatchQueue.main.async { + self.stream = stream + self.video = video + self.model.stream = stream + self.composition = AVMutableComposition() + self.asset = nil + } + + let startPlaying = { + #if !os(macOS) + try? AVAudioSession.sharedInstance().setActive(true) + #endif + + if self.isAutoplaying(self.model.playerItem!) { + DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in + guard let self = self else { + return + } + + if !preservingTime, + let segment = self.model.sponsorBlock.segments.first, + segment.start < 3, + self.model.lastSkipped.isNil + { + self.avPlayer.seek( + to: segment.endTime, + toleranceBefore: .secondsInDefaultTimescale(1), + toleranceAfter: .zero + ) { finished in + guard finished else { + return + } + + self.model.lastSkipped = segment + self.model.play() + } + } else { + self.model.play() + } + } + } + } + + let replaceItemAndSeek = { + guard video == self.model.currentVideo else { + return + } + self.avPlayer.replaceCurrentItem(with: self.model.playerItem) + self.seekToPreservedTime { finished in + guard finished else { + return + } + self.model.preservedTime = nil + + startPlaying() + } + } + + if preservingTime { + if model.preservedTime.isNil { + model.saveTime { + replaceItemAndSeek() + startPlaying() + } + } else { + replaceItemAndSeek() + startPlaying() + } + } else { + avPlayer.replaceCurrentItem(with: model.playerItem) + startPlaying() + } + } + + private func seekToPreservedTime(completionHandler: @escaping (Bool) -> Void = { _ in }) { + guard let time = model.preservedTime else { + return + } + + avPlayer.seek( + to: time, + toleranceBefore: .secondsInDefaultTimescale(1), + toleranceAfter: .zero, + completionHandler: completionHandler + ) + } + + private func playerItem(_: Stream) -> AVPlayerItem? { + if let asset = asset { + return AVPlayerItem(asset: asset) + } else { + return AVPlayerItem(asset: composition) + } + } + + private func attachMetadata(to item: AVPlayerItem, video: Video, for _: Stream? = nil) { + #if !os(macOS) + var externalMetadata = [ + makeMetadataItem(.commonIdentifierTitle, value: video.title), + makeMetadataItem(.quickTimeMetadataGenre, value: video.genre ?? ""), + makeMetadataItem(.commonIdentifierDescription, value: video.description ?? "") + ] + if let thumbnailData = try? Data(contentsOf: video.thumbnailURL(quality: .medium)!), + let image = UIImage(data: thumbnailData), + let pngData = image.pngData() + { + let artworkItem = makeMetadataItem(.commonIdentifierArtwork, value: pngData) + externalMetadata.append(artworkItem) + } + + item.externalMetadata = externalMetadata + #endif + + item.preferredForwardBufferDuration = 5 + + observePlayerItemStatus(item) + } + + #if !os(macOS) + private func makeMetadataItem(_ identifier: AVMetadataIdentifier, value: Any) -> AVMetadataItem { + let item = AVMutableMetadataItem() + + item.identifier = identifier + item.value = value as? NSCopying & NSObjectProtocol + item.extendedLanguageTag = "und" + + return item.copy() as! AVMetadataItem + } + #endif + + func isAutoplaying(_ item: AVPlayerItem) -> Bool { + avPlayer.currentItem == item + } + + private func observePlayerItemStatus(_ item: AVPlayerItem) { + statusObservation?.invalidate() + statusObservation = item.observe(\.status, options: [.old, .new]) { [weak self] playerItem, _ in + guard let self = self else { + return + } + + switch playerItem.status { + case .readyToPlay: + if self.isAutoplaying(playerItem) { + self.model.play() + } + case .failed: + self.model.playerError = item.error + + default: + return + } + } + } + + private func addItemDidPlayToEndTimeObserver() { + NotificationCenter.default.addObserver( + self, + selector: #selector(itemDidPlayToEndTime), + name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, + object: playerItem + ) + } + + private func removeItemDidPlayToEndTimeObserver() { + NotificationCenter.default.removeObserver( + self, + name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, + object: playerItem + ) + } + + @objc func itemDidPlayToEndTime() { + model.prepareCurrentItemForHistory(finished: true) + + if model.queue.isEmpty { + #if !os(macOS) + try? AVAudioSession.sharedInstance().setActive(false) + #endif + model.resetQueue() + #if os(tvOS) + controller?.playerView.dismiss(animated: false) { [weak self] in + self?.controller?.dismiss(animated: true) + } + #else + model.hide() + #endif + } else { + model.advanceToNextItem() + } + } + + private func addFrequentTimeObserver() { + let interval = CMTime.secondsInDefaultTimescale(0.5) + + frequentTimeObserver = avPlayer.addPeriodicTimeObserver( + forInterval: interval, + queue: .main + ) { [weak self] _ in + guard let self = self else { + return + } + + guard !self.model.currentItem.isNil else { + return + } + + self.controls.duration = self.playerItemDuration ?? .zero + self.controls.currentTime = self.currentTime ?? .zero + + #if !os(tvOS) + self.updateNowPlayingInfo() + #endif + + if let currentTime = self.currentTime { + self.model.handleSegments(at: currentTime) + } + } + } + + private func addInfrequentTimeObserver() { + let interval = CMTime.secondsInDefaultTimescale(5) + + infrequentTimeObserver = avPlayer.addPeriodicTimeObserver( + forInterval: interval, + queue: .main + ) { [weak self] _ in + guard let self = self else { + return + } + + guard !self.model.currentItem.isNil else { + return + } + + self.timeObserverThrottle.execute { + self.model.updateWatch() + } + } + } + + private func addPlayerTimeControlStatusObserver() { + playerTimeControlStatusObserver = avPlayer.observe(\.timeControlStatus) { [weak self] player, _ in + guard let self = self, + self.avPlayer == player + else { + return + } + + DispatchQueue.main.async { + self.controls.isPlaying = player.timeControlStatus == .playing + } + + if player.timeControlStatus != .waitingToPlayAtSpecifiedRate { + DispatchQueue.main.async { [weak self] in + self?.model.objectWillChange.send() + } + } + + if player.timeControlStatus == .playing, player.rate != self.model.currentRate { + player.rate = self.model.currentRate + } + + #if os(macOS) + if player.timeControlStatus == .playing { + ScreenSaverManager.shared.disable(reason: "Yattee is playing video") + } else { + ScreenSaverManager.shared.enable() + } + #endif + + self.timeObserverThrottle.execute { + self.model.updateWatch() + } + } + } + + private func updateCurrentArtwork() { + guard let thumbnailData = try? Data(contentsOf: model.currentItem.video.thumbnailURL(quality: .medium)!) else { + return + } + + #if os(macOS) + let image = NSImage(data: thumbnailData) + #else + let image = UIImage(data: thumbnailData) + #endif + + if image.isNil { + return + } + + currentArtwork = MPMediaItemArtwork(boundsSize: image!.size) { _ in image! } + } + + fileprivate func updateNowPlayingInfo() { + var nowPlayingInfo: [String: AnyObject] = [ + MPMediaItemPropertyTitle: model.currentItem.video.title as AnyObject, + MPMediaItemPropertyArtist: model.currentItem.video.author as AnyObject, + MPNowPlayingInfoPropertyIsLiveStream: model.currentItem.video.live as AnyObject, + MPNowPlayingInfoPropertyElapsedPlaybackTime: avPlayer.currentTime().seconds as AnyObject, + MPNowPlayingInfoPropertyPlaybackQueueCount: model.queue.count as AnyObject, + MPMediaItemPropertyMediaType: MPMediaType.anyVideo.rawValue as AnyObject + ] + + if !currentArtwork.isNil { + nowPlayingInfo[MPMediaItemPropertyArtwork] = currentArtwork as AnyObject + } + + if !model.currentItem.video.live { + let itemDuration = model.currentItem.videoDuration ?? model.currentItem.duration + let duration = itemDuration.isFinite ? Double(itemDuration) : nil + + if !duration.isNil { + nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration as AnyObject + } + } + + MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo + } +} diff --git a/Model/Player/Backends/MPVBackend.swift b/Model/Player/Backends/MPVBackend.swift new file mode 100644 index 00000000..3eb16b7c --- /dev/null +++ b/Model/Player/Backends/MPVBackend.swift @@ -0,0 +1,305 @@ +import AVFAudio +import CoreMedia +import Foundation +import Logging +import SwiftUI + +final class MPVBackend: PlayerBackend { + private var logger = Logger(label: "mpv-backend") + + var model: PlayerModel! + var controls: PlayerControlsModel! + + var stream: Stream? + var video: Video? + var currentTime: CMTime? + + var loadedVideo = false + var isLoadingVideo = true + + var isPlaying = true { didSet { + if isPlaying { + startClientUpdates() + } else { + stopControlsUpdates() + } + + updateControlsIsPlaying() + }} + var playerItemDuration: CMTime? + + var controller: MPVViewController! + var client: MPVClient! { didSet { client.backend = self } } + + private var clientTimer: RepeatingTimer! + + private var onFileLoaded: (() -> Void)? + + private var controlsUpdates = false + private var timeObserverThrottle = Throttle(interval: 2) + + init(model: PlayerModel, controls: PlayerControlsModel? = nil) { + self.model = model + self.controls = controls + + clientTimer = .init(timeInterval: 1) + clientTimer.eventHandler = getClientUpdates + } + + func bestPlayable(_ streams: [Stream]) -> Stream? { + streams.filter { $0.kind == .adaptive }.max { $0.resolution < $1.resolution } ?? + streams.first { $0.kind == .hls } ?? + streams.first + } + + func canPlay(_ stream: Stream) -> Bool { + stream.resolution != .unknown && stream.format != "AV1" + } + + func playStream(_ stream: Stream, of video: Video, preservingTime: Bool, upgrading _: Bool) { + let updateCurrentStream = { + DispatchQueue.main.async { [weak self] in + self?.stream = stream + self?.video = video + self?.model.stream = stream + } + } + + let startPlaying = { + #if !os(macOS) + try? AVAudioSession.sharedInstance().setActive(true) + #endif + + DispatchQueue.main.async { [weak self] in + guard let self = self else { + return + } + + self.startClientUpdates() + + if !preservingTime, + let segment = self.model.sponsorBlock.segments.first, + segment.start < 3, + self.model.lastSkipped.isNil + { + self.seek(to: segment.endTime) { finished in + guard finished else { + return + } + + self.model.lastSkipped = segment + self.play() + } + } else { + self.play() + } + } + } + + let replaceItem: (CMTime?) -> Void = { [weak self] time in + guard let self = self else { + return + } + + self.stop() + + if let url = stream.singleAssetURL { + self.onFileLoaded = { [weak self] in + self?.setIsLoadingVideo(false) + updateCurrentStream() + startPlaying() + } + + self.client.loadFile(url, time: time) { [weak self] _ in + self?.setIsLoadingVideo(true) + } + } else { + self.onFileLoaded = { [weak self] in + self?.client.addAudio(stream.audioAsset.url) { _ in + self?.setIsLoadingVideo(false) + updateCurrentStream() + startPlaying() + } + } + + self.client.loadFile(stream.videoAsset.url, time: time) { [weak self] _ in + self?.setIsLoadingVideo(true) + self?.pause() + } + } + } + + if preservingTime { + if model.preservedTime.isNil { + model.saveTime { + replaceItem(self.model.preservedTime) + } + } else { + replaceItem(self.model.preservedTime) + } + } else { + replaceItem(nil) + } + } + + func play() { + isPlaying = true + startClientUpdates() + + client?.play() + } + + func pause() { + isPlaying = false + stopClientUpdates() + + client?.pause() + } + + func togglePlay() { + isPlaying ? pause() : play() + } + + func stop() { + client?.stop() + } + + func seek(to time: CMTime, completionHandler: ((Bool) -> Void)?) { + client.seek(to: time) { [weak self] _ in + self?.getClientUpdates() + self?.updateControls() + completionHandler?(true) + } + } + + func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + client.seek(relative: time) { [weak self] _ in + self?.getClientUpdates() + self?.updateControls() + completionHandler?(true) + } + } + + func setRate(_: Float) { + // TODO: Implement rate change + } + + func closeItem() {} + + func enterFullScreen() {} + + func exitFullScreen() {} + + func closePiP(wasPlaying _: Bool) {} + + func updateControls() { + DispatchQueue.main.async { [weak self] in + self?.logger.info("updating controls") + self?.controls.currentTime = self?.currentTime ?? .zero + self?.controls.duration = self?.playerItemDuration ?? .zero + } + } + + func startControlsUpdates() { + self.logger.info("starting controls updates") + controlsUpdates = true + } + + func stopControlsUpdates() { + self.logger.info("stopping controls updates") + controlsUpdates = false + } + + func startClientUpdates() { + clientTimer.resume() + } + + private func getClientUpdates() { + self.logger.info("getting client updates") + + currentTime = client?.currentTime + playerItemDuration = client?.duration + + if controlsUpdates { + updateControls() + } + + if let currentTime = currentTime { + model.handleSegments(at: currentTime) + } + + self.timeObserverThrottle.execute { + self.model.updateWatch() + } + } + + private func stopClientUpdates() { + clientTimer.suspend() + } + + private func updateControlsIsPlaying() { + DispatchQueue.main.async { [weak self] in + self?.controls.isPlaying = self?.isPlaying ?? false + } + } + + private func setIsLoadingVideo(_ value: Bool) { + isLoadingVideo = value + DispatchQueue.main.async { [weak self] in + self?.controls.isLoadingVideo = value + } + } + + func handle(_ event: UnsafePointer!) { + logger.info("\(String(cString: mpv_event_name(event.pointee.event_id)))") + + switch event.pointee.event_id { + case MPV_EVENT_SHUTDOWN: + mpv_destroy(client.mpv) + client.mpv = nil + + case MPV_EVENT_LOG_MESSAGE: + let logmsg = UnsafeMutablePointer(OpaquePointer(event.pointee.data)) + logger.info(.init(stringLiteral: "log: \(String(cString: (logmsg!.pointee.prefix)!)), " + + "\(String(cString: (logmsg!.pointee.level)!)), " + + "\(String(cString: (logmsg!.pointee.text)!))")) + + case MPV_EVENT_FILE_LOADED: + onFileLoaded?() + onFileLoaded = nil + + case MPV_EVENT_END_FILE: + break + // DispatchQueue.main.async { [weak self] in + // TODO: handle EOF + // self?.handleEndOfFile(event) + // } + + default: + logger.info(.init(stringLiteral: "event: \(String(cString: mpv_event_name(event.pointee.event_id)))")) + } + } + + func handleEndOfFile(_: UnsafePointer!) { + guard !isLoadingVideo else { + return + } + + model.prepareCurrentItemForHistory(finished: true) + + if model.queue.isEmpty { + #if !os(macOS) + try? AVAudioSession.sharedInstance().setActive(false) + #endif + model.resetQueue() + + model.hide() + } else { + model.advanceToNextItem() + } + } + + func setNeedsDrawing(_ needsDrawing: Bool) { + client?.setNeedsDrawing(needsDrawing) + } +} diff --git a/Model/Player/Backends/MPVClient.swift b/Model/Player/Backends/MPVClient.swift new file mode 100644 index 00000000..94450e01 --- /dev/null +++ b/Model/Player/Backends/MPVClient.swift @@ -0,0 +1,229 @@ +import Foundation +import Logging +#if !os(macOS) + import CoreMedia + import Siesta + import UIKit +#endif + +final class MPVClient: ObservableObject { + private var logger = Logger(label: "mpv-client") + + var mpv: OpaquePointer! + var mpvGL: OpaquePointer! + var queue: DispatchQueue! + var glView: MPVOGLView! + var backend: MPVBackend! + + func create(frame: CGRect) -> MPVOGLView { + glView = MPVOGLView(frame: frame) + + mpv = mpv_create() + if mpv == nil { + print("failed creating context\n") + exit(1) + } + + checkError(mpv_request_log_messages(mpv, "warn")) + checkError(mpv_initialize(mpv)) + checkError(mpv_set_option_string(mpv, "vo", "libmpv")) + checkError(mpv_set_option_string(mpv, "hwdec", "yes")) + + checkError(mpv_set_option_string(mpv, "override-display-fps", "\(UIScreen.main.maximumFramesPerSecond)")) + checkError(mpv_set_option_string(mpv, "video-sync", "display-resample")) + + let api = UnsafeMutableRawPointer(mutating: (MPV_RENDER_API_TYPE_OPENGL as NSString).utf8String) + var initParams = mpv_opengl_init_params( + get_proc_address: getProcAddress(_:_:), + get_proc_address_ctx: nil, + extra_exts: nil + ) + + withUnsafeMutablePointer(to: &initParams) { initParams in + var params = [ + mpv_render_param(type: MPV_RENDER_PARAM_API_TYPE, data: api), + mpv_render_param(type: MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, data: initParams), + mpv_render_param() + ] + + var mpvGL: OpaquePointer? + + if mpv_render_context_create(&mpvGL, mpv, ¶ms) < 0 { + puts("failed to initialize mpv GL context") + exit(1) + } + + glView.mpvGL = UnsafeMutableRawPointer(mpvGL) + + mpv_render_context_set_update_callback( + mpvGL, + glUpdate(_:), + UnsafeMutableRawPointer(Unmanaged.passUnretained(glView).toOpaque()) + ) + } + + queue = DispatchQueue(label: "mpv", qos: .background) + queue!.async { + mpv_set_wakeup_callback(self.mpv, wakeUp, UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())) + } + + return glView + } + + func readEvents() { + queue?.async { [self] in + while self.mpv != nil { + let event = mpv_wait_event(self.mpv, 0) + if event!.pointee.event_id == MPV_EVENT_NONE { + break + } + backend.handle(event) + } + } + } + + func loadFile(_ url: URL, time: CMTime? = nil, completionHandler: ((Int32) -> Void)? = nil) { + var args = [url.absoluteString] + if let time = time { + args.append("replace") + args.append("start=\(Int(time.seconds))") + } + + command("loadfile", args: args, returnValueCallback: completionHandler) + } + + func addAudio(_ url: URL, completionHandler: ((Int32) -> Void)? = nil) { + command("audio-add", args: [url.absoluteString], returnValueCallback: completionHandler) + } + + func play() { + setFlagAsync("pause", false) + } + + func pause() { + setFlagAsync("pause", true) + } + + func togglePlay() { + command("cycle", args: ["pause"]) + } + + func stop() { + command("stop") + } + + var currentTime: CMTime { + CMTime.secondsInDefaultTimescale(getDouble("time-pos")) + } + + var duration: CMTime { + CMTime.secondsInDefaultTimescale(getDouble("duration")) + } + + func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + command("seek", args: [String(time.seconds)]) { _ in + completionHandler?(true) + } + } + + func seek(to time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + command("seek", args: [String(time.seconds), "absolute"]) { _ in + completionHandler?(true) + } + } + + func setSize(_ width: Double, _ height: Double) { + logger.info("setting player size to \(width),\(height)") + #if !os(macOS) + guard width <= UIScreen.main.bounds.width, height <= UIScreen.main.bounds.height else { + logger.info("requested size is greater than screen size, ignoring") + return + } + #endif + + glView?.frame = CGRect(x: 0, y: 0, width: width, height: height) + } + + func setNeedsDrawing(_ needsDrawing: Bool) { + logger.info("needs drawing: \(needsDrawing)") + glView.needsDrawing = needsDrawing + } + + func command( + _ command: String, + args: [String?] = [], + checkForErrors: Bool = true, + returnValueCallback: ((Int32) -> Void)? = nil + ) { + guard mpv != nil else { + return + } + var cargs = makeCArgs(command, args).map { $0.flatMap { UnsafePointer(strdup($0)) } } + defer { + for ptr in cargs where ptr != nil { + free(UnsafeMutablePointer(mutating: ptr!)) + } + } + logger.info("\(command) -- \(args)") + let returnValue = mpv_command(mpv, &cargs) + if checkForErrors { + checkError(returnValue) + } + if let cb = returnValueCallback { + cb(returnValue) + } + } + + private func setFlagAsync(_ name: String, _ flag: Bool) { + var data: Int = flag ? 1 : 0 + mpv_set_property_async(mpv, 0, name, MPV_FORMAT_FLAG, &data) + } + + private func getDouble(_ name: String) -> Double { + var data = Double() + mpv_get_property(mpv, name, MPV_FORMAT_DOUBLE, &data) + return data + } + + private func makeCArgs(_ command: String, _ args: [String?]) -> [String?] { + if !args.isEmpty, args.last == nil { + fatalError("Command do not need a nil suffix") + } + + var strArgs = args + strArgs.insert(command, at: 0) + strArgs.append(nil) + + return strArgs + } + + func checkError(_ status: CInt) { + if status < 0 { + logger.error(.init(stringLiteral: "MPV API error: \(String(cString: mpv_error_string(status)))\n")) + } + } +} + +private func getProcAddress(_: UnsafeMutableRawPointer?, _ name: UnsafePointer?) -> UnsafeMutableRawPointer? { + let symbolName = CFStringCreateWithCString(kCFAllocatorDefault, name, CFStringBuiltInEncodings.ASCII.rawValue) + let addr = CFBundleGetFunctionPointerForName(CFBundleGetBundleWithIdentifier("com.apple.opengles" as CFString), symbolName) + + return addr +} + +private func glUpdate(_ ctx: UnsafeMutableRawPointer?) { + let glView = unsafeBitCast(ctx, to: MPVOGLView.self) + + guard glView.needsDrawing else { + return + } + + DispatchQueue.main.async { + glView.setNeedsDisplay() + } +} + +private func wakeUp(_ context: UnsafeMutableRawPointer?) { + let client = unsafeBitCast(context, to: MPVClient.self) + client.readEvents() +} diff --git a/Model/Player/Backends/PlayerBackend.swift b/Model/Player/Backends/PlayerBackend.swift new file mode 100644 index 00000000..2745cf5e --- /dev/null +++ b/Model/Player/Backends/PlayerBackend.swift @@ -0,0 +1,67 @@ +import CoreMedia +import Defaults +import Foundation + +protocol PlayerBackend { + var model: PlayerModel! { get set } + var controls: PlayerControlsModel! { get set } + + var stream: Stream? { get set } + var video: Video? { get set } + var currentTime: CMTime? { get } + + var loadedVideo: Bool { get } + var isLoadingVideo: Bool { get } + + var isPlaying: Bool { get } + var playerItemDuration: CMTime? { get } + + func bestPlayable(_ streams: [Stream]) -> Stream? + func canPlay(_ stream: Stream) -> Bool + + func playStream( + _ stream: Stream, + of video: Video, + preservingTime: Bool, + upgrading: Bool + ) + + func play() + func pause() + func togglePlay() + + func stop() + + func seek(to time: CMTime, completionHandler: ((Bool) -> Void)?) + func seek(to seconds: Double, completionHandler: ((Bool) -> Void)?) + func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)?) + + func setRate(_ rate: Float) + + func closeItem() + + func enterFullScreen() + func exitFullScreen() + + func closePiP(wasPlaying: Bool) + + func updateControls() + func startControlsUpdates() + func stopControlsUpdates() + + func setNeedsDrawing(_ needsDrawing: Bool) +} + +extension PlayerBackend { + func seek(to time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + seek(to: time, completionHandler: completionHandler) + } + + func seek(to seconds: Double, completionHandler: ((Bool) -> Void)? = nil) { + seek(to: .secondsInDefaultTimescale(seconds), completionHandler: completionHandler) + } + + func seek(relative time: CMTime, completionHandler: ((Bool) -> Void)? = nil) { + seek(relative: time, completionHandler: completionHandler) + } +} diff --git a/Model/Player/Backends/PlayerBackendType.swift b/Model/Player/Backends/PlayerBackendType.swift new file mode 100644 index 00000000..51ffd73f --- /dev/null +++ b/Model/Player/Backends/PlayerBackendType.swift @@ -0,0 +1,16 @@ +import Defaults +import Foundation + +enum PlayerBackendType: String, CaseIterable, Defaults.Serializable { + case mpv + case appleAVPlayer + + var label: String { + switch self { + case .mpv: + return "MPV" + case .appleAVPlayer: + return "AVPlayer" + } + } +} diff --git a/Model/Player/PlayerControlsModel.swift b/Model/Player/PlayerControlsModel.swift new file mode 100644 index 00000000..fcac2062 --- /dev/null +++ b/Model/Player/PlayerControlsModel.swift @@ -0,0 +1,114 @@ +import CoreMedia +import Foundation +import SwiftUI + +final class PlayerControlsModel: ObservableObject { + @Published var isLoadingVideo = true + @Published var isPlaying = true + @Published var currentTime = CMTime.zero + @Published var duration = CMTime.zero + @Published var presentingControls = false { didSet { handlePresentationChange() } } + @Published var timer: Timer? + @Published var playingFullscreen = false + + var player: PlayerModel! + + var playbackTime: String { + guard let current = currentTime.seconds.formattedAsPlaybackTime(), + let duration = duration.seconds.formattedAsPlaybackTime() + else { + return "--:-- / --:--" + } + + var withoutSegments = "" + if let withoutSegmentsDuration = playerItemDurationWithoutSponsorSegments, + self.duration.seconds != withoutSegmentsDuration + { + withoutSegments = " (\(withoutSegmentsDuration.formattedAsPlaybackTime() ?? "--:--"))" + } + + return "\(current) / \(duration)\(withoutSegments)" + } + + var playerItemDurationWithoutSponsorSegments: Double? { + guard let duration = player.playerItemDurationWithoutSponsorSegments else { + return nil + } + + return duration.seconds + } + + func handlePresentationChange() { + if presentingControls { + DispatchQueue.main.async { [weak self] in + self?.player.backend.startControlsUpdates() + self?.resetTimer() + } + } else { + player.backend.stopControlsUpdates() + timer?.invalidate() + timer = nil + } + } + + func show() { + withAnimation(PlayerControls.animation) { + player.backend.updateControls() + presentingControls = true + } + } + + func hide() { + withAnimation(PlayerControls.animation) { + presentingControls = false + } + } + + func toggle() { + withAnimation(PlayerControls.animation) { + if !presentingControls { + player.backend.updateControls() + } + + presentingControls.toggle() + } + } + + func toggleFullscreen(_ value: Bool) { + withAnimation(Animation.easeOut) { + resetTimer() + withAnimation(PlayerControls.animation) { + playingFullscreen = !value + } + + if playingFullscreen { + guard !(UIApplication.shared.windows.first?.windowScene?.interfaceOrientation.isLandscape ?? true) else { + return + } + Orientation.lockOrientation(.landscape, andRotateTo: .landscapeRight) + } else { + Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait) + } + } + } + + func reset() { + currentTime = .zero + duration = .zero + } + + func resetTimer() { + removeTimer() + timer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: false) { _ in + withAnimation(PlayerControls.animation) { [weak self] in + self?.presentingControls = false + self?.player.backend.stopControlsUpdates() + } + } + } + + func removeTimer() { + timer?.invalidate() + timer = nil + } +} diff --git a/Model/Player/PlayerModel.swift b/Model/Player/PlayerModel.swift index 852bf77b..b84b3d7b 100644 --- a/Model/Player/PlayerModel.swift +++ b/Model/Player/PlayerModel.swift @@ -16,18 +16,35 @@ import SwiftyJSON final class PlayerModel: ObservableObject { static let availableRates: [Float] = [0.5, 0.67, 0.8, 1, 1.25, 1.5, 2] - static let assetKeysToLoad = ["tracks", "playable", "duration"] let logger = Logger(label: "stream.yattee.app") - private(set) var player = AVPlayer() - var playerView = Player() - var controller: PlayerViewController? + var avPlayerView = AVPlayerView() var playerItem: AVPlayerItem? - @Published var presentingPlayer = false { didSet { handlePresentationChange() } } + var mpvPlayerView = MPVPlayerView() + @Published var presentingPlayer = false { didSet { handlePresentationChange() } } + @Published var activeBackend = PlayerBackendType.mpv + + var avPlayerBackend: AVPlayerBackend! + var mpvBackend: MPVBackend! + + var backends: [PlayerBackend] { + [avPlayerBackend, mpvBackend] + } + + var backend: PlayerBackend! { + switch activeBackend { + case .mpv: + return mpvBackend + case .appleAVPlayer: + return avPlayerBackend + } + } + + @Published var playerSize: CGSize = .zero @Published var stream: Stream? - @Published var currentRate: Float = 1.0 { didSet { player.rate = currentRate } } + @Published var currentRate: Float = 1.0 { didSet { backend.setRate(currentRate) } } @Published var availableStreams = [Stream]() { didSet { handleAvailableStreamsChange() } } @Published var streamSelection: Stream? { didSet { rebuildTVMenu() } } @@ -53,24 +70,15 @@ final class PlayerModel: ObservableObject { var accounts: AccountsModel var comments: CommentsModel - - var asset: AVURLAsset? - var composition = AVMutableComposition() - var loadedCompositionAssets = [AVMediaType]() - + var controls: PlayerControlsModel { didSet { + backends.forEach { backend in + var backend = backend + backend.controls = controls + } + }} var context: NSManagedObjectContext = PersistenceController.shared.container.viewContext - private var currentArtwork: MPMediaItemArtwork? - private var frequentTimeObserver: Any? - private var infrequentTimeObserver: Any? - private var playerTimeControlStatusObserver: Any? - - private var statusObservation: NSKeyValueObservation? - - private var timeObserverThrottle = Throttle(interval: 2) - - var playingInPictureInPicture = false - var playingFullscreen = false + @Published var playingInPictureInPicture = false @Published var presentingErrorDetails = false var playerError: Error? { didSet { @@ -89,13 +97,15 @@ final class PlayerModel: ObservableObject { @Default(.closePiPAndOpenPlayerOnEnteringForeground) var closePiPAndOpenPlayerOnEnteringForeground #endif - init(accounts: AccountsModel? = nil, comments: CommentsModel? = nil) { + init(accounts: AccountsModel? = nil, comments: CommentsModel? = nil, controls: PlayerControlsModel? = nil) { self.accounts = accounts ?? AccountsModel() self.comments = comments ?? CommentsModel() + self.controls = controls ?? PlayerControlsModel() - addFrequentTimeObserver() - addInfrequentTimeObserver() - addPlayerTimeControlStatusObserver() + self.avPlayerBackend = AVPlayerBackend(model: self, controls: controls) + self.mpvBackend = MPVBackend(model: self) + + self.activeBackend = Defaults[.activeBackend] } func show() { @@ -137,11 +147,25 @@ final class PlayerModel: ObservableObject { return false } - return player.currentItem == nil || time == nil || !time!.isValid + return backend.isLoadingVideo } var isPlaying: Bool { - player.timeControlStatus == .playing + backend.isPlaying + } + + var playerItemDuration: CMTime? { + backend.playerItemDuration + } + + var playerItemDurationWithoutSponsorSegments: CMTime? { + (backend.playerItemDuration ?? .zero) - .secondsInDefaultTimescale( + sponsorBlock.segments.reduce(0) { $0 + $1.duration } + ) + } + + var videoDuration: TimeInterval? { + currentItem?.duration ?? currentVideo?.length ?? playerItemDuration?.seconds } var time: CMTime? { @@ -152,32 +176,16 @@ final class PlayerModel: ObservableObject { currentVideo?.live ?? false } - var playerItemDuration: CMTime? { - player.currentItem?.asset.duration - } - - var videoDuration: TimeInterval? { - currentItem?.duration ?? currentVideo?.length ?? player.currentItem?.asset.duration.seconds - } - func togglePlay() { - isPlaying ? pause() : play() + backend.togglePlay() } func play() { - guard player.timeControlStatus != .playing else { - return - } - - player.play() + backend.play() } func pause() { - guard player.timeControlStatus != .paused else { - return - } - - player.pause() + backend.pause() } func play(_ video: Video, at time: TimeInterval? = nil, inNavigationView: Bool = false) { @@ -208,28 +216,37 @@ final class PlayerModel: ObservableObject { self?.sponsorBlock.loadSegments( videoID: video.videoID, categories: Defaults[.sponsorBlockCategories] - ) + ) { + if Defaults[.showChannelSubscribers] { + self?.loadCurrentItemChannelDetails() + } + } } } - if let url = stream.singleAssetURL { - logger.info("playing stream with one asset\(stream.kind == .hls ? " (HLS)" : ""): \(url)") - loadSingleAsset(url, stream: stream, of: video, preservingTime: preservingTime) - } else { - logger.info("playing stream with many assets:") - logger.info("composition audio asset: \(stream.audioAsset.url)") - logger.info("composition video asset: \(stream.videoAsset.url)") + controls.reset() - loadComposition(stream, of: video, preservingTime: preservingTime) + backend.playStream( + stream, + of: video, + preservingTime: preservingTime, + upgrading: upgrading + ) + } + + func saveTime(completionHandler: @escaping () -> Void = {}) { + guard let currentTime = backend.currentTime, currentTime.seconds > 0 else { + return } - if !upgrading { - updateCurrentArtwork() + DispatchQueue.main.async { [weak self] in + self?.preservedTime = currentTime + completionHandler() } } - func upgradeToStream(_ stream: Stream) { - if !self.stream.isNil, self.stream != stream { + func upgradeToStream(_ stream: Stream, force: Bool = false) { + if !self.stream.isNil, force || self.stream != stream { playStream(stream, of: currentVideo!, preservingTime: true, upgrading: true) } } @@ -254,6 +271,9 @@ final class PlayerModel: ObservableObject { } private func handlePresentationChange() { + backend.setNeedsDrawing(presentingPlayer) + controls.hide() + if presentingPlayer, closePiPOnOpeningPlayer, playingInPictureInPicture { DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in self?.closePiP() @@ -266,7 +286,7 @@ final class PlayerModel: ObservableObject { } } - if !presentingPlayer, !pauseOnHidingPlayer, isPlaying { + if !presentingPlayer, !pauseOnHidingPlayer, backend.isPlaying { DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in self?.play() } @@ -281,423 +301,49 @@ final class PlayerModel: ObservableObject { } } - private func insertPlayerItem( - _ stream: Stream, - for video: Video, - preservingTime: Bool = false - ) { - removeItemDidPlayToEndTimeObserver() + func changeActiveBackend(from: PlayerBackendType, to: PlayerBackendType) { + Defaults[.activeBackend] = to + self.activeBackend = to - playerItem = playerItem(stream) - guard playerItem != nil else { + guard var stream = stream else { return } - addItemDidPlayToEndTimeObserver() - attachMetadata(to: playerItem!, video: video, for: stream) + inactiveBackends().forEach { $0.pause() } - DispatchQueue.main.async { [weak self] in - guard let self = self else { - return - } + let fromBackend: PlayerBackend = from == .appleAVPlayer ? avPlayerBackend : mpvBackend + let toBackend: PlayerBackend = to == .appleAVPlayer ? avPlayerBackend : mpvBackend - self.stream = stream - self.composition = AVMutableComposition() - self.asset = nil - } - - let startPlaying = { - #if !os(macOS) - try? AVAudioSession.sharedInstance().setActive(true) - #endif - - if self.isAutoplaying(self.playerItem!) { - DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in - guard let self = self else { - return - } - - if !preservingTime, - let segment = self.sponsorBlock.segments.first, - segment.start < 3, - self.lastSkipped.isNil - { - self.player.seek( - to: segment.endTime, - toleranceBefore: .secondsInDefaultTimescale(1), - toleranceAfter: .zero - ) { finished in - guard finished else { - return - } - - self.lastSkipped = segment - self.play() - } - } else { - self.play() - } - } - } - } - - let replaceItemAndSeek = { - guard video == self.currentVideo else { - return - } - self.player.replaceCurrentItem(with: self.playerItem) - self.seekToPreservedTime { finished in + if let stream = toBackend.stream, toBackend.video == fromBackend.video { + toBackend.seek(to: fromBackend.currentTime?.seconds ?? .zero) { finished in guard finished else { return } - self.preservedTime = nil - - startPlaying() - } - } - - if preservingTime { - if preservedTime.isNil { - saveTime { - replaceItemAndSeek() - startPlaying() - } - } else { - replaceItemAndSeek() - startPlaying() - } - } else { - player.replaceCurrentItem(with: playerItem) - startPlaying() - } - } - - private func loadSingleAsset( - _ url: URL, - stream: Stream, - of video: Video, - preservingTime: Bool = false - ) { - asset?.cancelLoading() - asset = AVURLAsset(url: url) - asset?.loadValuesAsynchronously(forKeys: Self.assetKeysToLoad) { [weak self] in - var error: NSError? - - switch self?.asset?.statusOfValue(forKey: "duration", error: &error) { - case .loaded: - DispatchQueue.main.async { [weak self] in - self?.insertPlayerItem(stream, for: video, preservingTime: preservingTime) - } - case .failed: - DispatchQueue.main.async { [weak self] in - self?.playerError = error - } - default: - return - } - } - } - - private func loadComposition( - _ stream: Stream, - of video: Video, - preservingTime: Bool = false - ) { - loadedCompositionAssets = [] - loadCompositionAsset(stream.audioAsset, stream: stream, type: .audio, of: video, preservingTime: preservingTime) - loadCompositionAsset(stream.videoAsset, stream: stream, type: .video, of: video, preservingTime: preservingTime) - } - - private func loadCompositionAsset( - _ asset: AVURLAsset, - stream: Stream, - type: AVMediaType, - of video: Video, - preservingTime: Bool = false - ) { - asset.loadValuesAsynchronously(forKeys: Self.assetKeysToLoad) { [weak self] in - guard let self = self else { - return - } - self.logger.info("loading \(type.rawValue) track") - - let assetTracks = asset.tracks(withMediaType: type) - - guard let compositionTrack = self.composition.addMutableTrack( - withMediaType: type, - preferredTrackID: kCMPersistentTrackID_Invalid - ) else { - self.logger.critical("composition \(type.rawValue) addMutableTrack FAILED") - return + toBackend.play() } - guard let assetTrack = assetTracks.first else { - self.logger.critical("asset \(type.rawValue) track FAILED") - return - } + self.stream = stream + streamSelection = stream - try! compositionTrack.insertTimeRange( - CMTimeRange(start: .zero, duration: CMTime.secondsInDefaultTimescale(video.length)), - of: assetTrack, - at: .zero - ) - - self.logger.critical("\(type.rawValue) LOADED") - - guard self.streamSelection == stream else { - self.logger.critical("IGNORING LOADED") - return - } - - self.loadedCompositionAssets.append(type) - - if self.loadedCompositionAssets.count == 2 { - self.insertPlayerItem(stream, for: video, preservingTime: preservingTime) - } - } - } - - private func playerItem(_: Stream) -> AVPlayerItem? { - if let asset = asset { - return AVPlayerItem(asset: asset) - } else { - return AVPlayerItem(asset: composition) - } - } - - private func attachMetadata(to item: AVPlayerItem, video: Video, for _: Stream? = nil) { - #if !os(macOS) - var externalMetadata = [ - makeMetadataItem(.commonIdentifierTitle, value: video.title), - makeMetadataItem(.quickTimeMetadataGenre, value: video.genre ?? ""), - makeMetadataItem(.commonIdentifierDescription, value: video.description ?? "") - ] - if let thumbnailData = try? Data(contentsOf: video.thumbnailURL(quality: .medium)!), - let image = UIImage(data: thumbnailData), - let pngData = image.pngData() - { - let artworkItem = makeMetadataItem(.commonIdentifierArtwork, value: pngData) - externalMetadata.append(artworkItem) - } - - item.externalMetadata = externalMetadata - #endif - - item.preferredForwardBufferDuration = 5 - - observePlayerItemStatus(item) - } - - private func observePlayerItemStatus(_ item: AVPlayerItem) { - statusObservation?.invalidate() - statusObservation = item.observe(\.status, options: [.old, .new]) { [weak self] playerItem, _ in - guard let self = self else { - return - } - - switch playerItem.status { - case .readyToPlay: - if self.isAutoplaying(playerItem) { - self.play() - } - case .failed: - self.playerError = item.error - - default: - return - } - } - } - - #if !os(macOS) - private func makeMetadataItem(_ identifier: AVMetadataIdentifier, value: Any) -> AVMetadataItem { - let item = AVMutableMetadataItem() - - item.identifier = identifier - item.value = value as? NSCopying & NSObjectProtocol - item.extendedLanguageTag = "und" - - return item.copy() as! AVMetadataItem - } - #endif - - private func addItemDidPlayToEndTimeObserver() { - NotificationCenter.default.addObserver( - self, - selector: #selector(itemDidPlayToEndTime), - name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, - object: playerItem - ) - } - - private func removeItemDidPlayToEndTimeObserver() { - NotificationCenter.default.removeObserver( - self, - name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, - object: playerItem - ) - } - - @objc func itemDidPlayToEndTime() { - prepareCurrentItemForHistory(finished: true) - - if queue.isEmpty { - #if !os(macOS) - try? AVAudioSession.sharedInstance().setActive(false) - #endif - resetQueue() - #if os(tvOS) - controller?.playerView.dismiss(animated: false) { [weak self] in - self?.controller?.dismiss(animated: true) - } - #endif - } else { - advanceToNextItem() - } - } - - private func saveTime(completionHandler: @escaping () -> Void = {}) { - let currentTime = player.currentTime() - - guard currentTime.seconds > 0 else { return } - DispatchQueue.main.async { [weak self] in - self?.preservedTime = currentTime - completionHandler() - } - } - - private func seekToPreservedTime(completionHandler: @escaping (Bool) -> Void = { _ in }) { - guard let time = preservedTime else { - return - } - - player.seek( - to: time, - toleranceBefore: .secondsInDefaultTimescale(1), - toleranceAfter: .zero, - completionHandler: completionHandler - ) - } - - private func addFrequentTimeObserver() { - let interval = CMTime.secondsInDefaultTimescale(0.5) - - frequentTimeObserver = player.addPeriodicTimeObserver( - forInterval: interval, - queue: .main - ) { [weak self] _ in - guard let self = self else { + if !backend.canPlay(stream) { + guard let preferredStream = preferredStream(availableStreams) else { return } - guard !self.currentItem.isNil else { - return - } + stream = preferredStream + streamSelection = preferredStream + } - #if !os(tvOS) - self.updateNowPlayingInfo() - #endif - - self.handleSegments(at: self.player.currentTime()) + DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in + self?.upgradeToStream(stream, force: true) } } - private func addInfrequentTimeObserver() { - let interval = CMTime.secondsInDefaultTimescale(5) - - infrequentTimeObserver = player.addPeriodicTimeObserver( - forInterval: interval, - queue: .main - ) { [weak self] _ in - guard let self = self else { - return - } - - guard !self.currentItem.isNil else { - return - } - - self.timeObserverThrottle.execute { - self.updateWatch() - } - } - } - - private func addPlayerTimeControlStatusObserver() { - playerTimeControlStatusObserver = player.observe(\.timeControlStatus) { [weak self] player, _ in - guard let self = self, - self.player == player - else { - return - } - - if player.timeControlStatus != .waitingToPlayAtSpecifiedRate { - self.objectWillChange.send() - } - - if player.timeControlStatus == .playing, player.rate != self.currentRate { - player.rate = self.currentRate - } - - #if os(macOS) - if player.timeControlStatus == .playing { - ScreenSaverManager.shared.disable(reason: "Yattee is playing video") - } else { - ScreenSaverManager.shared.enable() - } - #endif - - self.timeObserverThrottle.execute { - self.updateWatch() - } - } - } - - fileprivate func updateNowPlayingInfo() { - var nowPlayingInfo: [String: AnyObject] = [ - MPMediaItemPropertyTitle: currentItem.video.title as AnyObject, - MPMediaItemPropertyArtist: currentItem.video.author as AnyObject, - MPNowPlayingInfoPropertyIsLiveStream: currentItem.video.live as AnyObject, - MPNowPlayingInfoPropertyElapsedPlaybackTime: player.currentTime().seconds as AnyObject, - MPNowPlayingInfoPropertyPlaybackQueueCount: queue.count as AnyObject, - MPMediaItemPropertyMediaType: MPMediaType.anyVideo.rawValue as AnyObject - ] - - if !currentArtwork.isNil { - nowPlayingInfo[MPMediaItemPropertyArtwork] = currentArtwork as AnyObject - } - - if !currentItem.video.live { - let itemDuration = currentItem.videoDuration ?? currentItem.duration - let duration = itemDuration.isFinite ? Double(itemDuration) : nil - - if !duration.isNil { - nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration as AnyObject - } - } - - MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo - } - - private func updateCurrentArtwork() { - guard let thumbnailData = try? Data(contentsOf: currentItem.video.thumbnailURL(quality: .medium)!) else { - return - } - - #if os(macOS) - let image = NSImage(data: thumbnailData) - #else - let image = UIImage(data: thumbnailData) - #endif - - if image.isNil { - return - } - - currentArtwork = MPMediaItemArtwork(boundsSize: image!.size) { _ in image! } + private func inactiveBackends() -> [PlayerBackend] { + [activeBackend == PlayerBackendType.mpv ? avPlayerBackend : mpvBackend] } func rateLabel(_ rate: Float) -> String { @@ -711,7 +357,8 @@ final class PlayerModel: ObservableObject { func closeCurrentItem() { prepareCurrentItemForHistory() currentItem = nil - player.replaceCurrentItem(with: nil) + + backend.closeItem() } func closePiP() { @@ -726,46 +373,9 @@ final class PlayerModel: ObservableObject { show() #endif - doClosePiP(wasPlaying: wasPlaying) + backend.closePiP(wasPlaying: wasPlaying) } - #if os(tvOS) - private func doClosePiP(wasPlaying: Bool) { - let item = player.currentItem - let time = player.currentTime() - - self.player.replaceCurrentItem(with: nil) - - guard !item.isNil else { - return - } - - self.player.seek(to: time) - self.player.replaceCurrentItem(with: item) - - guard wasPlaying else { - return - } - - DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in - self?.play() - } - } - #else - private func doClosePiP(wasPlaying: Bool) { - controller?.playerView.player = nil - controller?.playerView.player = player - - guard wasPlaying else { - return - } - - DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in - self?.play() - } - } - #endif - func handleCurrentItemChange() { #if os(macOS) Windows.player.window?.title = windowTitle @@ -789,25 +399,23 @@ final class PlayerModel: ObservableObject { } func enterFullScreen() { - guard !playingFullscreen else { + guard !controls.playingFullscreen else { return } logger.info("entering fullscreen") - controller?.playerView - .perform(NSSelectorFromString("enterFullScreenAnimated:completionHandler:"), with: false, with: nil) + backend.enterFullScreen() } func exitFullScreen() { - guard playingFullscreen else { + guard controls.playingFullscreen else { return } logger.info("exiting fullscreen") - controller?.playerView - .perform(NSSelectorFromString("exitFullScreenAnimated:completionHandler:"), with: false, with: nil) + backend.exitFullScreen() } #endif } diff --git a/Model/Player/PlayerQueue.swift b/Model/Player/PlayerQueue.swift index 75111cc3..4c45d148 100644 --- a/Model/Player/PlayerQueue.swift +++ b/Model/Player/PlayerQueue.swift @@ -56,7 +56,7 @@ extension PlayerModel { func playItem(_ item: PlayerQueueItem, video: Video? = nil, at time: TimeInterval? = nil) { if !playingInPictureInPicture { - player.replaceCurrentItem(with: nil) + backend.closeItem() } comments.reset() @@ -92,13 +92,13 @@ extension PlayerModel { streams = streams.filter { $0.instance.id == id } } + streams = streams.filter { backend.canPlay($0) } + switch quality { case .best: - return streams.first { $0.kind == .hls } ?? - streams.filter { $0.kind == .stream }.max { $0.resolution < $1.resolution } ?? - streams.first + return backend.bestPlayable(streams) default: - let sorted = streams.filter { $0.kind != .hls }.sorted { $0.resolution > $1.resolution } + let sorted = streams.filter { $0.kind != .hls }.sorted { $0.resolution > $1.resolution }.sorted { $0.kind < $1.kind } return sorted.first(where: { $0.resolution.height <= quality.value.height }) } } @@ -117,7 +117,7 @@ extension PlayerModel { remove(newItem) currentItem = newItem - player.pause() + pause() accounts.api.loadDetails(newItem) { newItem in self.playItem(newItem, video: newItem.video, at: time) @@ -143,11 +143,7 @@ extension PlayerModel { self.removeQueueItems() } - player.replaceCurrentItem(with: nil) - } - - func isAutoplaying(_ item: AVPlayerItem) -> Bool { - player.currentItem == item + backend.closeItem() } @discardableResult func enqueueVideo( @@ -162,7 +158,7 @@ extension PlayerModel { if play { currentItem = item // pause playing current video as it's going to be replaced with next one - player.pause() + pause() } queue.insert(item, at: prepending ? 0 : queue.endIndex) diff --git a/Model/Player/PlayerSponsorBlock.swift b/Model/Player/PlayerSponsorBlock.swift index aff4ad9f..b84b9939 100644 --- a/Model/Player/PlayerSponsorBlock.swift +++ b/Model/Player/PlayerSponsorBlock.swift @@ -38,9 +38,12 @@ extension PlayerModel { return } - player.seek(to: segment.endTime) - lastSkipped = segment - segmentRestorationTime = time + backend.seek(to: segment.endTime) + + DispatchQueue.main.async { [weak self] in + self?.lastSkipped = segment + self?.segmentRestorationTime = time + } logger.info("SponsorBlock skipping to: \(segment.end)") } @@ -63,13 +66,15 @@ extension PlayerModel { } restoredSegments.append(segment) - player.seek(to: time) + backend.seek(to: time) resetLastSegment() } private func resetLastSegment() { - lastSkipped = nil - segmentRestorationTime = nil + DispatchQueue.main.async { [weak self] in + self?.lastSkipped = nil + self?.segmentRestorationTime = nil + } } func resetSegments() { diff --git a/Model/Segment.swift b/Model/Segment.swift index e21675d8..fb53af02 100644 --- a/Model/Segment.swift +++ b/Model/Segment.swift @@ -17,6 +17,10 @@ class Segment: ObservableObject, Hashable { segment.last! } + var duration: Double { + end - start + } + var endTime: CMTime { CMTime(seconds: end, preferredTimescale: 1000) } diff --git a/Model/Stream.swift b/Model/Stream.swift index 65fe2a37..8b237fbb 100644 --- a/Model/Stream.swift +++ b/Model/Stream.swift @@ -5,7 +5,7 @@ import Foundation // swiftlint:disable:next final_class class Stream: Equatable, Hashable, Identifiable { enum Resolution: String, CaseIterable, Comparable, Defaults.Serializable { - case hd1440p60, hd1440p, hd1080p60, hd1080p, hd720p60, hd720p, sd480p, sd360p, sd240p, sd144p, unknown + case hd2160p, hd1440p60, hd1440p, hd1080p60, hd1080p, hd720p60, hd720p, sd480p, sd360p, sd240p, sd144p, unknown var name: String { "\(height)p\(refreshRate != -1 ? ", \(refreshRate) fps" : "")" @@ -68,6 +68,7 @@ class Stream: Equatable, Hashable, Identifiable { var kind: Kind! var encoding: String! + var videoFormat: String! init( instance: Instance? = nil, @@ -76,7 +77,8 @@ class Stream: Equatable, Hashable, Identifiable { hlsURL: URL? = nil, resolution: Resolution? = nil, kind: Kind = .hls, - encoding: String? = nil + encoding: String? = nil, + videoFormat: String? = nil ) { self.instance = instance self.audioAsset = audioAsset @@ -85,14 +87,35 @@ class Stream: Equatable, Hashable, Identifiable { self.resolution = resolution self.kind = kind self.encoding = encoding + self.videoFormat = videoFormat } var quality: String { - kind == .hls ? "adaptive (HLS)" : "\(resolution.name) \(kind == .stream ? "(\(kind.rawValue))" : "")" + if resolution == .hd2160p { + return "4K (2160p)" + } + + return kind == .hls ? "adaptive (HLS)" : "\(resolution.name)\(kind == .stream ? " (\(kind.rawValue))" : "")" + } + + var format: String { + let lowercasedFormat = (videoFormat ?? "unknown").lowercased() + if lowercasedFormat.contains("webm") { + return "WEBM" + } else if lowercasedFormat.contains("avc1") { + return "avc1" + } else if lowercasedFormat.contains("av01") { + return "AV1" + } else if lowercasedFormat.contains("mpeg_4") || lowercasedFormat.contains("mp4") { + return "MP4" + } else { + return lowercasedFormat + } } var description: String { - "\(quality) - \(instance?.description ?? "")" + let formatString = format == "unknown" ? "" : " (\(format))" + return "\(quality)\(formatString) - \(instance?.description ?? "")" } var assets: [AVURLAsset] { diff --git a/Shared/Defaults.swift b/Shared/Defaults.swift index 5bec9ecc..6c312459 100644 --- a/Shared/Defaults.swift +++ b/Shared/Defaults.swift @@ -43,6 +43,7 @@ extension Defaults.Keys { static let timeOnThumbnail = Key("timeOnThumbnail", default: true) static let roundedThumbnails = Key("roundedThumbnails", default: true) + static let activeBackend = Key("activeBackend", default: .mpv) static let quality = Key("quality", default: .best) static let playerSidebar = Key("playerSidebar", default: PlayerSidebarSetting.defaultValue) static let playerInstanceID = Key("playerInstance") diff --git a/Shared/Favorites/FavoritesView.swift b/Shared/Favorites/FavoritesView.swift index 343fca44..fe0b980a 100644 --- a/Shared/Favorites/FavoritesView.swift +++ b/Shared/Favorites/FavoritesView.swift @@ -19,7 +19,7 @@ struct FavoritesView: View { #endif var body: some View { - PlayerControlsView { + BrowserPlayerControls { ScrollView(.vertical, showsIndicators: false) { if !accounts.current.isNil { #if os(tvOS) diff --git a/Shared/Navigation/AppSidebarNavigation.swift b/Shared/Navigation/AppSidebarNavigation.swift index ff8aa5e2..873eda48 100644 --- a/Shared/Navigation/AppSidebarNavigation.swift +++ b/Shared/Navigation/AppSidebarNavigation.swift @@ -49,7 +49,7 @@ struct AppSidebarNavigation: View { .frame(minWidth: sidebarMinWidth) VStack { - PlayerControlsView { + BrowserPlayerControls { HStack(alignment: .center) { Spacer() Image(systemName: "play.tv") diff --git a/Shared/Navigation/AppTabNavigation.swift b/Shared/Navigation/AppTabNavigation.swift index a3470416..2c7dd5ae 100644 --- a/Shared/Navigation/AppTabNavigation.swift +++ b/Shared/Navigation/AppTabNavigation.swift @@ -7,6 +7,7 @@ struct AppTabNavigation: View { @EnvironmentObject private var instances @EnvironmentObject private var navigation @EnvironmentObject private var player + @EnvironmentObject private var playerControls @EnvironmentObject private var playlists @EnvironmentObject private var recents @EnvironmentObject private var search @@ -95,7 +96,7 @@ struct AppTabNavigation: View { .toolbar { toolbarContent } } .tabItem { - Label("Favorites", systemImage: "heart") + Label("Favorites", systemImage: "heart.fill") .accessibility(label: Text("Favorites")) } .tag(TabSelection.favorites) @@ -129,7 +130,7 @@ struct AppTabNavigation: View { .toolbar { toolbarContent } } .tabItem { - Label("Popular", systemImage: "arrow.up.right.circle") + Label("Popular", systemImage: "arrow.up.right.circle.fill") .accessibility(label: Text("Popular")) } .tag(TabSelection.popular) @@ -141,7 +142,7 @@ struct AppTabNavigation: View { .toolbar { toolbarContent } } .tabItem { - Label("Trending", systemImage: "chart.bar") + Label("Trending", systemImage: "chart.bar.fill") .accessibility(label: Text("Trending")) } .tag(TabSelection.trending) @@ -187,6 +188,7 @@ struct AppTabNavigation: View { .environmentObject(instances) .environmentObject(navigation) .environmentObject(player) + .environmentObject(playerControls) .environmentObject(playlists) .environmentObject(recents) .environmentObject(subscriptions) diff --git a/Shared/Navigation/ContentView.swift b/Shared/Navigation/ContentView.swift index dba8eba6..5386f6c6 100644 --- a/Shared/Navigation/ContentView.swift +++ b/Shared/Navigation/ContentView.swift @@ -12,6 +12,7 @@ struct ContentView: View { @EnvironmentObject private var instances @EnvironmentObject private var navigation @EnvironmentObject private var player + @EnvironmentObject private var playerControls @EnvironmentObject private var playlists @EnvironmentObject private var recents @EnvironmentObject private var search @@ -135,9 +136,11 @@ struct ContentView: View { menu.accounts = accounts menu.navigation = navigation menu.player = player + playerControls.player = player player.accounts = accounts player.comments = comments + player.controls = playerControls if !accounts.current.isNil { player.restoreQueue() diff --git a/Shared/Player/Player.swift b/Shared/Player/AVPlayerView.swift similarity index 51% rename from Shared/Player/Player.swift rename to Shared/Player/AVPlayerView.swift index 596dad00..f2730719 100644 --- a/Shared/Player/Player.swift +++ b/Shared/Player/AVPlayerView.swift @@ -1,35 +1,25 @@ import Defaults import SwiftUI -struct Player: UIViewControllerRepresentable { +struct AVPlayerView: UIViewControllerRepresentable { @EnvironmentObject private var comments @EnvironmentObject private var navigation @EnvironmentObject private var player @EnvironmentObject private var subscriptions - var controller: PlayerViewController? - - init(controller: PlayerViewController? = nil) { - self.controller = controller - } - - func makeUIViewController(context _: Context) -> PlayerViewController { - if self.controller != nil { - return self.controller! - } - - let controller = PlayerViewController() + func makeUIViewController(context _: Context) -> UIViewController { + let controller = AppleAVPlayerViewController() controller.commentsModel = comments controller.navigationModel = navigation controller.playerModel = player controller.subscriptionsModel = subscriptions - player.controller = controller + player.avPlayerBackend.controller = controller return controller } - func updateUIViewController(_: PlayerViewController, context _: Context) { + func updateUIViewController(_: UIViewController, context _: Context) { player.rebuildTVMenu() } } diff --git a/Shared/Player/AVPlayerViewController.swift b/Shared/Player/AVPlayerViewController.swift new file mode 100644 index 00000000..acfbdb92 --- /dev/null +++ b/Shared/Player/AVPlayerViewController.swift @@ -0,0 +1,207 @@ +import AVKit +import Defaults +import SwiftUI + +final class AppleAVPlayerViewController: UIViewController { + var playerLoaded = false + var commentsModel: CommentsModel! + var navigationModel: NavigationModel! + var playerModel: PlayerModel! + var subscriptionsModel: SubscriptionsModel! + var playerView = AVPlayerViewController() + + let persistenceController = PersistenceController.shared + + #if !os(tvOS) + var aspectRatio: Double? { + let ratio = Double(playerView.videoBounds.width) / Double(playerView.videoBounds.height) + + guard ratio.isFinite else { + return VideoPlayerView.defaultAspectRatio // swiftlint:disable:this implicit_return + } + + return [ratio, 1.0].max()! + } + #endif + + override func viewWillAppear(_ animated: Bool) { + super.viewWillAppear(animated) + + loadPlayer() + + #if os(tvOS) + if !playerView.isBeingPresented, !playerView.isBeingDismissed { + present(playerView, animated: false) + } + #endif + } + + #if os(tvOS) + override func viewDidDisappear(_ animated: Bool) { + super.viewDidDisappear(animated) + + if !playerModel.presentingPlayer, !Defaults[.pauseOnHidingPlayer], !playerModel.isPlaying { + DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in + self?.playerModel.play() + } + } + } + #endif + + func loadPlayer() { + guard !playerLoaded else { + return + } + + playerModel.avPlayerBackend.controller = self + playerView.player = playerModel.avPlayerBackend.avPlayer + playerView.allowsPictureInPicturePlayback = true + playerView.showsPlaybackControls = false + #if os(iOS) + if #available(iOS 14.2, *) { + playerView.canStartPictureInPictureAutomaticallyFromInline = true + } + #endif + playerView.delegate = self + + #if os(tvOS) + var infoViewControllers = [UIHostingController]() + if CommentsModel.enabled { + infoViewControllers.append(infoViewController([.comments], title: "Comments")) + } + + var queueSections = [NowPlayingView.ViewSection.playingNext] + if Defaults[.showHistoryInPlayer] { + queueSections.append(.playedPreviously) + } + + infoViewControllers.append(contentsOf: [ + infoViewController([.related], title: "Related"), + infoViewController(queueSections, title: "Queue") + ]) + + playerView.customInfoViewControllers = infoViewControllers + #else + embedViewController() + #endif + } + + #if os(tvOS) + func infoViewController( + _ sections: [NowPlayingView.ViewSection], + title: String + ) -> UIHostingController { + let controller = UIHostingController(rootView: + AnyView( + NowPlayingView(sections: sections, inInfoViewController: true) + .frame(maxHeight: 600) + .environmentObject(commentsModel) + .environmentObject(playerModel) + .environmentObject(subscriptionsModel) + .environment(\.managedObjectContext, persistenceController.container.viewContext) + ) + ) + + controller.title = title + + return controller + } + #else + func embedViewController() { + playerView.view.frame = view.bounds + + addChild(playerView) + view.addSubview(playerView.view) + + playerView.didMove(toParent: self) + } + #endif +} + +extension AppleAVPlayerViewController: AVPlayerViewControllerDelegate { + func playerViewControllerShouldDismiss(_: AVPlayerViewController) -> Bool { + true + } + + func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(_: AVPlayerViewController) -> Bool { + true + } + + func playerViewControllerWillBeginDismissalTransition(_: AVPlayerViewController) { + if Defaults[.pauseOnHidingPlayer] { + playerModel.pause() + } + dismiss(animated: false) + } + + func playerViewControllerDidEndDismissalTransition(_: AVPlayerViewController) {} + + func playerViewController( + _: AVPlayerViewController, + willBeginFullScreenPresentationWithAnimationCoordinator context: UIViewControllerTransitionCoordinator + ) { + #if os(iOS) + if !context.isCancelled, Defaults[.lockLandscapeWhenEnteringFullscreen] { + Orientation.lockOrientation(.landscape, andRotateTo: UIDevice.current.orientation.isLandscape ? nil : .landscapeRight) + } + #endif + } + + func playerViewController( + _: AVPlayerViewController, + willEndFullScreenPresentationWithAnimationCoordinator coordinator: UIViewControllerTransitionCoordinator + ) { + let wasPlaying = playerModel.isPlaying + coordinator.animate(alongsideTransition: nil) { context in + #if os(iOS) + if wasPlaying { + self.playerModel.play() + } + #endif + if !context.isCancelled { + #if os(iOS) + self.playerModel.lockedOrientation = nil + if Defaults[.enterFullscreenInLandscape] { + Orientation.lockOrientation(.portrait, andRotateTo: .portrait) + } + + if wasPlaying { + self.playerModel.play() + } + #endif + } + } + } + + func playerViewController( + _: AVPlayerViewController, + restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void + ) { + DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { + if self.navigationModel.presentingChannel { + self.playerModel.playerNavigationLinkActive = true + } else { + self.playerModel.show() + } + + #if os(tvOS) + if self.playerModel.playingInPictureInPicture { + self.present(self.playerView, animated: false) { + completionHandler(true) + } + } + #else + completionHandler(true) + #endif + } + } + + func playerViewControllerWillStartPictureInPicture(_: AVPlayerViewController) { + playerModel.playingInPictureInPicture = true + playerModel.playerNavigationLinkActive = false + } + + func playerViewControllerWillStopPictureInPicture(_: AVPlayerViewController) { + playerModel.playingInPictureInPicture = false + } +} diff --git a/Shared/Player/Controls/PlayerControls.swift b/Shared/Player/Controls/PlayerControls.swift new file mode 100644 index 00000000..a157ce66 --- /dev/null +++ b/Shared/Player/Controls/PlayerControls.swift @@ -0,0 +1,237 @@ +import Foundation +import SwiftUI + +struct PlayerControls: View { + static let animation = Animation.easeInOut(duration: 0) + + private var player: PlayerModel! + @EnvironmentObject private var model + + @Environment(\.verticalSizeClass) private var verticalSizeClass + + init(player: PlayerModel) { + self.player = player + } + + var body: some View { + VStack { + ZStack(alignment: .bottom) { + VStack(spacing: 0) { + Group { + statusBar + .padding(3) + #if os(macOS) + .background(VisualEffectBlur(material: .hudWindow)) + #elseif os(iOS) + .background(VisualEffectBlur(blurStyle: .systemThinMaterial)) + #endif + .mask(RoundedRectangle(cornerRadius: 3)) + + buttonsBar + .padding(.top, 4) + .padding(.horizontal, 4) + } + + Spacer() + + mediumButtonsBar + + Spacer() + + timeline + .offset(y: 10) + .zIndex(1) + + bottomBar + + #if os(macOS) + .background(VisualEffectBlur(material: .hudWindow)) + #elseif os(iOS) + .background(VisualEffectBlur(blurStyle: .systemThinMaterial)) + #endif + .mask(RoundedRectangle(cornerRadius: 3)) + } + } + .opacity(model.presentingControls ? 1 : 0) + } + .background(controlsBackground) + .environment(\.colorScheme, .dark) + } + + var controlsBackground: some View { + model.presentingControls ? + AnyView( + PlayerGestures() + .background(Color.black.opacity(0.5)) + ) : + AnyView(Color.clear) + } + + var timeline: some View { + TimelineView(duration: durationBinding, current: currentTimeBinding, cornerRadius: 0) + } + + var durationBinding: Binding { + Binding( + get: { model.duration.seconds }, + set: { value in model.duration = .secondsInDefaultTimescale(value) } + ) + } + + var currentTimeBinding: Binding { + Binding( + get: { model.currentTime.seconds }, + set: { value in model.currentTime = .secondsInDefaultTimescale(value) } + ) + } + + var statusBar: some View { + HStack(spacing: 4) { + hidePlayerButton + Text(playbackStatus) + Spacer() + ToggleBackendButton() + Text("•") + StreamControl() + } + .foregroundColor(.primary) + .padding(.trailing, 4) + .font(.system(size: 14)) + } + + private var hidePlayerButton: some View { + Button { + player.hide() + } label: { + Image(systemName: "chevron.down.circle.fill") + } + } + + private var playbackStatus: String { + if player.live { + return "LIVE" + } + + guard !player.isLoadingVideo else { + return "loading..." + } + + let videoLengthAtRate = (player.currentVideo?.length ?? 0) / Double(player.currentRate) + let remainingSeconds = videoLengthAtRate - (player.time?.seconds ?? 0) + + if remainingSeconds < 60 { + return "less than a minute" + } + + let timeFinishAt = Date().addingTimeInterval(remainingSeconds) + + return "ends at \(formattedTimeFinishAt(timeFinishAt))" + } + + private func formattedTimeFinishAt(_ date: Date) -> String { + let dateFormatter = DateFormatter() + + dateFormatter.dateStyle = .none + dateFormatter.timeStyle = .short + + return dateFormatter.string(from: date) + } + + var buttonsBar: some View { + HStack { + fullscreenButton + Spacer() + button("Music Mode", systemImage: "music.note") + } + } + + var fullscreenButton: some View { + button( + "Fullscreen", + systemImage: fullScreenLayout ? "arrow.down.right.and.arrow.up.left" : "arrow.up.left.and.arrow.down.right" + ) { + model.toggleFullscreen(fullScreenLayout) + } + .keyboardShortcut(fullScreenLayout ? .cancelAction : .defaultAction) + } + + var mediumButtonsBar: some View { + HStack { + button("Seek Backward", systemImage: "gobackward.10", size: 50, cornerRadius: 10) { + player.backend.seek(relative: .secondsInDefaultTimescale(-10)) + } + .keyboardShortcut("k") + + Spacer() + + button( + model.isPlaying ? "Pause" : "Play", + systemImage: model.isPlaying ? "pause.fill" : "play.fill", + size: 50, + cornerRadius: 10 + ) { + player.backend.togglePlay() + } + .keyboardShortcut("p") + .disabled(model.isLoadingVideo) + + Spacer() + + button("Seek Forward", systemImage: "goforward.10", size: 50, cornerRadius: 10) { + player.backend.seek(relative: .secondsInDefaultTimescale(10)) + } + .keyboardShortcut("l") + } + .font(.system(size: 30)) + .padding(.horizontal, 4) + } + + var bottomBar: some View { + HStack { + Spacer() + + Text(model.playbackTime) + } + .font(.system(size: 15)) + .padding(.horizontal, 5) + .padding(.vertical, 3) + .labelStyle(.iconOnly) + .foregroundColor(.primary) + } + + func button( + _ label: String, + systemImage: String = "arrow.up.left.and.arrow.down.right", + size: Double = 30, + cornerRadius: Double = 3, + action: @escaping () -> Void = {} + ) -> some View { + Button { + action() + model.resetTimer() + } label: { + Label(label, systemImage: systemImage) + .labelStyle(.iconOnly) + .padding() + .contentShape(Rectangle()) + } + .foregroundColor(.primary) + .frame(width: size, height: size) + #if os(macOS) + .background(VisualEffectBlur(material: .hudWindow)) + #elseif os(iOS) + .background(VisualEffectBlur(blurStyle: .systemThinMaterial)) + #endif + .mask(RoundedRectangle(cornerRadius: cornerRadius)) + } + + var fullScreenLayout: Bool { + model.playingFullscreen || verticalSizeClass == .compact + } +} + +struct PlayerControls_Previews: PreviewProvider { + static var previews: some View { + PlayerControls(player: PlayerModel()) + } +} diff --git a/Shared/Player/Controls/ToggleBackendButton.swift b/Shared/Player/Controls/ToggleBackendButton.swift new file mode 100644 index 00000000..ae2da73b --- /dev/null +++ b/Shared/Player/Controls/ToggleBackendButton.swift @@ -0,0 +1,23 @@ +import SwiftUI + +struct ToggleBackendButton: View { + @EnvironmentObject private var controls + @EnvironmentObject private var player + + var body: some View { + Button { + player.saveTime { + player.changeActiveBackend(from: player.activeBackend, to: player.activeBackend.next()) + controls.resetTimer() + } + } label: { + Text(player.activeBackend.label) + } + } +} + +struct ToggleBackendButton_Previews: PreviewProvider { + static var previews: some View { + ToggleBackendButton() + } +} diff --git a/Shared/Player/MPV/MPVOGLView.swift b/Shared/Player/MPV/MPVOGLView.swift new file mode 100644 index 00000000..1f5a866b --- /dev/null +++ b/Shared/Player/MPV/MPVOGLView.swift @@ -0,0 +1,63 @@ +import GLKit +import OpenGLES + +final class MPVOGLView: GLKView { + private var defaultFBO: GLint? + + var mpvGL: UnsafeMutableRawPointer? + var needsDrawing = true + + override init(frame: CGRect) { + guard let context = EAGLContext(api: .openGLES2) else { + print("Failed to initialize OpenGLES 2.0 context") + exit(1) + } + + super.init(frame: frame, context: context) + contentMode = .redraw + + EAGLContext.setCurrent(context) + + drawableColorFormat = .RGBA8888 + drawableDepthFormat = .formatNone + drawableStencilFormat = .formatNone + + defaultFBO = -1 + isOpaque = false + + fillBlack() + } + + func fillBlack() { + glClearColor(0, 0, 0, 0) + glClear(UInt32(GL_COLOR_BUFFER_BIT)) + } + + override func draw(_: CGRect) { + glGetIntegerv(UInt32(GL_FRAMEBUFFER_BINDING), &defaultFBO!) + + if mpvGL != nil { + var data = mpv_opengl_fbo( + fbo: Int32(defaultFBO!), + w: Int32(bounds.size.width) * Int32(contentScaleFactor), + h: Int32(bounds.size.height) * Int32(contentScaleFactor), + internal_format: 0 + ) + var flip: CInt = 1 + withUnsafeMutablePointer(to: &flip) { flip in + withUnsafeMutablePointer(to: &data) { data 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() + ] + mpv_render_context_render(OpaquePointer(mpvGL), ¶ms) + } + } + } + } + + required init?(coder aDecoder: NSCoder) { + super.init(coder: aDecoder) + } +} diff --git a/Shared/Player/MPV/MPVViewController.swift b/Shared/Player/MPV/MPVViewController.swift new file mode 100644 index 00000000..be202ac8 --- /dev/null +++ b/Shared/Player/MPV/MPVViewController.swift @@ -0,0 +1,25 @@ +import UIKit + +final class MPVViewController: UIViewController { + var client: MPVClient! + var glView: MPVOGLView! + + init() { + client = MPVClient() + super.init(nibName: nil, bundle: nil) + } + + required init?(coder: NSCoder) { + super.init(coder: coder) + } + + override func viewDidLoad() { + super.loadView() + + glView = client.create(frame: view.frame) + + view.addSubview(glView) + + super.viewDidLoad() + } +} diff --git a/Shared/Player/PlaybackBar.swift b/Shared/Player/PlaybackBar.swift index e3fdab8b..e69de29b 100644 --- a/Shared/Player/PlaybackBar.swift +++ b/Shared/Player/PlaybackBar.swift @@ -1,231 +0,0 @@ -import Defaults -import Foundation -import SwiftUI - -struct PlaybackBar: View { - @Environment(\.colorScheme) private var colorScheme - @Environment(\.presentationMode) private var presentationMode - @Environment(\.inNavigationView) private var inNavigationView - - @EnvironmentObject private var player - - var body: some View { - HStack { - #if !os(macOS) - closeButton - #endif - - if player.currentItem != nil { - HStack { - Text(playbackStatus) - Text("•") - rateMenu - } - .font(.caption2) - #if os(macOS) - .padding(.leading, 4) - #endif - - Spacer() - - HStack(spacing: 4) { - if !player.lastSkipped.isNil { - restoreLastSkippedSegmentButton - } - if player.live { - Image(systemName: "dot.radiowaves.left.and.right") - } else if player.isLoadingAvailableStreams || player.isLoadingStream { - Image(systemName: "bolt.horizontal.fill") - } else if !player.playerError.isNil { - Button { - player.presentingErrorDetails = true - } label: { - Image(systemName: "exclamationmark.circle.fill") - .foregroundColor(.red) - } - .buttonStyle(.plain) - } - - streamControl - .disabled(player.isLoadingAvailableStreams) - .frame(alignment: .trailing) - .onChange(of: player.streamSelection) { selection in - guard !selection.isNil else { - return - } - - player.upgradeToStream(selection!) - } - #if os(macOS) - .frame(maxWidth: 180) - #endif - } - .transaction { t in t.animation = .none } - .font(.caption2) - } else { - Spacer() - } - } - .foregroundColor(colorScheme == .dark ? .gray : .black) - .alert(isPresented: $player.presentingErrorDetails) { - Alert( - title: Text("Error"), - message: Text(player.playerError?.localizedDescription ?? "") - ) - } - .frame(minWidth: 0, maxWidth: .infinity, minHeight: 20) - .padding(4) - .background(colorScheme == .dark ? Color.black : Color.white) - } - - private var closeButton: some View { - Button { - player.hide() - } label: { - Label( - "Close", - systemImage: inNavigationView ? "chevron.backward.circle.fill" : "chevron.down.circle.fill" - ) - .labelStyle(.iconOnly) - } - .accessibilityLabel(Text("Close")) - .buttonStyle(.borderless) - .foregroundColor(.gray) - .keyboardShortcut(.cancelAction) - } - - private var playbackStatus: String { - if player.live { - return "LIVE" - } - - guard !player.isLoadingVideo else { - return "loading..." - } - - guard let video = player.currentVideo, - let time = player.time - else { - return "" - } - - let videoLengthAtRate = video.length / Double(player.currentRate) - let remainingSeconds = videoLengthAtRate - time.seconds - - if remainingSeconds < 60 { - return "less than a minute" - } - - let timeFinishAt = Date().addingTimeInterval(remainingSeconds) - - return "ends at \(formattedTimeFinishAt(timeFinishAt))" - } - - private func formattedTimeFinishAt(_ date: Date) -> String { - let dateFormatter = DateFormatter() - - dateFormatter.dateStyle = .none - dateFormatter.timeStyle = .short - - return dateFormatter.string(from: date) - } - - private var rateMenu: some View { - #if os(macOS) - ratePicker - .labelsHidden() - .frame(maxWidth: 70) - #else - Menu { - ratePicker - } label: { - Text(player.rateLabel(player.currentRate)) - } - - #endif - } - - private var ratePicker: some View { - Picker("", selection: $player.currentRate) { - ForEach(PlayerModel.availableRates, id: \.self) { rate in - Text(player.rateLabel(rate)).tag(rate) - } - } - } - - private var restoreLastSkippedSegmentButton: some View { - HStack(spacing: 4) { - Button { - player.restoreLastSkippedSegment() - } label: { - HStack(spacing: 4) { - Image(systemName: "arrow.uturn.left.circle") - Text(player.lastSkipped!.title()) - } - } - .buttonStyle(.plain) - - Text("•") - } - } - - private var streamControl: some View { - #if os(macOS) - Picker("", selection: $player.streamSelection) { - ForEach(InstancesModel.all) { instance in - let instanceStreams = availableStreamsForInstance(instance) - if !instanceStreams.values.isEmpty { - let kinds = Array(instanceStreams.keys).sorted { $0 < $1 } - - Section(header: Text(instance.longDescription)) { - ForEach(kinds, id: \.self) { key in - ForEach(instanceStreams[key] ?? []) { stream in - Text(stream.quality).tag(Stream?.some(stream)) - } - - if kinds.count > 1 { - Divider() - } - } - } - } - } - } - #else - Menu { - ForEach(InstancesModel.all) { instance in - let instanceStreams = availableStreamsForInstance(instance) - if !instanceStreams.values.isEmpty { - let kinds = Array(instanceStreams.keys).sorted { $0 < $1 } - Picker("", selection: $player.streamSelection) { - ForEach(kinds, id: \.self) { key in - ForEach(instanceStreams[key] ?? []) { stream in - Text(stream.description).tag(Stream?.some(stream)) - } - - if kinds.count > 1 { - Divider() - } - } - } - } - } - } label: { - Text(player.streamSelection?.quality ?? "") - } - #endif - } - - private func availableStreamsForInstance(_ instance: Instance) -> [Stream.Kind: [Stream]] { - let streams = player.availableStreamsSorted.filter { $0.instance == instance } - - return Dictionary(grouping: streams, by: \.kind!) - } -} - -struct PlaybackBar_Previews: PreviewProvider { - static var previews: some View { - PlaybackBar() - .injectFixtureEnvironmentObjects() - } -} diff --git a/Shared/Player/PlayerGestures.swift b/Shared/Player/PlayerGestures.swift new file mode 100644 index 00000000..b29a5447 --- /dev/null +++ b/Shared/Player/PlayerGestures.swift @@ -0,0 +1,55 @@ +import SwiftUI + +struct PlayerGestures: View { + @EnvironmentObject private var player + @EnvironmentObject private var model + + var body: some View { + HStack(spacing: 0) { + gestureRectangle + .tapRecognizer( + tapSensitivity: 0.2, + singleTapAction: { + model.toggle() + }, + doubleTapAction: { + player.backend.seek(relative: .secondsInDefaultTimescale(-10)) + } + ) + + gestureRectangle + .tapRecognizer( + tapSensitivity: 0.2, + singleTapAction: { + model.toggle() + }, + doubleTapAction: { + player.backend.togglePlay() + } + ) + + gestureRectangle + .tapRecognizer( + tapSensitivity: 0.2, + singleTapAction: { + model.toggle() + }, + doubleTapAction: { + player.backend.seek(relative: .secondsInDefaultTimescale(10)) + } + ) + } + } + + var gestureRectangle: some View { + Color.clear + .contentShape(Rectangle()) + .frame(maxWidth: .infinity, maxHeight: .infinity) + } +} + +struct PlayerGestures_Previews: PreviewProvider { + static var previews: some View { + PlayerGestures() + } +} diff --git a/Shared/Player/StreamControl.swift b/Shared/Player/StreamControl.swift new file mode 100644 index 00000000..70e08782 --- /dev/null +++ b/Shared/Player/StreamControl.swift @@ -0,0 +1,79 @@ +import SwiftUI + +struct StreamControl: View { + @EnvironmentObject private var player + + var body: some View { + Group { + #if os(macOS) + Picker("", selection: $player.streamSelection) { + ForEach(InstancesModel.all) { instance in + let instanceStreams = availableStreamsForInstance(instance) + if !instanceStreams.values.isEmpty { + let kinds = Array(instanceStreams.keys).sorted { $0 < $1 } + + Section(header: Text(instance.longDescription)) { + ForEach(kinds, id: \.self) { key in + ForEach(instanceStreams[key] ?? []) { stream in + Text(stream.quality).tag(Stream?.some(stream)) + } + + if kinds.count > 1 { + Divider() + } + } + } + } + } + } + .disabled(player.isLoadingAvailableStreams) + + #else + Menu { + ForEach(InstancesModel.all) { instance in + let instanceStreams = availableStreamsForInstance(instance) + if !instanceStreams.values.isEmpty { + let kinds = Array(instanceStreams.keys).sorted { $0 < $1 } + Picker("", selection: $player.streamSelection) { + ForEach(kinds, id: \.self) { key in + ForEach(instanceStreams[key] ?? []) { stream in + Text(stream.description).tag(Stream?.some(stream)) + } + + if kinds.count > 1 { + Divider() + } + } + } + } + } + } label: { + Text(player.streamSelection?.quality ?? "no playable streams") + } + .disabled(player.isLoadingAvailableStreams) + #endif + } + + .transaction { t in t.animation = .none } + .onChange(of: player.streamSelection) { selection in + guard !selection.isNil else { + return + } + + player.upgradeToStream(selection!) + } + .frame(alignment: .trailing) + } + + private func availableStreamsForInstance(_ instance: Instance) -> [Stream.Kind: [Stream]] { + let streams = player.availableStreamsSorted.filter { $0.instance == instance }.filter { player.backend.canPlay($0) } + + return Dictionary(grouping: streams, by: \.kind!) + } +} + +struct StreamControl_Previews: PreviewProvider { + static var previews: some View { + StreamControl() + } +} diff --git a/Shared/Player/TapRecognizerViewModifier.swift b/Shared/Player/TapRecognizerViewModifier.swift new file mode 100644 index 00000000..6e746498 --- /dev/null +++ b/Shared/Player/TapRecognizerViewModifier.swift @@ -0,0 +1,48 @@ +import SwiftUI + +struct TapRecognizerViewModifier: ViewModifier { + @State private var singleTapIsTaped: Bool = .init() + + var tapSensitivity: Double + var singleTapAction: () -> Void + var doubleTapAction: () -> Void + + init(tapSensitivity: Double, singleTapAction: @escaping () -> Void, doubleTapAction: @escaping () -> Void) { + self.tapSensitivity = tapSensitivity + self.singleTapAction = singleTapAction + self.doubleTapAction = doubleTapAction + } + + func body(content: Content) -> some View { + content.gesture(simultaneouslyGesture) + } + + private var singleTapGesture: some Gesture { + TapGesture(count: 1).onEnded { + singleTapIsTaped = true + + DispatchQueue.main.asyncAfter(deadline: .now() + tapSensitivity) { + if singleTapIsTaped { + singleTapAction() + } + } + } + } + + private var doubleTapGesture: some Gesture { + TapGesture(count: 2).onEnded { + singleTapIsTaped = false + doubleTapAction() + } + } + + private var simultaneouslyGesture: some Gesture { + singleTapGesture.simultaneously(with: doubleTapGesture) + } +} + +extension View { + func tapRecognizer(tapSensitivity: Double, singleTapAction: @escaping () -> Void, doubleTapAction: @escaping () -> Void) -> some View { + modifier(TapRecognizerViewModifier(tapSensitivity: tapSensitivity, singleTapAction: singleTapAction, doubleTapAction: doubleTapAction)) + } +} diff --git a/Shared/Player/TimelineView.swift b/Shared/Player/TimelineView.swift new file mode 100644 index 00000000..762bc902 --- /dev/null +++ b/Shared/Player/TimelineView.swift @@ -0,0 +1,193 @@ +import SwiftUI + +struct TimelineView: View { + @Binding private var duration: Double + @Binding private var current: Double + + @State private var size = CGSize.zero + @State private var dragging = false + @State private var dragOffset: Double = 0 + @State private var draggedFrom: Double = 0 + + private var start: Double = 0.0 + private var height = 10.0 + + var cornerRadius: Double + var thumbTooltipWidth: Double = 100 + + @EnvironmentObject private var player + @EnvironmentObject private var controls + + init(duration: Binding, current: Binding, cornerRadius: Double = 10.0) { + _duration = duration + _current = current + self.cornerRadius = cornerRadius + } + + var body: some View { + ZStack(alignment: .leading) { + RoundedRectangle(cornerRadius: cornerRadius) + .foregroundColor(.blue) + .frame(maxHeight: height) + + RoundedRectangle(cornerRadius: cornerRadius) + .fill( + Color.green + ) + .frame(maxHeight: height) + .frame(width: current * oneUnitWidth) + + segmentsLayers + + Circle() + .strokeBorder(.gray, lineWidth: 1) + .background(Circle().fill(dragging ? .gray : .white)) + .offset(x: thumbOffset) + .foregroundColor(.red.opacity(0.6)) + + .frame(maxHeight: height * 2) + + .gesture( + DragGesture(minimumDistance: 0) + .onChanged { value in + if !dragging { + controls.removeTimer() + draggedFrom = current + } + + dragging = true + + let drag = value.translation.width + let change = (drag / size.width) * units + let changedCurrent = current + change + + guard changedCurrent >= start, changedCurrent <= duration else { + return + } + withAnimation(Animation.linear(duration: 0.2)) { + dragOffset = drag + } + } + .onEnded { _ in + current = projectedValue + + player.backend.seek(to: projectedValue) + + dragging = false + dragOffset = 0.0 + draggedFrom = 0.0 + controls.resetTimer() + } + ) + + ZStack { + RoundedRectangle(cornerRadius: cornerRadius) + .frame(maxWidth: thumbTooltipWidth, maxHeight: 30) + + Text(projectedValue.formattedAsPlaybackTime() ?? "--:--") + .foregroundColor(.black) + } + .animation(.linear(duration: 0.1)) + .opacity(dragging ? 1 : 0) + .offset(x: thumbTooltipOffset, y: -(height * 2) - 7) + } + .background(GeometryReader { proxy in + Color.clear + .onAppear { + self.size = proxy.size + } + .onChange(of: proxy.size) { size in + self.size = size + } + }) + .gesture(DragGesture(minimumDistance: 0).onEnded { value in + let target = (value.location.x / size.width) * units + current = target + player.backend.seek(to: target) + }) + } + + var projectedValue: Double { + let change = (dragOffset / size.width) * units + let projected = draggedFrom + change + return projected.isFinite ? projected : start + } + + var thumbOffset: Double { + let offset = dragging ? (draggedThumbHorizontalOffset + dragOffset) : thumbHorizontalOffset + return offset.isFinite ? offset : thumbLeadingOffset + } + + var thumbTooltipOffset: Double { + let offset = (dragging ? ((current * oneUnitWidth) + dragOffset) : (current * oneUnitWidth)) - (thumbTooltipWidth / 2) + + return offset.clamped(to: minThumbTooltipOffset ... maxThumbTooltipOffset) + } + + var minThumbTooltipOffset: Double = -10 + + var maxThumbTooltipOffset: Double { + max(minThumbTooltipOffset, (units * oneUnitWidth) - thumbTooltipWidth + 10) + } + + var segmentsLayers: some View { + ForEach(player.sponsorBlock.segments, id: \.uuid) { segment in + RoundedRectangle(cornerRadius: cornerRadius) + .offset(x: segmentLayerHorizontalOffset(segment)) + .foregroundColor(.red) + .frame(maxHeight: height) + .frame(width: segmentLayerWidth(segment)) + } + } + + func segmentLayerHorizontalOffset(_ segment: Segment) -> Double { + segment.start * oneUnitWidth + } + + func segmentLayerWidth(_ segment: Segment) -> Double { + let width = segment.duration * oneUnitWidth + return width.isFinite ? width : thumbLeadingOffset + } + + var draggedThumbHorizontalOffset: Double { + thumbLeadingOffset + (draggedFrom * oneUnitWidth) + } + + var thumbHorizontalOffset: Double { + thumbLeadingOffset + (current * oneUnitWidth) + } + + var thumbLeadingOffset: Double { + -(size.width / 2) + } + + var oneUnitWidth: Double { + let one = size.width / units + return one.isFinite ? one : 0 + } + + var units: Double { + duration - start + } + + func setCurrent(_ current: Double) { + withAnimation { + self.current = current + } + } +} + +struct TimelineView_Previews: PreviewProvider { + static var previews: some View { + VStack(spacing: 40) { + TimelineView(duration: .constant(100), current: .constant(0)) + TimelineView(duration: .constant(100), current: .constant(1)) + TimelineView(duration: .constant(100), current: .constant(30)) + TimelineView(duration: .constant(100), current: .constant(50)) + TimelineView(duration: .constant(100), current: .constant(66)) + TimelineView(duration: .constant(100), current: .constant(90)) + TimelineView(duration: .constant(100), current: .constant(100)) + } + .padding() + } +} diff --git a/Shared/Player/VideoDetailsPaddingModifier.swift b/Shared/Player/VideoDetailsPaddingModifier.swift index ce159676..a2f51996 100644 --- a/Shared/Player/VideoDetailsPaddingModifier.swift +++ b/Shared/Player/VideoDetailsPaddingModifier.swift @@ -6,7 +6,7 @@ struct VideoDetailsPaddingModifier: ViewModifier { #if os(macOS) 30 #else - 40 + 10 #endif } diff --git a/Shared/Player/VideoPlayerSizeModifier.swift b/Shared/Player/VideoPlayerSizeModifier.swift index ba7fd27c..21f426e4 100644 --- a/Shared/Player/VideoPlayerSizeModifier.swift +++ b/Shared/Player/VideoPlayerSizeModifier.swift @@ -5,6 +5,7 @@ struct VideoPlayerSizeModifier: ViewModifier { let geometry: GeometryProxy let aspectRatio: Double? let minimumHeightLeft: Double + let fullScreen: Bool #if os(iOS) @Environment(\.verticalSizeClass) private var verticalSizeClass @@ -13,18 +14,19 @@ struct VideoPlayerSizeModifier: ViewModifier { init( geometry: GeometryProxy, aspectRatio: Double? = nil, - minimumHeightLeft: Double? = nil + minimumHeightLeft: Double? = nil, + fullScreen: Bool = false ) { self.geometry = geometry self.aspectRatio = aspectRatio ?? VideoPlayerView.defaultAspectRatio self.minimumHeightLeft = minimumHeightLeft ?? VideoPlayerView.defaultMinimumHeightLeft + self.fullScreen = fullScreen } func body(content: Content) -> some View { content - .frame(maxHeight: maxHeight) - .aspectRatio(usedAspectRatio, contentMode: usedAspectRatioContentMode) - .edgesIgnoringSafeArea(edgesIgnoringSafeArea) + .frame(maxHeight: fullScreen ? .infinity : maxHeight) + .aspectRatio(usedAspectRatio, contentMode: .fit) } var usedAspectRatio: Double { @@ -44,7 +46,7 @@ struct VideoPlayerSizeModifier: ViewModifier { var usedAspectRatioContentMode: ContentMode { #if os(iOS) - verticalSizeClass == .regular ? .fit : .fill + !fullScreen ? .fit : .fill #else .fit #endif @@ -59,14 +61,4 @@ struct VideoPlayerSizeModifier: ViewModifier { return [height, 0].max()! } - - var edgesIgnoringSafeArea: Edge.Set { - let empty = Edge.Set() - - #if os(iOS) - return verticalSizeClass == .compact ? .all : empty - #else - return empty - #endif - } } diff --git a/Shared/Player/VideoPlayerView.swift b/Shared/Player/VideoPlayerView.swift index a7ab7f0b..d8a967c1 100644 --- a/Shared/Player/VideoPlayerView.swift +++ b/Shared/Player/VideoPlayerView.swift @@ -22,7 +22,6 @@ struct VideoPlayerView: View { @Environment(\.colorScheme) private var colorScheme #if os(iOS) - @Environment(\.presentationMode) private var presentationMode @Environment(\.horizontalSizeClass) private var horizontalSizeClass @Environment(\.verticalSizeClass) private var verticalSizeClass @@ -36,6 +35,7 @@ struct VideoPlayerView: View { #endif @EnvironmentObject private var accounts + @EnvironmentObject private var playerControls @EnvironmentObject private var player var body: some View { @@ -60,12 +60,15 @@ struct VideoPlayerView: View { .onChange(of: geometry.size) { size in self.playerSize = size } + .onChange(of: fullScreenDetails) { value in + player.backend.setNeedsDrawing(!value) + } #if os(iOS) .onReceive(NotificationCenter.default.publisher(for: UIDevice.orientationDidChangeNotification)) { _ in handleOrientationDidChangeNotification() } .onDisappear { - guard !player.playingFullscreen else { + guard !playerControls.playingFullscreen else { return // swiftlint:disable:this implicit_return } @@ -80,7 +83,6 @@ struct VideoPlayerView: View { } #endif } - .navigationBarHidden(true) #endif } @@ -89,79 +91,117 @@ struct VideoPlayerView: View { Group { #if os(tvOS) player.playerView + .ignoresSafeArea(.all, edges: .all) #else GeometryReader { geometry in VStack(spacing: 0) { - #if os(iOS) - if verticalSizeClass == .regular { + if !playerControls.playingFullscreen { + #if os(macOS) PlaybackBar() - } - #elseif os(macOS) - PlaybackBar() - #endif + #endif + } if player.currentItem.isNil { playerPlaceholder(geometry: geometry) } else if player.playingInPictureInPicture { pictureInPicturePlaceholder(geometry: geometry) } else { - player.playerView - .modifier( - VideoPlayerSizeModifier( - geometry: geometry, - aspectRatio: player.controller?.aspectRatio - ) + ZStack(alignment: .top) { + switch player.activeBackend { + case .mpv: + player.mpvPlayerView + .overlay(GeometryReader { proxy in + Color.clear + .onAppear { + player.playerSize = proxy.size + player.mpvBackend.client?.setSize(proxy.size.width, proxy.size.height) + } + .onChange(of: proxy.size) { _ in + player.playerSize = proxy.size + player.mpvBackend.client?.setSize(proxy.size.width, proxy.size.height) + } + }) + case .appleAVPlayer: + player.avPlayerView + } + + PlayerGestures() + + PlayerControls(player: player) + } + .modifier( + VideoPlayerSizeModifier( + geometry: geometry, + aspectRatio: player.avPlayerBackend.controller?.aspectRatio, + fullScreen: playerControls.playingFullscreen ) + ) } } + .frame(maxWidth: fullScreenLayout ? .infinity : nil, maxHeight: fullScreenLayout ? .infinity : nil) + #if os(iOS) - .onSwipeGesture( - up: { - withAnimation { - fullScreenDetails = true - } - }, - down: { player.hide() } - ) + .onSwipeGesture( + up: { + withAnimation { + fullScreenDetails = true + } + }, + down: { player.hide() } + ) + .onHover { hovering in + hovering ? playerControls.show() : playerControls.hide() + } #endif - .background(Color.black) + .background(Color.black) - Group { - #if os(iOS) - if verticalSizeClass == .regular { + if !playerControls.playingFullscreen { + Group { + #if os(iOS) + if verticalSizeClass == .regular { + VideoDetails(sidebarQueue: sidebarQueueBinding, fullScreen: $fullScreenDetails) + } + + #else VideoDetails(sidebarQueue: sidebarQueueBinding, fullScreen: $fullScreenDetails) - } - - #else - VideoDetails(sidebarQueue: sidebarQueueBinding, fullScreen: $fullScreenDetails) - #endif + #endif + } + .background(colorScheme == .dark ? Color.black : Color.white) + .modifier(VideoDetailsPaddingModifier( + geometry: geometry, + aspectRatio: player.avPlayerBackend.controller?.aspectRatio, + fullScreen: fullScreenDetails + )) } - .background(colorScheme == .dark ? Color.black : Color.white) - .modifier(VideoDetailsPaddingModifier( - geometry: geometry, - aspectRatio: player.controller?.aspectRatio, - fullScreen: fullScreenDetails - )) } #endif } - .background(colorScheme == .dark ? Color.black : Color.white) + .background(((colorScheme == .dark || fullScreenLayout) ? Color.black : Color.white).edgesIgnoringSafeArea(.all)) #if os(macOS) .frame(minWidth: 650) #endif - #if os(iOS) - if sidebarQueue { - PlayerQueueView(sidebarQueue: .constant(true), fullScreen: $fullScreenDetails) - .frame(maxWidth: 350) - } - #elseif os(macOS) - if Defaults[.playerSidebar] != .never { - PlayerQueueView(sidebarQueue: sidebarQueueBinding, fullScreen: $fullScreenDetails) - .frame(minWidth: 300) - } - #endif + if !playerControls.playingFullscreen { + #if os(iOS) + if sidebarQueue { + PlayerQueueView(sidebarQueue: .constant(true), fullScreen: $fullScreenDetails) + .frame(maxWidth: 350) + } + #elseif os(macOS) + if Defaults[.playerSidebar] != .never { + PlayerQueueView(sidebarQueue: sidebarQueueBinding, fullScreen: $fullScreenDetails) + .frame(minWidth: 300) + } + #endif + } } + .ignoresSafeArea(.all, edges: fullScreenLayout ? .vertical : Edge.Set()) + .statusBar(hidden: playerControls.playingFullscreen) + .navigationBarHidden(true) + } + + var fullScreenLayout: Bool { + playerControls.playingFullscreen || verticalSizeClass == .compact } func playerPlaceholder(geometry: GeometryProxy) -> some View { @@ -235,7 +275,7 @@ struct VideoPlayerView: View { private func configureOrientationUpdatesBasedOnAccelerometer() { if UIDevice.current.orientation.isLandscape, enterFullscreenInLandscape, - !player.playingFullscreen, + !playerControls.playingFullscreen, !player.playingInPictureInPicture { DispatchQueue.main.async { diff --git a/Shared/Playlists/PlaylistsView.swift b/Shared/Playlists/PlaylistsView.swift index 2af9cad0..df4001e2 100644 --- a/Shared/Playlists/PlaylistsView.swift +++ b/Shared/Playlists/PlaylistsView.swift @@ -53,7 +53,7 @@ struct PlaylistsView: View { } var body: some View { - PlayerControlsView(toolbar: { + BrowserPlayerControls(toolbar: { HStack { HStack { newPlaylistButton diff --git a/Shared/RepeatingTimer.swift b/Shared/RepeatingTimer.swift new file mode 100644 index 00000000..3b244450 --- /dev/null +++ b/Shared/RepeatingTimer.swift @@ -0,0 +1,54 @@ +import Foundation + +final class RepeatingTimer { + let timeInterval: TimeInterval + + init(timeInterval: TimeInterval) { + self.timeInterval = timeInterval + } + + private lazy var timer: DispatchSourceTimer = { + let t = DispatchSource.makeTimerSource() + t.schedule(deadline: .now() + self.timeInterval, repeating: self.timeInterval) + t.setEventHandler { [weak self] in + self?.eventHandler?() + } + return t + }() + + var eventHandler: (() -> Void)? + + private enum State { + case suspended + case resumed + } + + private var state: State = .suspended + + deinit { + timer.setEventHandler {} + timer.cancel() + /* + If the timer is suspended, calling cancel without resuming + triggers a crash. This is documented here https://forums.developer.apple.com/thread/15902 + */ + resume() + eventHandler = nil + } + + func resume() { + if state == .resumed { + return + } + state = .resumed + timer.resume() + } + + func suspend() { + if state == .suspended { + return + } + state = .suspended + timer.suspend() + } +} diff --git a/Shared/Search/SearchView.swift b/Shared/Search/SearchView.swift index 6c5bbd37..31314e11 100644 --- a/Shared/Search/SearchView.swift +++ b/Shared/Search/SearchView.swift @@ -41,7 +41,7 @@ struct SearchView: View { } var body: some View { - PlayerControlsView(toolbar: { + BrowserPlayerControls(toolbar: { #if os(iOS) if accounts.app.supportsSearchFilters { HStack(spacing: 0) { diff --git a/Shared/Trending/TrendingView.swift b/Shared/Trending/TrendingView.swift index b637ac1b..54bfcba7 100644 --- a/Shared/Trending/TrendingView.swift +++ b/Shared/Trending/TrendingView.swift @@ -33,7 +33,7 @@ struct TrendingView: View { } var body: some View { - PlayerControlsView(toolbar: { + BrowserPlayerControls(toolbar: { HStack { if accounts.app.supportsTrendingCategories { HStack { diff --git a/Shared/Videos/VideoCell.swift b/Shared/Videos/VideoCell.swift index af3a7623..2b662642 100644 --- a/Shared/Videos/VideoCell.swift +++ b/Shared/Videos/VideoCell.swift @@ -72,7 +72,7 @@ struct VideoCell: View { } if !playNowContinues { - player.player.seek(to: .zero) + player.backend.seek(to: .zero) } player.play() @@ -255,7 +255,6 @@ struct VideoCell: View { HStack(spacing: 8) { if let date = video.publishedDate { HStack(spacing: 2) { - Image(systemName: "calendar") Text(date) .allowsTightening(true) } @@ -272,7 +271,6 @@ struct VideoCell: View { Spacer() HStack(spacing: 2) { - Image(systemName: "clock") Text(time) } } diff --git a/Shared/Views/PlayerControlsView.swift b/Shared/Views/BrowserPlayerControls.swift similarity index 94% rename from Shared/Views/PlayerControlsView.swift rename to Shared/Views/BrowserPlayerControls.swift index b6b19f0d..d46a5a8c 100644 --- a/Shared/Views/PlayerControlsView.swift +++ b/Shared/Views/BrowserPlayerControls.swift @@ -1,11 +1,12 @@ import Foundation import SwiftUI -struct PlayerControlsView: View { +struct BrowserPlayerControls: View { let content: Content let toolbar: Toolbar? @Environment(\.navigationStyle) private var navigationStyle + @EnvironmentObject private var playerControls @EnvironmentObject private var model init(@ViewBuilder toolbar: @escaping () -> Toolbar? = { nil }, @ViewBuilder content: @escaping () -> Content) { @@ -84,7 +85,7 @@ struct PlayerControlsView: View { ZStack(alignment: .bottom) { HStack { Group { - if model.isPlaying { + if playerControls.isPlaying { Button(action: { model.pause() }) { @@ -96,9 +97,9 @@ struct PlayerControlsView: View { }) { Label("Play", systemImage: "play.fill") } - .disabled(model.player.currentItem.isNil) } } + .disabled(playerControls.isLoadingVideo) .font(.system(size: 30)) .frame(minWidth: 30) @@ -145,7 +146,7 @@ struct PlayerControlsView: View { struct PlayerControlsView_Previews: PreviewProvider { static var previews: some View { - PlayerControlsView { + BrowserPlayerControls { VStack { Spacer() Text("Hello") diff --git a/Shared/Views/ChannelPlaylistView.swift b/Shared/Views/ChannelPlaylistView.swift index 66ff25bb..e38fa805 100644 --- a/Shared/Views/ChannelPlaylistView.swift +++ b/Shared/Views/ChannelPlaylistView.swift @@ -28,12 +28,12 @@ struct ChannelPlaylistView: View { if inNavigationView { content } else { - PlayerControlsView { + BrowserPlayerControls { content } } #else - PlayerControlsView { + BrowserPlayerControls { content } #endif diff --git a/Shared/Views/ChannelVideosView.swift b/Shared/Views/ChannelVideosView.swift index 4dc384a1..f672e9c3 100644 --- a/Shared/Views/ChannelVideosView.swift +++ b/Shared/Views/ChannelVideosView.swift @@ -33,12 +33,12 @@ struct ChannelVideosView: View { if inNavigationView { content } else { - PlayerControlsView { + BrowserPlayerControls { content } } #else - PlayerControlsView { + BrowserPlayerControls { content } #endif diff --git a/Shared/Views/MPVPlayerView.swift b/Shared/Views/MPVPlayerView.swift new file mode 100644 index 00000000..15dc0050 --- /dev/null +++ b/Shared/Views/MPVPlayerView.swift @@ -0,0 +1,33 @@ +import SwiftUI + +#if !os(macOS) + struct MPVPlayerView: UIViewControllerRepresentable { + @EnvironmentObject private var player + + @State private var controller = MPVViewController() + + func makeUIViewController(context _: Context) -> some UIViewController { + player.mpvBackend.controller = controller + player.mpvBackend.client = controller.client + + return controller + } + + func updateUIViewController(_: UIViewControllerType, context _: Context) {} + } +#else + struct MPVPlayerView: NSViewRepresentable { + let layer: VideoLayer + + func makeNSView(context _: Context) -> some NSView { + let vview = VideoView() + + vview.layer = layer + vview.wantsLayer = true + + return vview + } + + func updateNSView(_: NSViewType, context _: Context) {} + } +#endif diff --git a/Shared/Views/PlaylistVideosView.swift b/Shared/Views/PlaylistVideosView.swift index 92ffac77..7399c769 100644 --- a/Shared/Views/PlaylistVideosView.swift +++ b/Shared/Views/PlaylistVideosView.swift @@ -46,7 +46,7 @@ struct PlaylistVideosView: View { } var body: some View { - PlayerControlsView { + BrowserPlayerControls { VerticalCells(items: contentItems) .onAppear { if !player.accounts.app.userPlaylistsEndpointIncludesVideos { diff --git a/Shared/Views/PopularView.swift b/Shared/Views/PopularView.swift index 28cfd098..957515af 100644 --- a/Shared/Views/PopularView.swift +++ b/Shared/Views/PopularView.swift @@ -15,7 +15,7 @@ struct PopularView: View { } var body: some View { - PlayerControlsView { + BrowserPlayerControls { VerticalCells(items: videos) .onAppear { resource?.addObserver(store) diff --git a/Shared/Views/ShareButton.swift b/Shared/Views/ShareButton.swift index 373fb047..275a3f68 100644 --- a/Shared/Views/ShareButton.swift +++ b/Shared/Views/ShareButton.swift @@ -45,7 +45,7 @@ struct ShareButton: View { shareAction( accounts.api.shareURL( contentItem, - time: player.player.currentTime() + time: player.backend.currentTime )! ) } @@ -67,7 +67,7 @@ struct ShareButton: View { accounts.api.shareURL( contentItem, frontendHost: "www.youtube.com", - time: player.player.currentTime() + time: player.backend.currentTime )! ) } diff --git a/Shared/Views/SignInRequiredView.swift b/Shared/Views/SignInRequiredView.swift index 6fe4422c..d534e93f 100644 --- a/Shared/Views/SignInRequiredView.swift +++ b/Shared/Views/SignInRequiredView.swift @@ -60,7 +60,7 @@ struct SignInRequiredView: View { struct SignInRequiredView_Previews: PreviewProvider { static var previews: some View { - PlayerControlsView { + BrowserPlayerControls { SignInRequiredView(title: "Subscriptions") { Text("Only when signed in") } diff --git a/Shared/Views/SubscriptionsView.swift b/Shared/Views/SubscriptionsView.swift index 5ac717c2..e1aa9332 100644 --- a/Shared/Views/SubscriptionsView.swift +++ b/Shared/Views/SubscriptionsView.swift @@ -15,7 +15,7 @@ struct SubscriptionsView: View { } var body: some View { - PlayerControlsView { + BrowserPlayerControls { SignInRequiredView(title: "Subscriptions") { VerticalCells(items: videos) .onAppear { diff --git a/Shared/YatteeApp.swift b/Shared/YatteeApp.swift index 066556d5..57a42564 100644 --- a/Shared/YatteeApp.swift +++ b/Shared/YatteeApp.swift @@ -24,6 +24,7 @@ struct YatteeApp: App { @StateObject private var menu = MenuModel() @StateObject private var navigation = NavigationModel() @StateObject private var player = PlayerModel() + @StateObject private var playerControls = PlayerControlsModel() @StateObject private var playlists = PlaylistsModel() @StateObject private var recents = RecentsModel() @StateObject private var search = SearchModel() @@ -41,6 +42,7 @@ struct YatteeApp: App { .environmentObject(instances) .environmentObject(navigation) .environmentObject(player) + .environmentObject(playerControls) .environmentObject(playlists) .environmentObject(recents) .environmentObject(subscriptions) @@ -101,6 +103,7 @@ struct YatteeApp: App { .environmentObject(instances) .environmentObject(navigation) .environmentObject(player) + .environmentObject(playerControls) .environmentObject(playlists) .environmentObject(recents) .environmentObject(subscriptions) @@ -115,6 +118,7 @@ struct YatteeApp: App { .environmentObject(accounts) .environmentObject(instances) .environmentObject(player) + .environmentObject(playerControls) .environmentObject(updater) } #endif diff --git a/Vendor/mpv/iOS/include/client.h b/Vendor/mpv/iOS/include/client.h new file mode 100644 index 00000000..2e8dcdc9 --- /dev/null +++ b/Vendor/mpv/iOS/include/client.h @@ -0,0 +1,1969 @@ +/* Copyright (C) 2017 the mpv developers + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Note: the client API is licensed under ISC (see above) to enable + * other wrappers outside of mpv. But keep in mind that the + * mpv core is by default still GPLv2+ - unless built with + * --enable-lgpl, which makes it LGPLv2+. + */ + +#ifndef MPV_CLIENT_API_H_ +#define MPV_CLIENT_API_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Mechanisms provided by this API + * ------------------------------- + * + * This API provides general control over mpv playback. It does not give you + * direct access to individual components of the player, only the whole thing. + * It's somewhat equivalent to MPlayer's slave mode. You can send commands, + * retrieve or set playback status or settings with properties, and receive + * events. + * + * The API can be used in two ways: + * 1) Internally in mpv, to provide additional features to the command line + * player. Lua scripting uses this. (Currently there is no plugin API to + * get a client API handle in external user code. It has to be a fixed + * part of the player at compilation time.) + * 2) Using mpv as a library with mpv_create(). This basically allows embedding + * mpv in other applications. + * + * Documentation + * ------------- + * + * The libmpv C API is documented directly in this header. Note that most + * actual interaction with this player is done through + * options/commands/properties, which can be accessed through this API. + * Essentially everything is done with them, including loading a file, + * retrieving playback progress, and so on. + * + * These are documented elsewhere: + * * http://mpv.io/manual/master/#options + * * http://mpv.io/manual/master/#list-of-input-commands + * * http://mpv.io/manual/master/#properties + * + * You can also look at the examples here: + * * https://github.com/mpv-player/mpv-examples/tree/master/libmpv + * + * Event loop + * ---------- + * + * In general, the API user should run an event loop in order to receive events. + * This event loop should call mpv_wait_event(), which will return once a new + * mpv client API is available. It is also possible to integrate client API + * usage in other event loops (e.g. GUI toolkits) with the + * mpv_set_wakeup_callback() function, and then polling for events by calling + * mpv_wait_event() with a 0 timeout. + * + * Note that the event loop is detached from the actual player. Not calling + * mpv_wait_event() will not stop playback. It will eventually congest the + * event queue of your API handle, though. + * + * Synchronous vs. asynchronous calls + * ---------------------------------- + * + * The API allows both synchronous and asynchronous calls. Synchronous calls + * have to wait until the playback core is ready, which currently can take + * an unbounded time (e.g. if network is slow or unresponsive). Asynchronous + * calls just queue operations as requests, and return the result of the + * operation as events. + * + * Asynchronous calls + * ------------------ + * + * The client API includes asynchronous functions. These allow you to send + * requests instantly, and get replies as events at a later point. The + * requests are made with functions carrying the _async suffix, and replies + * are returned by mpv_wait_event() (interleaved with the normal event stream). + * + * A 64 bit userdata value is used to allow the user to associate requests + * with replies. The value is passed as reply_userdata parameter to the request + * function. The reply to the request will have the reply + * mpv_event->reply_userdata field set to the same value as the + * reply_userdata parameter of the corresponding request. + * + * This userdata value is arbitrary and is never interpreted by the API. Note + * that the userdata value 0 is also allowed, but then the client must be + * careful not accidentally interpret the mpv_event->reply_userdata if an + * event is not a reply. (For non-replies, this field is set to 0.) + * + * Asynchronous calls may be reordered in arbitrarily with other synchronous + * and asynchronous calls. If you want a guaranteed order, you need to wait + * until asynchronous calls report completion before doing the next call. + * + * See also the section "Asynchronous command details" in the manpage. + * + * Multithreading + * -------------- + * + * The client API is generally fully thread-safe, unless otherwise noted. + * Currently, there is no real advantage in using more than 1 thread to access + * the client API, since everything is serialized through a single lock in the + * playback core. + * + * Basic environment requirements + * ------------------------------ + * + * This documents basic requirements on the C environment. This is especially + * important if mpv is used as library with mpv_create(). + * + * - The LC_NUMERIC locale category must be set to "C". If your program calls + * setlocale(), be sure not to use LC_ALL, or if you do, reset LC_NUMERIC + * to its sane default: setlocale(LC_NUMERIC, "C"). + * - If a X11 based VO is used, mpv will set the xlib error handler. This error + * handler is process-wide, and there's no proper way to share it with other + * xlib users within the same process. This might confuse GUI toolkits. + * - mpv uses some other libraries that are not library-safe, such as Fribidi + * (used through libass), ALSA, FFmpeg, and possibly more. + * - The FPU precision must be set at least to double precision. + * - On Windows, mpv will call timeBeginPeriod(1). + * - On memory exhaustion, mpv will kill the process. + * - In certain cases, mpv may start sub processes (such as with the ytdl + * wrapper script). + * - Using UNIX IPC (off by default) will override the SIGPIPE signal handler, + * and set it to SIG_IGN. + * + * Encoding of filenames + * --------------------- + * + * mpv uses UTF-8 everywhere. + * + * On some platforms (like Linux), filenames actually do not have to be UTF-8; + * for this reason libmpv supports non-UTF-8 strings. libmpv uses what the + * kernel uses and does not recode filenames. At least on Linux, passing a + * string to libmpv is like passing a string to the fopen() function. + * + * On Windows, filenames are always UTF-8, libmpv converts between UTF-8 and + * UTF-16 when using win32 API functions. libmpv never uses or accepts + * filenames in the local 8 bit encoding. It does not use fopen() either; + * it uses _wfopen(). + * + * On OS X, filenames and other strings taken/returned by libmpv can have + * inconsistent unicode normalization. This can sometimes lead to problems. + * You have to hope for the best. + * + * Also see the remarks for MPV_FORMAT_STRING. + * + * Embedding the video window + * -------------------------- + * + * Using the render API (in render_cb.h) is recommended. This API requires + * you to create and maintain an OpenGL context, to which you can render + * video using a specific API call. This API does not include keyboard or mouse + * input directly. + * + * There is an older way to embed the native mpv window into your own. You have + * to get the raw window handle, and set it as "wid" option. This works on X11, + * win32, and OSX only. It's much easier to use than the render API, but + * also has various problems. + * + * Also see client API examples and the mpv manpage. There is an extensive + * discussion here: + * https://github.com/mpv-player/mpv-examples/tree/master/libmpv#methods-of-embedding-the-video-window + * + * Compatibility + * ------------- + * + * mpv development doesn't stand still, and changes to mpv internals as well as + * to its interface can cause compatibility issues to client API users. + * + * The API is versioned (see MPV_CLIENT_API_VERSION), and changes to it are + * documented in DOCS/client-api-changes.rst. The C API itself will probably + * remain compatible for a long time, but the functionality exposed by it + * could change more rapidly. For example, it's possible that options are + * renamed, or change the set of allowed values. + * + * Defensive programming should be used to potentially deal with the fact that + * options, commands, and properties could disappear, change their value range, + * or change the underlying datatypes. It might be a good idea to prefer + * MPV_FORMAT_STRING over other types to decouple your code from potential + * mpv changes. + * + * Also see: DOCS/compatibility.rst + * + * Future changes + * -------------- + * + * This are the planned changes that will most likely be done on the next major + * bump of the library: + * + * - remove all symbols and include files that are marked as deprecated + * - reassign enum numerical values to remove gaps + * - remove the mpv_opengl_init_params.extra_exts field + * - change the type of mpv_event_end_file.reason + * - disabling all events by default + */ + +/** + * The version is incremented on each API change. The 16 lower bits form the + * minor version number, and the 16 higher bits the major version number. If + * the API becomes incompatible to previous versions, the major version + * number is incremented. This affects only C part, and not properties and + * options. + * + * Every API bump is described in DOCS/client-api-changes.rst + * + * You can use MPV_MAKE_VERSION() and compare the result with integer + * relational operators (<, >, <=, >=). + */ +#define MPV_MAKE_VERSION(major, minor) (((major) << 16) | (minor) | 0UL) +#define MPV_CLIENT_API_VERSION MPV_MAKE_VERSION(1, 107) + +/** + * The API user is allowed to "#define MPV_ENABLE_DEPRECATED 0" before + * including any libmpv headers. Then deprecated symbols will be excluded + * from the headers. (Of course, deprecated properties and commands and + * other functionality will still work.) + */ +#ifndef MPV_ENABLE_DEPRECATED +#define MPV_ENABLE_DEPRECATED 1 +#endif + +/** + * Return the MPV_CLIENT_API_VERSION the mpv source has been compiled with. + */ +unsigned long mpv_client_api_version(void); + +/** + * Client context used by the client API. Every client has its own private + * handle. + */ +typedef struct mpv_handle mpv_handle; + +/** + * List of error codes than can be returned by API functions. 0 and positive + * return values always mean success, negative values are always errors. + */ +typedef enum mpv_error { + /** + * No error happened (used to signal successful operation). + * Keep in mind that many API functions returning error codes can also + * return positive values, which also indicate success. API users can + * hardcode the fact that ">= 0" means success. + */ + MPV_ERROR_SUCCESS = 0, + /** + * The event ringbuffer is full. This means the client is choked, and can't + * receive any events. This can happen when too many asynchronous requests + * have been made, but not answered. Probably never happens in practice, + * unless the mpv core is frozen for some reason, and the client keeps + * making asynchronous requests. (Bugs in the client API implementation + * could also trigger this, e.g. if events become "lost".) + */ + MPV_ERROR_EVENT_QUEUE_FULL = -1, + /** + * Memory allocation failed. + */ + MPV_ERROR_NOMEM = -2, + /** + * The mpv core wasn't configured and initialized yet. See the notes in + * mpv_create(). + */ + MPV_ERROR_UNINITIALIZED = -3, + /** + * Generic catch-all error if a parameter is set to an invalid or + * unsupported value. This is used if there is no better error code. + */ + MPV_ERROR_INVALID_PARAMETER = -4, + /** + * Trying to set an option that doesn't exist. + */ + MPV_ERROR_OPTION_NOT_FOUND = -5, + /** + * Trying to set an option using an unsupported MPV_FORMAT. + */ + MPV_ERROR_OPTION_FORMAT = -6, + /** + * Setting the option failed. Typically this happens if the provided option + * value could not be parsed. + */ + MPV_ERROR_OPTION_ERROR = -7, + /** + * The accessed property doesn't exist. + */ + MPV_ERROR_PROPERTY_NOT_FOUND = -8, + /** + * Trying to set or get a property using an unsupported MPV_FORMAT. + */ + MPV_ERROR_PROPERTY_FORMAT = -9, + /** + * The property exists, but is not available. This usually happens when the + * associated subsystem is not active, e.g. querying audio parameters while + * audio is disabled. + */ + MPV_ERROR_PROPERTY_UNAVAILABLE = -10, + /** + * Error setting or getting a property. + */ + MPV_ERROR_PROPERTY_ERROR = -11, + /** + * General error when running a command with mpv_command and similar. + */ + MPV_ERROR_COMMAND = -12, + /** + * Generic error on loading (usually used with mpv_event_end_file.error). + */ + MPV_ERROR_LOADING_FAILED = -13, + /** + * Initializing the audio output failed. + */ + MPV_ERROR_AO_INIT_FAILED = -14, + /** + * Initializing the video output failed. + */ + MPV_ERROR_VO_INIT_FAILED = -15, + /** + * There was no audio or video data to play. This also happens if the + * file was recognized, but did not contain any audio or video streams, + * or no streams were selected. + */ + MPV_ERROR_NOTHING_TO_PLAY = -16, + /** + * When trying to load the file, the file format could not be determined, + * or the file was too broken to open it. + */ + MPV_ERROR_UNKNOWN_FORMAT = -17, + /** + * Generic error for signaling that certain system requirements are not + * fulfilled. + */ + MPV_ERROR_UNSUPPORTED = -18, + /** + * The API function which was called is a stub only. + */ + MPV_ERROR_NOT_IMPLEMENTED = -19, + /** + * Unspecified error. + */ + MPV_ERROR_GENERIC = -20 +} mpv_error; + +/** + * Return a string describing the error. For unknown errors, the string + * "unknown error" is returned. + * + * @param error error number, see enum mpv_error + * @return A static string describing the error. The string is completely + * static, i.e. doesn't need to be deallocated, and is valid forever. + */ +const char *mpv_error_string(int error); + +/** + * General function to deallocate memory returned by some of the API functions. + * Call this only if it's explicitly documented as allowed. Calling this on + * mpv memory not owned by the caller will lead to undefined behavior. + * + * @param data A valid pointer returned by the API, or NULL. + */ +void mpv_free(void *data); + +/** + * Return the name of this client handle. Every client has its own unique + * name, which is mostly used for user interface purposes. + * + * @return The client name. The string is read-only and is valid until the + * mpv_handle is destroyed. + */ +const char *mpv_client_name(mpv_handle *ctx); + +/** + * Create a new mpv instance and an associated client API handle to control + * the mpv instance. This instance is in a pre-initialized state, + * and needs to be initialized to be actually used with most other API + * functions. + * + * Some API functions will return MPV_ERROR_UNINITIALIZED in the uninitialized + * state. You can call mpv_set_property() (or mpv_set_property_string() and + * other variants, and before mpv 0.21.0 mpv_set_option() etc.) to set initial + * options. After this, call mpv_initialize() to start the player, and then use + * e.g. mpv_command() to start playback of a file. + * + * The point of separating handle creation and actual initialization is that + * you can configure things which can't be changed during runtime. + * + * Unlike the command line player, this will have initial settings suitable + * for embedding in applications. The following settings are different: + * - stdin/stdout/stderr and the terminal will never be accessed. This is + * equivalent to setting the --no-terminal option. + * (Technically, this also suppresses C signal handling.) + * - No config files will be loaded. This is roughly equivalent to using + * --config=no. Since libmpv 1.15, you can actually re-enable this option, + * which will make libmpv load config files during mpv_initialize(). If you + * do this, you are strongly encouraged to set the "config-dir" option too. + * (Otherwise it will load the mpv command line player's config.) + * For example: + * mpv_set_option_string(mpv, "config-dir", "/my/path"); // set config root + * mpv_set_option_string(mpv, "config", "yes"); // enable config loading + * (call mpv_initialize() _after_ this) + * - Idle mode is enabled, which means the playback core will enter idle mode + * if there are no more files to play on the internal playlist, instead of + * exiting. This is equivalent to the --idle option. + * - Disable parts of input handling. + * - Most of the different settings can be viewed with the command line player + * by running "mpv --show-profile=libmpv". + * + * All this assumes that API users want a mpv instance that is strictly + * isolated from the command line player's configuration, user settings, and + * so on. You can re-enable disabled features by setting the appropriate + * options. + * + * The mpv command line parser is not available through this API, but you can + * set individual options with mpv_set_property(). Files for playback must be + * loaded with mpv_command() or others. + * + * Note that you should avoid doing concurrent accesses on the uninitialized + * client handle. (Whether concurrent access is definitely allowed or not has + * yet to be decided.) + * + * @return a new mpv client API handle. Returns NULL on error. Currently, this + * can happen in the following situations: + * - out of memory + * - LC_NUMERIC is not set to "C" (see general remarks) + */ +mpv_handle *mpv_create(void); + +/** + * Initialize an uninitialized mpv instance. If the mpv instance is already + * running, an error is returned. + * + * This function needs to be called to make full use of the client API if the + * client API handle was created with mpv_create(). + * + * Only the following options are required to be set _before_ mpv_initialize(): + * - options which are only read at initialization time: + * - config + * - config-dir + * - input-conf + * - load-scripts + * - script + * - player-operation-mode + * - input-app-events (OSX) + * - all encoding mode options + * + * @return error code + */ +int mpv_initialize(mpv_handle *ctx); + +/** + * Disconnect and destroy the mpv_handle. ctx will be deallocated with this + * API call. + * + * If the last mpv_handle is detached, the core player is destroyed. In + * addition, if there are only weak mpv_handles (such as created by + * mpv_create_weak_client() or internal scripts), these mpv_handles will + * be sent MPV_EVENT_SHUTDOWN. This function may block until these clients + * have responded to the shutdown event, and the core is finally destroyed. + */ +void mpv_destroy(mpv_handle *ctx); + +#if MPV_ENABLE_DEPRECATED +/** + * @deprecated use mpv_destroy(), which has exactly the same semantics (the + * deprecation is a mere rename) + * + * Since mpv client API version 1.29: + * If the last mpv_handle is detached, the core player is destroyed. In + * addition, if there are only weak mpv_handles (such as created by + * mpv_create_weak_client() or internal scripts), these mpv_handles will + * be sent MPV_EVENT_SHUTDOWN. This function may block until these clients + * have responded to the shutdown event, and the core is finally destroyed. + * + * Before mpv client API version 1.29: + * This left the player running. If you want to be sure that the + * player is terminated, send a "quit" command, and wait until the + * MPV_EVENT_SHUTDOWN event is received, or use mpv_terminate_destroy(). + */ +void mpv_detach_destroy(mpv_handle *ctx); +#endif + +/** + * Similar to mpv_destroy(), but brings the player and all clients down + * as well, and waits until all of them are destroyed. This function blocks. The + * advantage over mpv_destroy() is that while mpv_destroy() merely + * detaches the client handle from the player, this function quits the player, + * waits until all other clients are destroyed (i.e. all mpv_handles are + * detached), and also waits for the final termination of the player. + * + * Since mpv_destroy() is called somewhere on the way, it's not safe to + * call other functions concurrently on the same context. + * + * Since mpv client API version 1.29: + * The first call on any mpv_handle will block until the core is destroyed. + * This means it will wait until other mpv_handle have been destroyed. If you + * want asynchronous destruction, just run the "quit" command, and then react + * to the MPV_EVENT_SHUTDOWN event. + * If another mpv_handle already called mpv_terminate_destroy(), this call will + * not actually block. It will destroy the mpv_handle, and exit immediately, + * while other mpv_handles might still be uninitializing. + * + * Before mpv client API version 1.29: + * If this is called on a mpv_handle that was not created with mpv_create(), + * this function will merely send a quit command and then call + * mpv_destroy(), without waiting for the actual shutdown. + */ +void mpv_terminate_destroy(mpv_handle *ctx); + +/** + * Create a new client handle connected to the same player core as ctx. This + * context has its own event queue, its own mpv_request_event() state, its own + * mpv_request_log_messages() state, its own set of observed properties, and + * its own state for asynchronous operations. Otherwise, everything is shared. + * + * This handle should be destroyed with mpv_destroy() if no longer + * needed. The core will live as long as there is at least 1 handle referencing + * it. Any handle can make the core quit, which will result in every handle + * receiving MPV_EVENT_SHUTDOWN. + * + * This function can not be called before the main handle was initialized with + * mpv_initialize(). The new handle is always initialized, unless ctx=NULL was + * passed. + * + * @param ctx Used to get the reference to the mpv core; handle-specific + * settings and parameters are not used. + * If NULL, this function behaves like mpv_create() (ignores name). + * @param name The client name. This will be returned by mpv_client_name(). If + * the name is already in use, or contains non-alphanumeric + * characters (other than '_'), the name is modified to fit. + * If NULL, an arbitrary name is automatically chosen. + * @return a new handle, or NULL on error + */ +mpv_handle *mpv_create_client(mpv_handle *ctx, const char *name); + +/** + * This is the same as mpv_create_client(), but the created mpv_handle is + * treated as a weak reference. If all mpv_handles referencing a core are + * weak references, the core is automatically destroyed. (This still goes + * through normal uninit of course. Effectively, if the last non-weak mpv_handle + * is destroyed, then the weak mpv_handles receive MPV_EVENT_SHUTDOWN and are + * asked to terminate as well.) + * + * Note if you want to use this like refcounting: you have to be aware that + * mpv_terminate_destroy() _and_ mpv_destroy() for the last non-weak + * mpv_handle will block until all weak mpv_handles are destroyed. + */ +mpv_handle *mpv_create_weak_client(mpv_handle *ctx, const char *name); + +/** + * Load a config file. This loads and parses the file, and sets every entry in + * the config file's default section as if mpv_set_option_string() is called. + * + * The filename should be an absolute path. If it isn't, the actual path used + * is unspecified. (Note: an absolute path starts with '/' on UNIX.) If the + * file wasn't found, MPV_ERROR_INVALID_PARAMETER is returned. + * + * If a fatal error happens when parsing a config file, MPV_ERROR_OPTION_ERROR + * is returned. Errors when setting options as well as other types or errors + * are ignored (even if options do not exist). You can still try to capture + * the resulting error messages with mpv_request_log_messages(). Note that it's + * possible that some options were successfully set even if any of these errors + * happen. + * + * @param filename absolute path to the config file on the local filesystem + * @return error code + */ +int mpv_load_config_file(mpv_handle *ctx, const char *filename); + +#if MPV_ENABLE_DEPRECATED + +/** + * This does nothing since mpv 0.23.0 (API version 1.24). Below is the + * description of the old behavior. + * + * Stop the playback thread. This means the core will stop doing anything, and + * only run and answer to client API requests. This is sometimes useful; for + * example, no new frame will be queued to the video output, so doing requests + * which have to wait on the video output can run instantly. + * + * Suspension is reentrant and recursive for convenience. Any thread can call + * the suspend function multiple times, and the playback thread will remain + * suspended until the last thread resumes it. Note that during suspension, all + * clients still have concurrent access to the core, which is serialized through + * a single mutex. + * + * Call mpv_resume() to resume the playback thread. You must call mpv_resume() + * for each mpv_suspend() call. Calling mpv_resume() more often than + * mpv_suspend() is not allowed. + * + * Calling this on an uninitialized player (see mpv_create()) will deadlock. + * + * @deprecated This function, as well as mpv_resume(), are deprecated, and + * will stop doing anything soon. Their semantics were never + * well-defined, and their usefulness is extremely limited. The + * calls will remain stubs in order to keep ABI compatibility. + */ +void mpv_suspend(mpv_handle *ctx); + +/** + * See mpv_suspend(). + */ +void mpv_resume(mpv_handle *ctx); + +#endif + +/** + * Return the internal time in microseconds. This has an arbitrary start offset, + * but will never wrap or go backwards. + * + * Note that this is always the real time, and doesn't necessarily have to do + * with playback time. For example, playback could go faster or slower due to + * playback speed, or due to playback being paused. Use the "time-pos" property + * instead to get the playback status. + * + * Unlike other libmpv APIs, this can be called at absolutely any time (even + * within wakeup callbacks), as long as the context is valid. + * + * Safe to be called from mpv render API threads. + */ +int64_t mpv_get_time_us(mpv_handle *ctx); + +/** + * Data format for options and properties. The API functions to get/set + * properties and options support multiple formats, and this enum describes + * them. + */ +typedef enum mpv_format { + /** + * Invalid. Sometimes used for empty values. + */ + MPV_FORMAT_NONE = 0, + /** + * The basic type is char*. It returns the raw property string, like + * using ${=property} in input.conf (see input.rst). + * + * NULL isn't an allowed value. + * + * Warning: although the encoding is usually UTF-8, this is not always the + * case. File tags often store strings in some legacy codepage, + * and even filenames don't necessarily have to be in UTF-8 (at + * least on Linux). If you pass the strings to code that requires + * valid UTF-8, you have to sanitize it in some way. + * On Windows, filenames are always UTF-8, and libmpv converts + * between UTF-8 and UTF-16 when using win32 API functions. See + * the "Encoding of filenames" section for details. + * + * Example for reading: + * + * char *result = NULL; + * if (mpv_get_property(ctx, "property", MPV_FORMAT_STRING, &result) < 0) + * goto error; + * printf("%s\n", result); + * mpv_free(result); + * + * Or just use mpv_get_property_string(). + * + * Example for writing: + * + * char *value = "the new value"; + * // yep, you pass the address to the variable + * // (needed for symmetry with other types and mpv_get_property) + * mpv_set_property(ctx, "property", MPV_FORMAT_STRING, &value); + * + * Or just use mpv_set_property_string(). + * + */ + MPV_FORMAT_STRING = 1, + /** + * The basic type is char*. It returns the OSD property string, like + * using ${property} in input.conf (see input.rst). In many cases, this + * is the same as the raw string, but in other cases it's formatted for + * display on OSD. It's intended to be human readable. Do not attempt to + * parse these strings. + * + * Only valid when doing read access. The rest works like MPV_FORMAT_STRING. + */ + MPV_FORMAT_OSD_STRING = 2, + /** + * The basic type is int. The only allowed values are 0 ("no") + * and 1 ("yes"). + * + * Example for reading: + * + * int result; + * if (mpv_get_property(ctx, "property", MPV_FORMAT_FLAG, &result) < 0) + * goto error; + * printf("%s\n", result ? "true" : "false"); + * + * Example for writing: + * + * int flag = 1; + * mpv_set_property(ctx, "property", MPV_FORMAT_FLAG, &flag); + */ + MPV_FORMAT_FLAG = 3, + /** + * The basic type is int64_t. + */ + MPV_FORMAT_INT64 = 4, + /** + * The basic type is double. + */ + MPV_FORMAT_DOUBLE = 5, + /** + * The type is mpv_node. + * + * For reading, you usually would pass a pointer to a stack-allocated + * mpv_node value to mpv, and when you're done you call + * mpv_free_node_contents(&node). + * You're expected not to write to the data - if you have to, copy it + * first (which you have to do manually). + * + * For writing, you construct your own mpv_node, and pass a pointer to the + * API. The API will never write to your data (and copy it if needed), so + * you're free to use any form of allocation or memory management you like. + * + * Warning: when reading, always check the mpv_node.format member. For + * example, properties might change their type in future versions + * of mpv, or sometimes even during runtime. + * + * Example for reading: + * + * mpv_node result; + * if (mpv_get_property(ctx, "property", MPV_FORMAT_NODE, &result) < 0) + * goto error; + * printf("format=%d\n", (int)result.format); + * mpv_free_node_contents(&result). + * + * Example for writing: + * + * mpv_node value; + * value.format = MPV_FORMAT_STRING; + * value.u.string = "hello"; + * mpv_set_property(ctx, "property", MPV_FORMAT_NODE, &value); + */ + MPV_FORMAT_NODE = 6, + /** + * Used with mpv_node only. Can usually not be used directly. + */ + MPV_FORMAT_NODE_ARRAY = 7, + /** + * See MPV_FORMAT_NODE_ARRAY. + */ + MPV_FORMAT_NODE_MAP = 8, + /** + * A raw, untyped byte array. Only used only with mpv_node, and only in + * some very special situations. (Currently, only for the screenshot-raw + * command.) + */ + MPV_FORMAT_BYTE_ARRAY = 9 +} mpv_format; + +/** + * Generic data storage. + * + * If mpv writes this struct (e.g. via mpv_get_property()), you must not change + * the data. In some cases (mpv_get_property()), you have to free it with + * mpv_free_node_contents(). If you fill this struct yourself, you're also + * responsible for freeing it, and you must not call mpv_free_node_contents(). + */ +typedef struct mpv_node { + union { + char *string; /** valid if format==MPV_FORMAT_STRING */ + int flag; /** valid if format==MPV_FORMAT_FLAG */ + int64_t int64; /** valid if format==MPV_FORMAT_INT64 */ + double double_; /** valid if format==MPV_FORMAT_DOUBLE */ + /** + * valid if format==MPV_FORMAT_NODE_ARRAY + * or if format==MPV_FORMAT_NODE_MAP + */ + struct mpv_node_list *list; + /** + * valid if format==MPV_FORMAT_BYTE_ARRAY + */ + struct mpv_byte_array *ba; + } u; + /** + * Type of the data stored in this struct. This value rules what members in + * the given union can be accessed. The following formats are currently + * defined to be allowed in mpv_node: + * + * MPV_FORMAT_STRING (u.string) + * MPV_FORMAT_FLAG (u.flag) + * MPV_FORMAT_INT64 (u.int64) + * MPV_FORMAT_DOUBLE (u.double_) + * MPV_FORMAT_NODE_ARRAY (u.list) + * MPV_FORMAT_NODE_MAP (u.list) + * MPV_FORMAT_BYTE_ARRAY (u.ba) + * MPV_FORMAT_NONE (no member) + * + * If you encounter a value you don't know, you must not make any + * assumptions about the contents of union u. + */ + mpv_format format; +} mpv_node; + +/** + * (see mpv_node) + */ +typedef struct mpv_node_list { + /** + * Number of entries. Negative values are not allowed. + */ + int num; + /** + * MPV_FORMAT_NODE_ARRAY: + * values[N] refers to value of the Nth item + * + * MPV_FORMAT_NODE_MAP: + * values[N] refers to value of the Nth key/value pair + * + * If num > 0, values[0] to values[num-1] (inclusive) are valid. + * Otherwise, this can be NULL. + */ + mpv_node *values; + /** + * MPV_FORMAT_NODE_ARRAY: + * unused (typically NULL), access is not allowed + * + * MPV_FORMAT_NODE_MAP: + * keys[N] refers to key of the Nth key/value pair. If num > 0, keys[0] to + * keys[num-1] (inclusive) are valid. Otherwise, this can be NULL. + * The keys are in random order. The only guarantee is that keys[N] belongs + * to the value values[N]. NULL keys are not allowed. + */ + char **keys; +} mpv_node_list; + +/** + * (see mpv_node) + */ +typedef struct mpv_byte_array { + /** + * Pointer to the data. In what format the data is stored is up to whatever + * uses MPV_FORMAT_BYTE_ARRAY. + */ + void *data; + /** + * Size of the data pointed to by ptr. + */ + size_t size; +} mpv_byte_array; + +/** + * Frees any data referenced by the node. It doesn't free the node itself. + * Call this only if the mpv client API set the node. If you constructed the + * node yourself (manually), you have to free it yourself. + * + * If node->format is MPV_FORMAT_NONE, this call does nothing. Likewise, if + * the client API sets a node with this format, this function doesn't need to + * be called. (This is just a clarification that there's no danger of anything + * strange happening in these cases.) + */ +void mpv_free_node_contents(mpv_node *node); + +/** + * Set an option. Note that you can't normally set options during runtime. It + * works in uninitialized state (see mpv_create()), and in some cases in at + * runtime. + * + * Using a format other than MPV_FORMAT_NODE is equivalent to constructing a + * mpv_node with the given format and data, and passing the mpv_node to this + * function. + * + * Note: this is semi-deprecated. For most purposes, this is not needed anymore. + * Starting with mpv version 0.21.0 (version 1.23) most options can be set + * with mpv_set_property() (and related functions), and even before + * mpv_initialize(). In some obscure corner cases, using this function + * to set options might still be required (see below, and also section + * "Inconsistencies between options and properties" on the manpage). Once + * these are resolved, the option setting functions might be fully + * deprecated. + * + * The following options still need to be set either _before_ + * mpv_initialize() with mpv_set_property() (or related functions), or + * with mpv_set_option() (or related functions) at any time: + * - options shadowed by deprecated properties: + * - demuxer (property deprecated in 0.21.0) + * - idle (property deprecated in 0.21.0) + * - fps (property deprecated in 0.21.0) + * - cache (property deprecated in 0.21.0) + * - length (property deprecated in 0.10.0) + * - audio-samplerate (property deprecated in 0.10.0) + * - audio-channels (property deprecated in 0.10.0) + * - audio-format (property deprecated in 0.10.0) + * - deprecated options shadowed by properties: + * - chapter (option deprecated in 0.21.0) + * - playlist-pos (option deprecated in 0.21.0) + * The deprecated properties were removed in mpv 0.23.0. + * + * @param name Option name. This is the same as on the mpv command line, but + * without the leading "--". + * @param format see enum mpv_format. + * @param[in] data Option value (according to the format). + * @return error code + */ +int mpv_set_option(mpv_handle *ctx, const char *name, mpv_format format, + void *data); + +/** + * Convenience function to set an option to a string value. This is like + * calling mpv_set_option() with MPV_FORMAT_STRING. + * + * @return error code + */ +int mpv_set_option_string(mpv_handle *ctx, const char *name, const char *data); + +/** + * Send a command to the player. Commands are the same as those used in + * input.conf, except that this function takes parameters in a pre-split + * form. + * + * The commands and their parameters are documented in input.rst. + * + * Does not use OSD and string expansion by default (unlike mpv_command_string() + * and input.conf). + * + * @param[in] args NULL-terminated list of strings. Usually, the first item + * is the command, and the following items are arguments. + * @return error code + */ +int mpv_command(mpv_handle *ctx, const char **args); + +/** + * Same as mpv_command(), but allows passing structured data in any format. + * In particular, calling mpv_command() is exactly like calling + * mpv_command_node() with the format set to MPV_FORMAT_NODE_ARRAY, and + * every arg passed in order as MPV_FORMAT_STRING. + * + * Does not use OSD and string expansion by default. + * + * The args argument can have one of the following formats: + * + * MPV_FORMAT_NODE_ARRAY: + * Positional arguments. Each entry is an argument using an arbitrary + * format (the format must be compatible to the used command). Usually, + * the first item is the command name (as MPV_FORMAT_STRING). The order + * of arguments is as documented in each command description. + * + * MPV_FORMAT_NODE_MAP: + * Named arguments. This requires at least an entry with the key "name" + * to be present, which must be a string, and contains the command name. + * The special entry "_flags" is optional, and if present, must be an + * array of strings, each being a command prefix to apply. All other + * entries are interpreted as arguments. They must use the argument names + * as documented in each command description. Some commands do not + * support named arguments at all, and must use MPV_FORMAT_NODE_ARRAY. + * + * @param[in] args mpv_node with format set to one of the values documented + * above (see there for details) + * @param[out] result Optional, pass NULL if unused. If not NULL, and if the + * function succeeds, this is set to command-specific return + * data. You must call mpv_free_node_contents() to free it + * (again, only if the command actually succeeds). + * Not many commands actually use this at all. + * @return error code (the result parameter is not set on error) + */ +int mpv_command_node(mpv_handle *ctx, mpv_node *args, mpv_node *result); + +/** + * This is essentially identical to mpv_command() but it also returns a result. + * + * Does not use OSD and string expansion by default. + * + * @param[in] args NULL-terminated list of strings. Usually, the first item + * is the command, and the following items are arguments. + * @param[out] result Optional, pass NULL if unused. If not NULL, and if the + * function succeeds, this is set to command-specific return + * data. You must call mpv_free_node_contents() to free it + * (again, only if the command actually succeeds). + * Not many commands actually use this at all. + * @return error code (the result parameter is not set on error) + */ +int mpv_command_ret(mpv_handle *ctx, const char **args, mpv_node *result); + +/** + * Same as mpv_command, but use input.conf parsing for splitting arguments. + * This is slightly simpler, but also more error prone, since arguments may + * need quoting/escaping. + * + * This also has OSD and string expansion enabled by default. + */ +int mpv_command_string(mpv_handle *ctx, const char *args); + +/** + * Same as mpv_command, but run the command asynchronously. + * + * Commands are executed asynchronously. You will receive a + * MPV_EVENT_COMMAND_REPLY event. This event will also have an + * error code set if running the command failed. For commands that + * return data, the data is put into mpv_event_command.result. + * + * Safe to be called from mpv render API threads. + * + * @param reply_userdata the value mpv_event.reply_userdata of the reply will + * be set to (see section about asynchronous calls) + * @param args NULL-terminated list of strings (see mpv_command()) + * @return error code (if parsing or queuing the command fails) + */ +int mpv_command_async(mpv_handle *ctx, uint64_t reply_userdata, + const char **args); + +/** + * Same as mpv_command_node(), but run it asynchronously. Basically, this + * function is to mpv_command_node() what mpv_command_async() is to + * mpv_command(). + * + * See mpv_command_async() for details. + * + * Safe to be called from mpv render API threads. + * + * @param reply_userdata the value mpv_event.reply_userdata of the reply will + * be set to (see section about asynchronous calls) + * @param args as in mpv_command_node() + * @return error code (if parsing or queuing the command fails) + */ +int mpv_command_node_async(mpv_handle *ctx, uint64_t reply_userdata, + mpv_node *args); + +/** + * Signal to all async requests with the matching ID to abort. This affects + * the following API calls: + * + * mpv_command_async + * mpv_command_node_async + * + * All of these functions take a reply_userdata parameter. This API function + * tells all requests with the matching reply_userdata value to try to return + * as soon as possible. If there are multiple requests with matching ID, it + * aborts all of them. + * + * This API function is mostly asynchronous itself. It will not wait until the + * command is aborted. Instead, the command will terminate as usual, but with + * some work not done. How this is signaled depends on the specific command (for + * example, the "subprocess" command will indicate it by "killed_by_us" set to + * true in the result). How long it takes also depends on the situation. The + * aborting process is completely asynchronous. + * + * Not all commands may support this functionality. In this case, this function + * will have no effect. The same is true if the request using the passed + * reply_userdata has already terminated, has not been started yet, or was + * never in use at all. + * + * You have to be careful of race conditions: the time during which the abort + * request will be effective is _after_ e.g. mpv_command_async() has returned, + * and before the command has signaled completion with MPV_EVENT_COMMAND_REPLY. + * + * @param reply_userdata ID of the request to be aborted (see above) + */ +void mpv_abort_async_command(mpv_handle *ctx, uint64_t reply_userdata); + +/** + * Set a property to a given value. Properties are essentially variables which + * can be queried or set at runtime. For example, writing to the pause property + * will actually pause or unpause playback. + * + * If the format doesn't match with the internal format of the property, access + * usually will fail with MPV_ERROR_PROPERTY_FORMAT. In some cases, the data + * is automatically converted and access succeeds. For example, MPV_FORMAT_INT64 + * is always converted to MPV_FORMAT_DOUBLE, and access using MPV_FORMAT_STRING + * usually invokes a string parser. The same happens when calling this function + * with MPV_FORMAT_NODE: the underlying format may be converted to another + * type if possible. + * + * Using a format other than MPV_FORMAT_NODE is equivalent to constructing a + * mpv_node with the given format and data, and passing the mpv_node to this + * function. (Before API version 1.21, this was different.) + * + * Note: starting with mpv 0.21.0 (client API version 1.23), this can be used to + * set options in general. It even can be used before mpv_initialize() + * has been called. If called before mpv_initialize(), setting properties + * not backed by options will result in MPV_ERROR_PROPERTY_UNAVAILABLE. + * In some cases, properties and options still conflict. In these cases, + * mpv_set_property() accesses the options before mpv_initialize(), and + * the properties after mpv_initialize(). These conflicts will be removed + * in mpv 0.23.0. See mpv_set_option() for further remarks. + * + * @param name The property name. See input.rst for a list of properties. + * @param format see enum mpv_format. + * @param[in] data Option value. + * @return error code + */ +int mpv_set_property(mpv_handle *ctx, const char *name, mpv_format format, + void *data); + +/** + * Convenience function to set a property to a string value. + * + * This is like calling mpv_set_property() with MPV_FORMAT_STRING. + */ +int mpv_set_property_string(mpv_handle *ctx, const char *name, const char *data); + +/** + * Set a property asynchronously. You will receive the result of the operation + * as MPV_EVENT_SET_PROPERTY_REPLY event. The mpv_event.error field will contain + * the result status of the operation. Otherwise, this function is similar to + * mpv_set_property(). + * + * Safe to be called from mpv render API threads. + * + * @param reply_userdata see section about asynchronous calls + * @param name The property name. + * @param format see enum mpv_format. + * @param[in] data Option value. The value will be copied by the function. It + * will never be modified by the client API. + * @return error code if sending the request failed + */ +int mpv_set_property_async(mpv_handle *ctx, uint64_t reply_userdata, + const char *name, mpv_format format, void *data); + +/** + * Read the value of the given property. + * + * If the format doesn't match with the internal format of the property, access + * usually will fail with MPV_ERROR_PROPERTY_FORMAT. In some cases, the data + * is automatically converted and access succeeds. For example, MPV_FORMAT_INT64 + * is always converted to MPV_FORMAT_DOUBLE, and access using MPV_FORMAT_STRING + * usually invokes a string formatter. + * + * @param name The property name. + * @param format see enum mpv_format. + * @param[out] data Pointer to the variable holding the option value. On + * success, the variable will be set to a copy of the option + * value. For formats that require dynamic memory allocation, + * you can free the value with mpv_free() (strings) or + * mpv_free_node_contents() (MPV_FORMAT_NODE). + * @return error code + */ +int mpv_get_property(mpv_handle *ctx, const char *name, mpv_format format, + void *data); + +/** + * Return the value of the property with the given name as string. This is + * equivalent to mpv_get_property() with MPV_FORMAT_STRING. + * + * See MPV_FORMAT_STRING for character encoding issues. + * + * On error, NULL is returned. Use mpv_get_property() if you want fine-grained + * error reporting. + * + * @param name The property name. + * @return Property value, or NULL if the property can't be retrieved. Free + * the string with mpv_free(). + */ +char *mpv_get_property_string(mpv_handle *ctx, const char *name); + +/** + * Return the property as "OSD" formatted string. This is the same as + * mpv_get_property_string, but using MPV_FORMAT_OSD_STRING. + * + * @return Property value, or NULL if the property can't be retrieved. Free + * the string with mpv_free(). + */ +char *mpv_get_property_osd_string(mpv_handle *ctx, const char *name); + +/** + * Get a property asynchronously. You will receive the result of the operation + * as well as the property data with the MPV_EVENT_GET_PROPERTY_REPLY event. + * You should check the mpv_event.error field on the reply event. + * + * Safe to be called from mpv render API threads. + * + * @param reply_userdata see section about asynchronous calls + * @param name The property name. + * @param format see enum mpv_format. + * @return error code if sending the request failed + */ +int mpv_get_property_async(mpv_handle *ctx, uint64_t reply_userdata, + const char *name, mpv_format format); + +/** + * Get a notification whenever the given property changes. You will receive + * updates as MPV_EVENT_PROPERTY_CHANGE. Note that this is not very precise: + * for some properties, it may not send updates even if the property changed. + * This depends on the property, and it's a valid feature request to ask for + * better update handling of a specific property. (For some properties, like + * ``clock``, which shows the wall clock, this mechanism doesn't make too + * much sense anyway.) + * + * Property changes are coalesced: the change events are returned only once the + * event queue becomes empty (e.g. mpv_wait_event() would block or return + * MPV_EVENT_NONE), and then only one event per changed property is returned. + * + * You always get an initial change notification. This is meant to initialize + * the user's state to the current value of the property. + * + * Normally, change events are sent only if the property value changes according + * to the requested format. mpv_event_property will contain the property value + * as data member. + * + * Warning: if a property is unavailable or retrieving it caused an error, + * MPV_FORMAT_NONE will be set in mpv_event_property, even if the + * format parameter was set to a different value. In this case, the + * mpv_event_property.data field is invalid. + * + * If the property is observed with the format parameter set to MPV_FORMAT_NONE, + * you get low-level notifications whether the property _may_ have changed, and + * the data member in mpv_event_property will be unset. With this mode, you + * will have to determine yourself whether the property really changed. On the + * other hand, this mechanism can be faster and uses less resources. + * + * Observing a property that doesn't exist is allowed. (Although it may still + * cause some sporadic change events.) + * + * Keep in mind that you will get change notifications even if you change a + * property yourself. Try to avoid endless feedback loops, which could happen + * if you react to the change notifications triggered by your own change. + * + * Only the mpv_handle on which this was called will receive the property + * change events, or can unobserve them. + * + * Safe to be called from mpv render API threads. + * + * @param reply_userdata This will be used for the mpv_event.reply_userdata + * field for the received MPV_EVENT_PROPERTY_CHANGE + * events. (Also see section about asynchronous calls, + * although this function is somewhat different from + * actual asynchronous calls.) + * If you have no use for this, pass 0. + * Also see mpv_unobserve_property(). + * @param name The property name. + * @param format see enum mpv_format. Can be MPV_FORMAT_NONE to omit values + * from the change events. + * @return error code (usually fails only on OOM or unsupported format) + */ +int mpv_observe_property(mpv_handle *mpv, uint64_t reply_userdata, + const char *name, mpv_format format); + +/** + * Undo mpv_observe_property(). This will remove all observed properties for + * which the given number was passed as reply_userdata to mpv_observe_property. + * + * Safe to be called from mpv render API threads. + * + * @param registered_reply_userdata ID that was passed to mpv_observe_property + * @return negative value is an error code, >=0 is number of removed properties + * on success (includes the case when 0 were removed) + */ +int mpv_unobserve_property(mpv_handle *mpv, uint64_t registered_reply_userdata); + +typedef enum mpv_event_id { + /** + * Nothing happened. Happens on timeouts or sporadic wakeups. + */ + MPV_EVENT_NONE = 0, + /** + * Happens when the player quits. The player enters a state where it tries + * to disconnect all clients. Most requests to the player will fail, and + * the client should react to this and quit with mpv_destroy() as soon as + * possible. + */ + MPV_EVENT_SHUTDOWN = 1, + /** + * See mpv_request_log_messages(). + */ + MPV_EVENT_LOG_MESSAGE = 2, + /** + * Reply to a mpv_get_property_async() request. + * See also mpv_event and mpv_event_property. + */ + MPV_EVENT_GET_PROPERTY_REPLY = 3, + /** + * Reply to a mpv_set_property_async() request. + * (Unlike MPV_EVENT_GET_PROPERTY, mpv_event_property is not used.) + */ + MPV_EVENT_SET_PROPERTY_REPLY = 4, + /** + * Reply to a mpv_command_async() or mpv_command_node_async() request. + * See also mpv_event and mpv_event_command. + */ + MPV_EVENT_COMMAND_REPLY = 5, + /** + * Notification before playback start of a file (before the file is loaded). + */ + MPV_EVENT_START_FILE = 6, + /** + * Notification after playback end (after the file was unloaded). + * See also mpv_event and mpv_event_end_file. + */ + MPV_EVENT_END_FILE = 7, + /** + * Notification when the file has been loaded (headers were read etc.), and + * decoding starts. + */ + MPV_EVENT_FILE_LOADED = 8, +#if MPV_ENABLE_DEPRECATED + /** + * The list of video/audio/subtitle tracks was changed. (E.g. a new track + * was found. This doesn't necessarily indicate a track switch; for this, + * MPV_EVENT_TRACK_SWITCHED is used.) + * + * @deprecated This is equivalent to using mpv_observe_property() on the + * "track-list" property. The event is redundant, and might + * be removed in the far future. + */ + MPV_EVENT_TRACKS_CHANGED = 9, + /** + * A video/audio/subtitle track was switched on or off. + * + * @deprecated This is equivalent to using mpv_observe_property() on the + * "vid", "aid", and "sid" properties. The event is redundant, + * and might be removed in the far future. + */ + MPV_EVENT_TRACK_SWITCHED = 10, +#endif + /** + * Idle mode was entered. In this mode, no file is played, and the playback + * core waits for new commands. (The command line player normally quits + * instead of entering idle mode, unless --idle was specified. If mpv + * was started with mpv_create(), idle mode is enabled by default.) + */ + MPV_EVENT_IDLE = 11, +#if MPV_ENABLE_DEPRECATED + /** + * Playback was paused. This indicates the user pause state. + * + * The user pause state is the state the user requested (changed with the + * "pause" property). There is an internal pause state too, which is entered + * if e.g. the network is too slow (the "core-idle" property generally + * indicates whether the core is playing or waiting). + * + * This event is sent whenever any pause states change, not only the user + * state. You might get multiple events in a row while these states change + * independently. But the event ID sent always indicates the user pause + * state. + * + * If you don't want to deal with this, use mpv_observe_property() on the + * "pause" property and ignore MPV_EVENT_PAUSE/UNPAUSE. Likewise, the + * "core-idle" property tells you whether video is actually playing or not. + * + * @deprecated The event is redundant with mpv_observe_property() as + * mentioned above, and might be removed in the far future. + */ + MPV_EVENT_PAUSE = 12, + /** + * Playback was unpaused. See MPV_EVENT_PAUSE for not so obvious details. + * + * @deprecated The event is redundant with mpv_observe_property() as + * explained in the MPV_EVENT_PAUSE comments, and might be + * removed in the far future. + */ + MPV_EVENT_UNPAUSE = 13, + /** + * Sent every time after a video frame is displayed. Note that currently, + * this will be sent in lower frequency if there is no video, or playback + * is paused - but that will be removed in the future, and it will be + * restricted to video frames only. + * + * @deprecated Use mpv_observe_property() with relevant properties instead + * (such as "playback-time"). + */ + MPV_EVENT_TICK = 14, + /** + * @deprecated This was used internally with the internal "script_dispatch" + * command to dispatch keyboard and mouse input for the OSC. + * It was never useful in general and has been completely + * replaced with "script-binding". + * This event never happens anymore, and is included in this + * header only for compatibility. + */ + MPV_EVENT_SCRIPT_INPUT_DISPATCH = 15, +#endif + /** + * Triggered by the script-message input command. The command uses the + * first argument of the command as client name (see mpv_client_name()) to + * dispatch the message, and passes along all arguments starting from the + * second argument as strings. + * See also mpv_event and mpv_event_client_message. + */ + MPV_EVENT_CLIENT_MESSAGE = 16, + /** + * Happens after video changed in some way. This can happen on resolution + * changes, pixel format changes, or video filter changes. The event is + * sent after the video filters and the VO are reconfigured. Applications + * embedding a mpv window should listen to this event in order to resize + * the window if needed. + * Note that this event can happen sporadically, and you should check + * yourself whether the video parameters really changed before doing + * something expensive. + */ + MPV_EVENT_VIDEO_RECONFIG = 17, + /** + * Similar to MPV_EVENT_VIDEO_RECONFIG. This is relatively uninteresting, + * because there is no such thing as audio output embedding. + */ + MPV_EVENT_AUDIO_RECONFIG = 18, +#if MPV_ENABLE_DEPRECATED + /** + * Happens when metadata (like file tags) is possibly updated. (It's left + * unspecified whether this happens on file start or only when it changes + * within a file.) + * + * @deprecated This is equivalent to using mpv_observe_property() on the + * "metadata" property. The event is redundant, and might + * be removed in the far future. + */ + MPV_EVENT_METADATA_UPDATE = 19, +#endif + /** + * Happens when a seek was initiated. Playback stops. Usually it will + * resume with MPV_EVENT_PLAYBACK_RESTART as soon as the seek is finished. + */ + MPV_EVENT_SEEK = 20, + /** + * There was a discontinuity of some sort (like a seek), and playback + * was reinitialized. Usually happens after seeking, or ordered chapter + * segment switches. The main purpose is allowing the client to detect + * when a seek request is finished. + */ + MPV_EVENT_PLAYBACK_RESTART = 21, + /** + * Event sent due to mpv_observe_property(). + * See also mpv_event and mpv_event_property. + */ + MPV_EVENT_PROPERTY_CHANGE = 22, +#if MPV_ENABLE_DEPRECATED + /** + * Happens when the current chapter changes. + * + * @deprecated This is equivalent to using mpv_observe_property() on the + * "chapter" property. The event is redundant, and might + * be removed in the far future. + */ + MPV_EVENT_CHAPTER_CHANGE = 23, +#endif + /** + * Happens if the internal per-mpv_handle ringbuffer overflows, and at + * least 1 event had to be dropped. This can happen if the client doesn't + * read the event queue quickly enough with mpv_wait_event(), or if the + * client makes a very large number of asynchronous calls at once. + * + * Event delivery will continue normally once this event was returned + * (this forces the client to empty the queue completely). + */ + MPV_EVENT_QUEUE_OVERFLOW = 24, + /** + * Triggered if a hook handler was registered with mpv_hook_add(), and the + * hook is invoked. If you receive this, you must handle it, and continue + * the hook with mpv_hook_continue(). + * See also mpv_event and mpv_event_hook. + */ + MPV_EVENT_HOOK = 25, + // Internal note: adjust INTERNAL_EVENT_BASE when adding new events. +} mpv_event_id; + +/** + * Return a string describing the event. For unknown events, NULL is returned. + * + * Note that all events actually returned by the API will also yield a non-NULL + * string with this function. + * + * @param event event ID, see see enum mpv_event_id + * @return A static string giving a short symbolic name of the event. It + * consists of lower-case alphanumeric characters and can include "-" + * characters. This string is suitable for use in e.g. scripting + * interfaces. + * The string is completely static, i.e. doesn't need to be deallocated, + * and is valid forever. + */ +const char *mpv_event_name(mpv_event_id event); + +typedef struct mpv_event_property { + /** + * Name of the property. + */ + const char *name; + /** + * Format of the data field in the same struct. See enum mpv_format. + * This is always the same format as the requested format, except when + * the property could not be retrieved (unavailable, or an error happened), + * in which case the format is MPV_FORMAT_NONE. + */ + mpv_format format; + /** + * Received property value. Depends on the format. This is like the + * pointer argument passed to mpv_get_property(). + * + * For example, for MPV_FORMAT_STRING you get the string with: + * + * char *value = *(char **)(event_property->data); + * + * Note that this is set to NULL if retrieving the property failed (the + * format will be MPV_FORMAT_NONE). + */ + void *data; +} mpv_event_property; + +/** + * Numeric log levels. The lower the number, the more important the message is. + * MPV_LOG_LEVEL_NONE is never used when receiving messages. The string in + * the comment after the value is the name of the log level as used for the + * mpv_request_log_messages() function. + * Unused numeric values are unused, but reserved for future use. + */ +typedef enum mpv_log_level { + MPV_LOG_LEVEL_NONE = 0, /// "no" - disable absolutely all messages + MPV_LOG_LEVEL_FATAL = 10, /// "fatal" - critical/aborting errors + MPV_LOG_LEVEL_ERROR = 20, /// "error" - simple errors + MPV_LOG_LEVEL_WARN = 30, /// "warn" - possible problems + MPV_LOG_LEVEL_INFO = 40, /// "info" - informational message + MPV_LOG_LEVEL_V = 50, /// "v" - noisy informational message + MPV_LOG_LEVEL_DEBUG = 60, /// "debug" - very noisy technical information + MPV_LOG_LEVEL_TRACE = 70, /// "trace" - extremely noisy +} mpv_log_level; + +typedef struct mpv_event_log_message { + /** + * The module prefix, identifies the sender of the message. As a special + * case, if the message buffer overflows, this will be set to the string + * "overflow" (which doesn't appear as prefix otherwise), and the text + * field will contain an informative message. + */ + const char *prefix; + /** + * The log level as string. See mpv_request_log_messages() for possible + * values. The level "no" is never used here. + */ + const char *level; + /** + * The log message. It consists of 1 line of text, and is terminated with + * a newline character. (Before API version 1.6, it could contain multiple + * or partial lines.) + */ + const char *text; + /** + * The same contents as the level field, but as a numeric ID. + * Since API version 1.6. + */ + mpv_log_level log_level; +} mpv_event_log_message; + +/// Since API version 1.9. +typedef enum mpv_end_file_reason { + /** + * The end of file was reached. Sometimes this may also happen on + * incomplete or corrupted files, or if the network connection was + * interrupted when playing a remote file. It also happens if the + * playback range was restricted with --end or --frames or similar. + */ + MPV_END_FILE_REASON_EOF = 0, + /** + * Playback was stopped by an external action (e.g. playlist controls). + */ + MPV_END_FILE_REASON_STOP = 2, + /** + * Playback was stopped by the quit command or player shutdown. + */ + MPV_END_FILE_REASON_QUIT = 3, + /** + * Some kind of error happened that lead to playback abort. Does not + * necessarily happen on incomplete or broken files (in these cases, both + * MPV_END_FILE_REASON_ERROR or MPV_END_FILE_REASON_EOF are possible). + * + * mpv_event_end_file.error will be set. + */ + MPV_END_FILE_REASON_ERROR = 4, + /** + * The file was a playlist or similar. When the playlist is read, its + * entries will be appended to the playlist after the entry of the current + * file, the entry of the current file is removed, and a MPV_EVENT_END_FILE + * event is sent with reason set to MPV_END_FILE_REASON_REDIRECT. Then + * playback continues with the playlist contents. + * Since API version 1.18. + */ + MPV_END_FILE_REASON_REDIRECT = 5, +} mpv_end_file_reason; + +typedef struct mpv_event_end_file { + /** + * Corresponds to the values in enum mpv_end_file_reason (the "int" type + * will be replaced with mpv_end_file_reason on the next ABI bump). + * + * Unknown values should be treated as unknown. + */ + int reason; + /** + * If reason==MPV_END_FILE_REASON_ERROR, this contains a mpv error code + * (one of MPV_ERROR_...) giving an approximate reason why playback + * failed. In other cases, this field is 0 (no error). + * Since API version 1.9. + */ + int error; +} mpv_event_end_file; + +#if MPV_ENABLE_DEPRECATED +/** @deprecated see MPV_EVENT_SCRIPT_INPUT_DISPATCH for remarks + */ +typedef struct mpv_event_script_input_dispatch { + int arg0; + const char *type; +} mpv_event_script_input_dispatch; +#endif + +typedef struct mpv_event_client_message { + /** + * Arbitrary arguments chosen by the sender of the message. If num_args > 0, + * you can access args[0] through args[num_args - 1] (inclusive). What + * these arguments mean is up to the sender and receiver. + * None of the valid items are NULL. + */ + int num_args; + const char **args; +} mpv_event_client_message; + +typedef struct mpv_event_hook { + /** + * The hook name as passed to mpv_hook_add(). + */ + const char *name; + /** + * Internal ID that must be passed to mpv_hook_continue(). + */ + uint64_t id; +} mpv_event_hook; + +// Since API version 1.102. +typedef struct mpv_event_command { + /** + * Result data of the command. Note that success/failure is signaled + * separately via mpv_event.error. This field is only for result data + * in case of success. Most commands leave it at MPV_FORMAT_NONE. Set + * to MPV_FORMAT_NONE on failure. + */ + mpv_node result; +} mpv_event_command; + +typedef struct mpv_event { + /** + * One of mpv_event. Keep in mind that later ABI compatible releases might + * add new event types. These should be ignored by the API user. + */ + mpv_event_id event_id; + /** + * This is mainly used for events that are replies to (asynchronous) + * requests. It contains a status code, which is >= 0 on success, or < 0 + * on error (a mpv_error value). Usually, this will be set if an + * asynchronous request fails. + * Used for: + * MPV_EVENT_GET_PROPERTY_REPLY + * MPV_EVENT_SET_PROPERTY_REPLY + * MPV_EVENT_COMMAND_REPLY + */ + int error; + /** + * If the event is in reply to a request (made with this API and this + * API handle), this is set to the reply_userdata parameter of the request + * call. Otherwise, this field is 0. + * Used for: + * MPV_EVENT_GET_PROPERTY_REPLY + * MPV_EVENT_SET_PROPERTY_REPLY + * MPV_EVENT_COMMAND_REPLY + * MPV_EVENT_PROPERTY_CHANGE + * MPV_EVENT_HOOK + */ + uint64_t reply_userdata; + /** + * The meaning and contents of the data member depend on the event_id: + * MPV_EVENT_GET_PROPERTY_REPLY: mpv_event_property* + * MPV_EVENT_PROPERTY_CHANGE: mpv_event_property* + * MPV_EVENT_LOG_MESSAGE: mpv_event_log_message* + * MPV_EVENT_CLIENT_MESSAGE: mpv_event_client_message* + * MPV_EVENT_END_FILE: mpv_event_end_file* + * MPV_EVENT_HOOK: mpv_event_hook* + * MPV_EVENT_COMMAND_REPLY* mpv_event_command* + * other: NULL + * + * Note: future enhancements might add new event structs for existing or new + * event types. + */ + void *data; +} mpv_event; + +/** + * Enable or disable the given event. + * + * Some events are enabled by default. Some events can't be disabled. + * + * (Informational note: currently, all events are enabled by default, except + * MPV_EVENT_TICK.) + * + * Safe to be called from mpv render API threads. + * + * @param event See enum mpv_event_id. + * @param enable 1 to enable receiving this event, 0 to disable it. + * @return error code + */ +int mpv_request_event(mpv_handle *ctx, mpv_event_id event, int enable); + +/** + * Enable or disable receiving of log messages. These are the messages the + * command line player prints to the terminal. This call sets the minimum + * required log level for a message to be received with MPV_EVENT_LOG_MESSAGE. + * + * @param min_level Minimal log level as string. Valid log levels: + * no fatal error warn info v debug trace + * The value "no" disables all messages. This is the default. + * An exception is the value "terminal-default", which uses the + * log level as set by the "--msg-level" option. This works + * even if the terminal is disabled. (Since API version 1.19.) + * Also see mpv_log_level. + * @return error code + */ +int mpv_request_log_messages(mpv_handle *ctx, const char *min_level); + +/** + * Wait for the next event, or until the timeout expires, or if another thread + * makes a call to mpv_wakeup(). Passing 0 as timeout will never wait, and + * is suitable for polling. + * + * The internal event queue has a limited size (per client handle). If you + * don't empty the event queue quickly enough with mpv_wait_event(), it will + * overflow and silently discard further events. If this happens, making + * asynchronous requests will fail as well (with MPV_ERROR_EVENT_QUEUE_FULL). + * + * Only one thread is allowed to call this on the same mpv_handle at a time. + * The API won't complain if more than one thread calls this, but it will cause + * race conditions in the client when accessing the shared mpv_event struct. + * Note that most other API functions are not restricted by this, and no API + * function internally calls mpv_wait_event(). Additionally, concurrent calls + * to different mpv_handles are always safe. + * + * As long as the timeout is 0, this is safe to be called from mpv render API + * threads. + * + * @param timeout Timeout in seconds, after which the function returns even if + * no event was received. A MPV_EVENT_NONE is returned on + * timeout. A value of 0 will disable waiting. Negative values + * will wait with an infinite timeout. + * @return A struct containing the event ID and other data. The pointer (and + * fields in the struct) stay valid until the next mpv_wait_event() + * call, or until the mpv_handle is destroyed. You must not write to + * the struct, and all memory referenced by it will be automatically + * released by the API on the next mpv_wait_event() call, or when the + * context is destroyed. The return value is never NULL. + */ +mpv_event *mpv_wait_event(mpv_handle *ctx, double timeout); + +/** + * Interrupt the current mpv_wait_event() call. This will wake up the thread + * currently waiting in mpv_wait_event(). If no thread is waiting, the next + * mpv_wait_event() call will return immediately (this is to avoid lost + * wakeups). + * + * mpv_wait_event() will receive a MPV_EVENT_NONE if it's woken up due to + * this call. But note that this dummy event might be skipped if there are + * already other events queued. All what counts is that the waiting thread + * is woken up at all. + * + * Safe to be called from mpv render API threads. + */ +void mpv_wakeup(mpv_handle *ctx); + +/** + * Set a custom function that should be called when there are new events. Use + * this if blocking in mpv_wait_event() to wait for new events is not feasible. + * + * Keep in mind that the callback will be called from foreign threads. You + * must not make any assumptions of the environment, and you must return as + * soon as possible (i.e. no long blocking waits). Exiting the callback through + * any other means than a normal return is forbidden (no throwing exceptions, + * no longjmp() calls). You must not change any local thread state (such as + * the C floating point environment). + * + * You are not allowed to call any client API functions inside of the callback. + * In particular, you should not do any processing in the callback, but wake up + * another thread that does all the work. The callback is meant strictly for + * notification only, and is called from arbitrary core parts of the player, + * that make no considerations for reentrant API use or allowing the callee to + * spend a lot of time doing other things. Keep in mind that it's also possible + * that the callback is called from a thread while a mpv API function is called + * (i.e. it can be reentrant). + * + * In general, the client API expects you to call mpv_wait_event() to receive + * notifications, and the wakeup callback is merely a helper utility to make + * this easier in certain situations. Note that it's possible that there's + * only one wakeup callback invocation for multiple events. You should call + * mpv_wait_event() with no timeout until MPV_EVENT_NONE is reached, at which + * point the event queue is empty. + * + * If you actually want to do processing in a callback, spawn a thread that + * does nothing but call mpv_wait_event() in a loop and dispatches the result + * to a callback. + * + * Only one wakeup callback can be set. + * + * @param cb function that should be called if a wakeup is required + * @param d arbitrary userdata passed to cb + */ +void mpv_set_wakeup_callback(mpv_handle *ctx, void (*cb)(void *d), void *d); + +/** + * Block until all asynchronous requests are done. This affects functions like + * mpv_command_async(), which return immediately and return their result as + * events. + * + * This is a helper, and somewhat equivalent to calling mpv_wait_event() in a + * loop until all known asynchronous requests have sent their reply as event, + * except that the event queue is not emptied. + * + * In case you called mpv_suspend() before, this will also forcibly reset the + * suspend counter of the given handle. + */ +void mpv_wait_async_requests(mpv_handle *ctx); + +/** + * A hook is like a synchronous event that blocks the player. You register + * a hook handler with this function. You will get an event, which you need + * to handle, and once things are ready, you can let the player continue with + * mpv_hook_continue(). + * + * Currently, hooks can't be removed explicitly. But they will be implicitly + * removed if the mpv_handle it was registered with is destroyed. This also + * continues the hook if it was being handled by the destroyed mpv_handle (but + * this should be avoided, as it might mess up order of hook execution). + * + * Hook handlers are ordered globally by priority and order of registration. + * Handlers for the same hook with same priority are invoked in order of + * registration (the handler registered first is run first). Handlers with + * lower priority are run first (which seems backward). + * + * See the "Hooks" section in the manpage to see which hooks are currently + * defined. + * + * Some hooks might be reentrant (so you get multiple MPV_EVENT_HOOK for the + * same hook). If this can happen for a specific hook type, it will be + * explicitly documented in the manpage. + * + * Only the mpv_handle on which this was called will receive the hook events, + * or can "continue" them. + * + * @param reply_userdata This will be used for the mpv_event.reply_userdata + * field for the received MPV_EVENT_HOOK events. + * If you have no use for this, pass 0. + * @param name The hook name. This should be one of the documented names. But + * if the name is unknown, the hook event will simply be never + * raised. + * @param priority See remarks above. Use 0 as a neutral default. + * @return error code (usually fails only on OOM) + */ +int mpv_hook_add(mpv_handle *ctx, uint64_t reply_userdata, + const char *name, int priority); + +/** + * Respond to a MPV_EVENT_HOOK event. You must call this after you have handled + * the event. There is no way to "cancel" or "stop" the hook. + * + * Calling this will will typically unblock the player for whatever the hook + * is responsible for (e.g. for the "on_load" hook it lets it continue + * playback). + * + * It is explicitly undefined behavior to call this more than once for each + * MPV_EVENT_HOOK, to pass an incorrect ID, or to call this on a mpv_handle + * different from the one that registered the handler and received the event. + * + * @param id This must be the value of the mpv_event_hook.id field for the + * corresponding MPV_EVENT_HOOK. + * @return error code + */ +int mpv_hook_continue(mpv_handle *ctx, uint64_t id); + +#if MPV_ENABLE_DEPRECATED + +/** + * Return a UNIX file descriptor referring to the read end of a pipe. This + * pipe can be used to wake up a poll() based processing loop. The purpose of + * this function is very similar to mpv_set_wakeup_callback(), and provides + * a primitive mechanism to handle coordinating a foreign event loop and the + * libmpv event loop. The pipe is non-blocking. It's closed when the mpv_handle + * is destroyed. This function always returns the same value (on success). + * + * This is in fact implemented using the same underlying code as for + * mpv_set_wakeup_callback() (though they don't conflict), and it is as if each + * callback invocation writes a single 0 byte to the pipe. When the pipe + * becomes readable, the code calling poll() (or select()) on the pipe should + * read all contents of the pipe and then call mpv_wait_event(c, 0) until + * no new events are returned. The pipe contents do not matter and can just + * be discarded. There is not necessarily one byte per readable event in the + * pipe. For example, the pipes are non-blocking, and mpv won't block if the + * pipe is full. Pipes are normally limited to 4096 bytes, so if there are + * more than 4096 events, the number of readable bytes can not equal the number + * of events queued. Also, it's possible that mpv does not write to the pipe + * once it's guaranteed that the client was already signaled. See the example + * below how to do it correctly. + * + * Example: + * + * int pipefd = mpv_get_wakeup_pipe(mpv); + * if (pipefd < 0) + * error(); + * while (1) { + * struct pollfd pfds[1] = { + * { .fd = pipefd, .events = POLLIN }, + * }; + * // Wait until there are possibly new mpv events. + * poll(pfds, 1, -1); + * if (pfds[0].revents & POLLIN) { + * // Empty the pipe. Doing this before calling mpv_wait_event() + * // ensures that no wakeups are missed. It's not so important to + * // make sure the pipe is really empty (it will just cause some + * // additional wakeups in unlikely corner cases). + * char unused[256]; + * read(pipefd, unused, sizeof(unused)); + * while (1) { + * mpv_event *ev = mpv_wait_event(mpv, 0); + * // If MPV_EVENT_NONE is received, the event queue is empty. + * if (ev->event_id == MPV_EVENT_NONE) + * break; + * // Process the event. + * ... + * } + * } + * } + * + * @deprecated this function will be removed in the future. If you need this + * functionality, use mpv_set_wakeup_callback(), create a pipe + * manually, and call write() on your pipe in the callback. + * + * @return A UNIX FD of the read end of the wakeup pipe, or -1 on error. + * On MS Windows/MinGW, this will always return -1. + */ +int mpv_get_wakeup_pipe(mpv_handle *ctx); + +/** + * @deprecated use render.h + */ +typedef enum mpv_sub_api { + /** + * For using mpv's OpenGL renderer on an external OpenGL context. + * mpv_get_sub_api(MPV_SUB_API_OPENGL_CB) returns mpv_opengl_cb_context*. + * This context can be used with mpv_opengl_cb_* functions. + * Will return NULL if unavailable (if OpenGL support was not compiled in). + * See opengl_cb.h for details. + * + * @deprecated use render.h + */ + MPV_SUB_API_OPENGL_CB = 1 +} mpv_sub_api; + +/** + * This is used for additional APIs that are not strictly part of the core API. + * See the individual mpv_sub_api member values. + * + * @deprecated use render.h + */ +void *mpv_get_sub_api(mpv_handle *ctx, mpv_sub_api sub_api); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Vendor/mpv/iOS/include/qthelper.hpp b/Vendor/mpv/iOS/include/qthelper.hpp new file mode 100644 index 00000000..3af86e36 --- /dev/null +++ b/Vendor/mpv/iOS/include/qthelper.hpp @@ -0,0 +1,386 @@ +/* Copyright (C) 2017 the mpv developers + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MPV_CLIENT_API_QTHELPER_H_ +#define MPV_CLIENT_API_QTHELPER_H_ + +#include + +#if !MPV_ENABLE_DEPRECATED +#error "This helper is deprecated. Copy it into your project instead." +#else + +/** + * Note: these helpers are provided for convenience for C++/Qt applications. + * This is based on the public API in client.h, and it does not encode any + * knowledge that is not known or guaranteed outside of the C client API. You + * can even copy and modify this code as you like, or implement similar things + * for other languages. + */ + +#include + +#include +#include +#include +#include +#include +#include + +namespace mpv { +namespace qt { + +// Wrapper around mpv_handle. Does refcounting under the hood. +class Handle +{ + struct container { + container(mpv_handle *h) : mpv(h) {} + ~container() { mpv_terminate_destroy(mpv); } + mpv_handle *mpv; + }; + QSharedPointer sptr; +public: + // Construct a new Handle from a raw mpv_handle with refcount 1. If the + // last Handle goes out of scope, the mpv_handle will be destroyed with + // mpv_terminate_destroy(). + // Never destroy the mpv_handle manually when using this wrapper. You + // will create dangling pointers. Just let the wrapper take care of + // destroying the mpv_handle. + // Never create multiple wrappers from the same raw mpv_handle; copy the + // wrapper instead (that's what it's for). + static Handle FromRawHandle(mpv_handle *handle) { + Handle h; + h.sptr = QSharedPointer(new container(handle)); + return h; + } + + // Return the raw handle; for use with the libmpv C API. + operator mpv_handle*() const { return sptr ? (*sptr).mpv : 0; } +}; + +static inline QVariant node_to_variant(const mpv_node *node) +{ + switch (node->format) { + case MPV_FORMAT_STRING: + return QVariant(QString::fromUtf8(node->u.string)); + case MPV_FORMAT_FLAG: + return QVariant(static_cast(node->u.flag)); + case MPV_FORMAT_INT64: + return QVariant(static_cast(node->u.int64)); + case MPV_FORMAT_DOUBLE: + return QVariant(node->u.double_); + case MPV_FORMAT_NODE_ARRAY: { + mpv_node_list *list = node->u.list; + QVariantList qlist; + for (int n = 0; n < list->num; n++) + qlist.append(node_to_variant(&list->values[n])); + return QVariant(qlist); + } + case MPV_FORMAT_NODE_MAP: { + mpv_node_list *list = node->u.list; + QVariantMap qmap; + for (int n = 0; n < list->num; n++) { + qmap.insert(QString::fromUtf8(list->keys[n]), + node_to_variant(&list->values[n])); + } + return QVariant(qmap); + } + default: // MPV_FORMAT_NONE, unknown values (e.g. future extensions) + return QVariant(); + } +} + +struct node_builder { + node_builder(const QVariant& v) { + set(&node_, v); + } + ~node_builder() { + free_node(&node_); + } + mpv_node *node() { return &node_; } +private: + Q_DISABLE_COPY(node_builder) + mpv_node node_; + mpv_node_list *create_list(mpv_node *dst, bool is_map, int num) { + dst->format = is_map ? MPV_FORMAT_NODE_MAP : MPV_FORMAT_NODE_ARRAY; + mpv_node_list *list = new mpv_node_list(); + dst->u.list = list; + if (!list) + goto err; + list->values = new mpv_node[num](); + if (!list->values) + goto err; + if (is_map) { + list->keys = new char*[num](); + if (!list->keys) + goto err; + } + return list; + err: + free_node(dst); + return NULL; + } + char *dup_qstring(const QString &s) { + QByteArray b = s.toUtf8(); + char *r = new char[b.size() + 1]; + if (r) + std::memcpy(r, b.data(), b.size() + 1); + return r; + } + bool test_type(const QVariant &v, QMetaType::Type t) { + // The Qt docs say: "Although this function is declared as returning + // "QVariant::Type(obsolete), the return value should be interpreted + // as QMetaType::Type." + // So a cast really seems to be needed to avoid warnings (urgh). + return static_cast(v.type()) == static_cast(t); + } + void set(mpv_node *dst, const QVariant &src) { + if (test_type(src, QMetaType::QString)) { + dst->format = MPV_FORMAT_STRING; + dst->u.string = dup_qstring(src.toString()); + if (!dst->u.string) + goto fail; + } else if (test_type(src, QMetaType::Bool)) { + dst->format = MPV_FORMAT_FLAG; + dst->u.flag = src.toBool() ? 1 : 0; + } else if (test_type(src, QMetaType::Int) || + test_type(src, QMetaType::LongLong) || + test_type(src, QMetaType::UInt) || + test_type(src, QMetaType::ULongLong)) + { + dst->format = MPV_FORMAT_INT64; + dst->u.int64 = src.toLongLong(); + } else if (test_type(src, QMetaType::Double)) { + dst->format = MPV_FORMAT_DOUBLE; + dst->u.double_ = src.toDouble(); + } else if (src.canConvert()) { + QVariantList qlist = src.toList(); + mpv_node_list *list = create_list(dst, false, qlist.size()); + if (!list) + goto fail; + list->num = qlist.size(); + for (int n = 0; n < qlist.size(); n++) + set(&list->values[n], qlist[n]); + } else if (src.canConvert()) { + QVariantMap qmap = src.toMap(); + mpv_node_list *list = create_list(dst, true, qmap.size()); + if (!list) + goto fail; + list->num = qmap.size(); + for (int n = 0; n < qmap.size(); n++) { + list->keys[n] = dup_qstring(qmap.keys()[n]); + if (!list->keys[n]) { + free_node(dst); + goto fail; + } + set(&list->values[n], qmap.values()[n]); + } + } else { + goto fail; + } + return; + fail: + dst->format = MPV_FORMAT_NONE; + } + void free_node(mpv_node *dst) { + switch (dst->format) { + case MPV_FORMAT_STRING: + delete[] dst->u.string; + break; + case MPV_FORMAT_NODE_ARRAY: + case MPV_FORMAT_NODE_MAP: { + mpv_node_list *list = dst->u.list; + if (list) { + for (int n = 0; n < list->num; n++) { + if (list->keys) + delete[] list->keys[n]; + if (list->values) + free_node(&list->values[n]); + } + delete[] list->keys; + delete[] list->values; + } + delete list; + break; + } + default: ; + } + dst->format = MPV_FORMAT_NONE; + } +}; + +/** + * RAII wrapper that calls mpv_free_node_contents() on the pointer. + */ +struct node_autofree { + mpv_node *ptr; + node_autofree(mpv_node *a_ptr) : ptr(a_ptr) {} + ~node_autofree() { mpv_free_node_contents(ptr); } +}; + +#if MPV_ENABLE_DEPRECATED + +/** + * Return the given property as mpv_node converted to QVariant, or QVariant() + * on error. + * + * @deprecated use get_property() instead + * + * @param name the property name + */ +static inline QVariant get_property_variant(mpv_handle *ctx, const QString &name) +{ + mpv_node node; + if (mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node) < 0) + return QVariant(); + node_autofree f(&node); + return node_to_variant(&node); +} + +/** + * Set the given property as mpv_node converted from the QVariant argument. + + * @deprecated use set_property() instead + */ +static inline int set_property_variant(mpv_handle *ctx, const QString &name, + const QVariant &v) +{ + node_builder node(v); + return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node()); +} + +/** + * Set the given option as mpv_node converted from the QVariant argument. + * + * @deprecated use set_property() instead + */ +static inline int set_option_variant(mpv_handle *ctx, const QString &name, + const QVariant &v) +{ + node_builder node(v); + return mpv_set_option(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node()); +} + +/** + * mpv_command_node() equivalent. Returns QVariant() on error (and + * unfortunately, the same on success). + * + * @deprecated use command() instead + */ +static inline QVariant command_variant(mpv_handle *ctx, const QVariant &args) +{ + node_builder node(args); + mpv_node res; + if (mpv_command_node(ctx, node.node(), &res) < 0) + return QVariant(); + node_autofree f(&res); + return node_to_variant(&res); +} + +#endif + +/** + * This is used to return error codes wrapped in QVariant for functions which + * return QVariant. + * + * You can use get_error() or is_error() to extract the error status from a + * QVariant value. + */ +struct ErrorReturn +{ + /** + * enum mpv_error value (or a value outside of it if ABI was extended) + */ + int error; + + ErrorReturn() : error(0) {} + explicit ErrorReturn(int err) : error(err) {} +}; + +/** + * Return the mpv error code packed into a QVariant, or 0 (success) if it's not + * an error value. + * + * @return error code (<0) or success (>=0) + */ +static inline int get_error(const QVariant &v) +{ + if (!v.canConvert()) + return 0; + return v.value().error; +} + +/** + * Return whether the QVariant carries a mpv error code. + */ +static inline bool is_error(const QVariant &v) +{ + return get_error(v) < 0; +} + +/** + * Return the given property as mpv_node converted to QVariant, or QVariant() + * on error. + * + * @param name the property name + * @return the property value, or an ErrorReturn with the error code + */ +static inline QVariant get_property(mpv_handle *ctx, const QString &name) +{ + mpv_node node; + int err = mpv_get_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, &node); + if (err < 0) + return QVariant::fromValue(ErrorReturn(err)); + node_autofree f(&node); + return node_to_variant(&node); +} + +/** + * Set the given property as mpv_node converted from the QVariant argument. + * + * @return mpv error code (<0 on error, >= 0 on success) + */ +static inline int set_property(mpv_handle *ctx, const QString &name, + const QVariant &v) +{ + node_builder node(v); + return mpv_set_property(ctx, name.toUtf8().data(), MPV_FORMAT_NODE, node.node()); +} + +/** + * mpv_command_node() equivalent. + * + * @param args command arguments, with args[0] being the command name as string + * @return the property value, or an ErrorReturn with the error code + */ +static inline QVariant command(mpv_handle *ctx, const QVariant &args) +{ + node_builder node(args); + mpv_node res; + int err = mpv_command_node(ctx, node.node(), &res); + if (err < 0) + return QVariant::fromValue(ErrorReturn(err)); + node_autofree f(&res); + return node_to_variant(&res); +} + +} +} + +Q_DECLARE_METATYPE(mpv::qt::ErrorReturn) + +#endif /* else #if MPV_ENABLE_DEPRECATED */ + +#endif diff --git a/Vendor/mpv/iOS/include/render.h b/Vendor/mpv/iOS/include/render.h new file mode 100644 index 00000000..293de3c9 --- /dev/null +++ b/Vendor/mpv/iOS/include/render.h @@ -0,0 +1,626 @@ +/* Copyright (C) 2018 the mpv developers + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MPV_CLIENT_API_RENDER_H_ +#define MPV_CLIENT_API_RENDER_H_ + +#include "client.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Overview + * -------- + * + * This API can be used to make mpv render using supported graphic APIs (such + * as OpenGL). It can be used to handle video display. + * + * The renderer needs to be created with mpv_render_context_create() before + * you start playback (or otherwise cause a VO to be created). Then (with most + * backends) mpv_render_context_render() can be used to explicitly render the + * current video frame. Use mpv_render_context_set_update_callback() to get + * notified when there is a new frame to draw. + * + * Preferably rendering should be done in a separate thread. If you call + * normal libmpv API functions on the renderer thread, deadlocks can result + * (these are made non-fatal with timeouts, but user experience will obviously + * suffer). See "Threading" section below. + * + * You can output and embed video without this API by setting the mpv "wid" + * option to a native window handle (see "Embedding the video window" section + * in the client.h header). In general, using the render API is recommended, + * because window embedding can cause various issues, especially with GUI + * toolkits and certain platforms. + * + * Supported backends + * ------------------ + * + * OpenGL: via MPV_RENDER_API_TYPE_OPENGL, see render_gl.h header. + * + * Threading + * --------- + * + * You are recommended to do rendering on a separate thread than normal libmpv + * use. + * + * The mpv_render_* functions can be called from any thread, under the + * following conditions: + * - only one of the mpv_render_* functions can be called at the same time + * (unless they belong to different mpv cores created by mpv_create()) + * - never can be called from within the callbacks set with + * mpv_set_wakeup_callback() or mpv_render_context_set_update_callback() + * - if the OpenGL backend is used, for all functions the OpenGL context + * must be "current" in the calling thread, and it must be the same OpenGL + * context as the mpv_render_context was created with. Otherwise, undefined + * behavior will occur. + * - the thread does not call libmpv API functions other than the mpv_render_* + * functions, except APIs which are declared as safe (see below). Likewise, + * there must be no lock or wait dependency from the render thread to a + * thread using other libmpv functions. Basically, the situation that your + * render thread waits for a "not safe" libmpv API function to return must + * not happen. If you ignore this requirement, deadlocks can happen, which + * are made non-fatal with timeouts; then playback quality will be degraded, + * and the message + * mpv_render_context_render() not being called or stuck. + * is logged. If you set MPV_RENDER_PARAM_ADVANCED_CONTROL, you promise that + * this won't happen, and must absolutely guarantee it, or a real deadlock + * will freeze the mpv core thread forever. + * + * libmpv functions which are safe to call from a render thread are: + * - functions marked with "Safe to be called from mpv render API threads." + * - client.h functions which don't have an explicit or implicit mpv_handle + * parameter + * - mpv_render_* functions; but only for the same mpv_render_context pointer. + * If the pointer is different, mpv_render_context_free() is not safe. (The + * reason is that if MPV_RENDER_PARAM_ADVANCED_CONTROL is set, it may have + * to process still queued requests from the core, which it can do only for + * the current context, while requests for other contexts would deadlock. + * Also, it may have to wait and block for the core to terminate the video + * chain to make sure no resources are used after context destruction.) + * - if the mpv_handle parameter refers to a different mpv core than the one + * you're rendering for (very obscure, but allowed) + * + * Note about old libmpv version: + * + * Before API version 1.105 (basically in mpv 0.29.x), simply enabling + * MPV_RENDER_PARAM_ADVANCED_CONTROL could cause deadlock issues. This can + * be worked around by setting the "vd-lavc-dr" option to "no". + * In addition, you were required to call all mpv_render*() API functions + * from the same thread on which mpv_render_context_create() was originally + * run (for the same the mpv_render_context). Not honoring it led to UB + * (deadlocks, use of invalid pthread_t handles), even if you moved your GL + * context to a different thread correctly. + * These problems were addressed in API version 1.105 (mpv 0.30.0). + * + * Context and handle lifecycle + * ---------------------------- + * + * Video initialization will fail if the render context was not initialized yet + * (with mpv_render_context_create()), or it will revert to a VO that creates + * its own window. + * + * Currently, there can be only 1 mpv_render_context at a time per mpv core. + * + * Calling mpv_render_context_free() while a VO is using the render context is + * active will disable video. + * + * You must free the context with mpv_render_context_free() before the mpv core + * is destroyed. If this doesn't happen, undefined behavior will result. + */ + +/** + * Opaque context, returned by mpv_render_context_create(). + */ +typedef struct mpv_render_context mpv_render_context; + +/** + * Parameters for mpv_render_param (which is used in a few places such as + * mpv_render_context_create(). + * + * Also see mpv_render_param for conventions and how to use it. + */ +typedef enum mpv_render_param_type { + /** + * Not a valid value, but also used to terminate a params array. Its value + * is always guaranteed to be 0 (even if the ABI changes in the future). + */ + MPV_RENDER_PARAM_INVALID = 0, + /** + * The render API to use. Valid for mpv_render_context_create(). + * + * Type: char* + * + * Defined APIs: + * + * MPV_RENDER_API_TYPE_OPENGL: + * OpenGL desktop 2.1 or later (preferably core profile compatible to + * OpenGL 3.2), or OpenGLES 2.0 or later. + * Providing MPV_RENDER_PARAM_OPENGL_INIT_PARAMS is required. + * It is expected that an OpenGL context is valid and "current" when + * calling mpv_render_* functions (unless specified otherwise). It + * must be the same context for the same mpv_render_context. + */ + MPV_RENDER_PARAM_API_TYPE = 1, + /** + * Required parameters for initializing the OpenGL renderer. Valid for + * mpv_render_context_create(). + * Type: mpv_opengl_init_params* + */ + MPV_RENDER_PARAM_OPENGL_INIT_PARAMS = 2, + /** + * Describes a GL render target. Valid for mpv_render_context_render(). + * Type: mpv_opengl_fbo* + */ + MPV_RENDER_PARAM_OPENGL_FBO = 3, + /** + * Control flipped rendering. Valid for mpv_render_context_render(). + * Type: int* + * If the value is set to 0, render normally. Otherwise, render it flipped, + * which is needed e.g. when rendering to an OpenGL default framebuffer + * (which has a flipped coordinate system). + */ + MPV_RENDER_PARAM_FLIP_Y = 4, + /** + * Control surface depth. Valid for mpv_render_context_render(). + * Type: int* + * This implies the depth of the surface passed to the render function in + * bits per channel. If omitted or set to 0, the renderer will assume 8. + * Typically used to control dithering. + */ + MPV_RENDER_PARAM_DEPTH = 5, + /** + * ICC profile blob. Valid for mpv_render_context_set_parameter(). + * Type: mpv_byte_array* + * Set an ICC profile for use with the "icc-profile-auto" option. (If the + * option is not enabled, the ICC data will not be used.) + */ + MPV_RENDER_PARAM_ICC_PROFILE = 6, + /** + * Ambient light in lux. Valid for mpv_render_context_set_parameter(). + * Type: int* + * This can be used for automatic gamma correction. + */ + MPV_RENDER_PARAM_AMBIENT_LIGHT = 7, + /** + * X11 Display, sometimes used for hwdec. Valid for + * mpv_render_context_create(). The Display must stay valid for the lifetime + * of the mpv_render_context. + * Type: Display* + */ + MPV_RENDER_PARAM_X11_DISPLAY = 8, + /** + * Wayland display, sometimes used for hwdec. Valid for + * mpv_render_context_create(). The wl_display must stay valid for the + * lifetime of the mpv_render_context. + * Type: struct wl_display* + */ + MPV_RENDER_PARAM_WL_DISPLAY = 9, + /** + * Better control about rendering and enabling some advanced features. Valid + * for mpv_render_context_create(). + * + * This conflates multiple requirements the API user promises to abide if + * this option is enabled: + * + * - The API user's render thread, which is calling the mpv_render_*() + * functions, never waits for the core. Otherwise deadlocks can happen. + * See "Threading" section. + * - The callback set with mpv_render_context_set_update_callback() can now + * be called even if there is no new frame. The API user should call the + * mpv_render_context_update() function, and interpret the return value + * for whether a new frame should be rendered. + * - Correct functionality is impossible if the update callback is not set, + * or not set soon enough after mpv_render_context_create() (the core can + * block while waiting for you to call mpv_render_context_update(), and + * if the update callback is not correctly set, it will deadlock, or + * block for too long). + * + * In general, setting this option will enable the following features (and + * possibly more): + * + * - "Direct rendering", which means the player decodes directly to a + * texture, which saves a copy per video frame ("vd-lavc-dr" option + * needs to be enabled, and the rendering backend as well as the + * underlying GPU API/driver needs to have support for it). + * - Rendering screenshots with the GPU API if supported by the backend + * (instead of using a suboptimal software fallback via libswscale). + * + * Warning: do not just add this without reading the "Threading" section + * above, and then wondering that deadlocks happen. The + * requirements are tricky. But also note that even if advanced + * control is disabled, not adhering to the rules will lead to + * playback problems. Enabling advanced controls simply makes + * violating these rules fatal. + * + * Type: int*: 0 for disable (default), 1 for enable + */ + MPV_RENDER_PARAM_ADVANCED_CONTROL = 10, + /** + * Return information about the next frame to render. Valid for + * mpv_render_context_get_info(). + * + * Type: mpv_render_frame_info* + * + * It strictly returns information about the _next_ frame. The implication + * is that e.g. mpv_render_context_update()'s return value will have + * MPV_RENDER_UPDATE_FRAME set, and the user is supposed to call + * mpv_render_context_render(). If there is no next frame, then the + * return value will have is_valid set to 0. + */ + MPV_RENDER_PARAM_NEXT_FRAME_INFO = 11, + /** + * Enable or disable video timing. Valid for mpv_render_context_render(). + * + * Type: int*: 0 for disable, 1 for enable (default) + * + * When video is timed to audio, the player attempts to render video a bit + * ahead, and then do a blocking wait until the target display time is + * reached. This blocks mpv_render_context_render() for up to the amount + * specified with the "video-timing-offset" global option. You can set + * this parameter to 0 to disable this kind of waiting. If you do, it's + * recommended to use the target time value in mpv_render_frame_info to + * wait yourself, or to set the "video-timing-offset" to 0 instead. + * + * Disabling this without doing anything in addition will result in A/V sync + * being slightly off. + */ + MPV_RENDER_PARAM_BLOCK_FOR_TARGET_TIME = 12, + /** + * Use to skip rendering in mpv_render_context_render(). + * + * Type: int*: 0 for rendering (default), 1 for skipping + * + * If this is set, you don't need to pass a target surface to the render + * function (and if you do, it's completely ignored). This can still call + * into the lower level APIs (i.e. if you use OpenGL, the OpenGL context + * must be set). + * + * Be aware that the render API will consider this frame as having been + * rendered. All other normal rules also apply, for example about whether + * you have to call mpv_render_context_report_swap(). It also does timing + * in the same way. + */ + MPV_RENDER_PARAM_SKIP_RENDERING = 13, + /** + * Deprecated. Not supported. Use MPV_RENDER_PARAM_DRM_DISPLAY_V2 instead. + * Type : struct mpv_opengl_drm_params* + */ + MPV_RENDER_PARAM_DRM_DISPLAY = 14, + /** + * DRM draw surface size, contains draw surface dimensions. + * Valid for mpv_render_context_create(). + * Type : struct mpv_opengl_drm_draw_surface_size* + */ + MPV_RENDER_PARAM_DRM_DRAW_SURFACE_SIZE = 15, + /** + * DRM display, contains drm display handles. + * Valid for mpv_render_context_create(). + * Type : struct mpv_opengl_drm_params_v2* + */ + MPV_RENDER_PARAM_DRM_DISPLAY_V2 = 16, +} mpv_render_param_type; + +/** + * For backwards compatibility with the old naming of + * MPV_RENDER_PARAM_DRM_DRAW_SURFACE_SIZE + */ +#define MPV_RENDER_PARAM_DRM_OSD_SIZE MPV_RENDER_PARAM_DRM_DRAW_SURFACE_SIZE + +/** + * Used to pass arbitrary parameters to some mpv_render_* functions. The + * meaning of the data parameter is determined by the type, and each + * MPV_RENDER_PARAM_* documents what type the value must point to. + * + * Each value documents the required data type as the pointer you cast to + * void* and set on mpv_render_param.data. For example, if MPV_RENDER_PARAM_FOO + * documents the type as Something* , then the code should look like this: + * + * Something foo = {...}; + * mpv_render_param param; + * param.type = MPV_RENDER_PARAM_FOO; + * param.data = & foo; + * + * Normally, the data field points to exactly 1 object. If the type is char*, + * it points to a 0-terminated string. + * + * In all cases (unless documented otherwise) the pointers need to remain + * valid during the call only. Unless otherwise documented, the API functions + * will not write to the params array or any data pointed to it. + * + * As a convention, parameter arrays are always terminated by type==0. There + * is no specific order of the parameters required. The order of the 2 fields in + * this struct is guaranteed (even after ABI changes). + */ +typedef struct mpv_render_param { + enum mpv_render_param_type type; + void *data; +} mpv_render_param; + + +/** + * Predefined values for MPV_RENDER_PARAM_API_TYPE. + */ +#define MPV_RENDER_API_TYPE_OPENGL "opengl" + +/** + * Flags used in mpv_render_frame_info.flags. Each value represents a bit in it. + */ +typedef enum mpv_render_frame_info_flag { + /** + * Set if there is actually a next frame. If unset, there is no next frame + * yet, and other flags and fields that require a frame to be queued will + * be unset. + * + * This is set for _any_ kind of frame, even for redraw requests. + * + * Note that when this is unset, it simply means no new frame was + * decoded/queued yet, not necessarily that the end of the video was + * reached. A new frame can be queued after some time. + * + * If the return value of mpv_render_context_render() had the + * MPV_RENDER_UPDATE_FRAME flag set, this flag will usually be set as well, + * unless the frame is rendered, or discarded by other asynchronous events. + */ + MPV_RENDER_FRAME_INFO_PRESENT = 1 << 0, + /** + * If set, the frame is not an actual new video frame, but a redraw request. + * For example if the video is paused, and an option that affects video + * rendering was changed (or any other reason), an update request can be + * issued and this flag will be set. + * + * Typically, redraw frames will not be subject to video timing. + * + * Implies MPV_RENDER_FRAME_INFO_PRESENT. + */ + MPV_RENDER_FRAME_INFO_REDRAW = 1 << 1, + /** + * If set, this is supposed to reproduce the previous frame perfectly. This + * is usually used for certain "video-sync" options ("display-..." modes). + * Typically the renderer will blit the video from a FBO. Unset otherwise. + * + * Implies MPV_RENDER_FRAME_INFO_PRESENT. + */ + MPV_RENDER_FRAME_INFO_REPEAT = 1 << 2, + /** + * If set, the player timing code expects that the user thread blocks on + * vsync (by either delaying the render call, or by making a call to + * mpv_render_context_report_swap() at vsync time). + * + * Implies MPV_RENDER_FRAME_INFO_PRESENT. + */ + MPV_RENDER_FRAME_INFO_BLOCK_VSYNC = 1 << 3, +} mpv_render_frame_info_flag; + +/** + * Information about the next video frame that will be rendered. Can be + * retrieved with MPV_RENDER_PARAM_NEXT_FRAME_INFO. + */ +typedef struct mpv_render_frame_info { + /** + * A bitset of mpv_render_frame_info_flag values (i.e. multiple flags are + * combined with bitwise or). + */ + uint64_t flags; + /** + * Absolute time at which the frame is supposed to be displayed. This is in + * the same unit and base as the time returned by mpv_get_time_us(). For + * frames that are redrawn, or if vsync locked video timing is used (see + * "video-sync" option), then this can be 0. The "video-timing-offset" + * option determines how much "headroom" the render thread gets (but a high + * enough frame rate can reduce it anyway). mpv_render_context_render() will + * normally block until the time is elapsed, unless you pass it + * MPV_RENDER_PARAM_BLOCK_FOR_TARGET_TIME = 0. + */ + int64_t target_time; +} mpv_render_frame_info; + +/** + * Initialize the renderer state. Depending on the backend used, this will + * access the underlying GPU API and initialize its own objects. + * + * You must free the context with mpv_render_context_free(). Not doing so before + * the mpv core is destroyed may result in memory leaks or crashes. + * + * Currently, only at most 1 context can exists per mpv core (it represents the + * main video output). + * + * You should pass the following parameters: + * - MPV_RENDER_PARAM_API_TYPE to select the underlying backend/GPU API. + * - Backend-specific init parameter, like MPV_RENDER_PARAM_OPENGL_INIT_PARAMS. + * - Setting MPV_RENDER_PARAM_ADVANCED_CONTROL and following its rules is + * strongly recommended. + * - If you want to use hwdec, possibly hwdec interop resources. + * + * @param res set to the context (on success) or NULL (on failure). The value + * is never read and always overwritten. + * @param mpv handle used to get the core (the mpv_render_context won't depend + * on this specific handle, only the core referenced by it) + * @param params an array of parameters, terminated by type==0. It's left + * unspecified what happens with unknown parameters. At least + * MPV_RENDER_PARAM_API_TYPE is required, and most backends will + * require another backend-specific parameter. + * @return error code, including but not limited to: + * MPV_ERROR_UNSUPPORTED: the OpenGL version is not supported + * (or required extensions are missing) + * MPV_ERROR_NOT_IMPLEMENTED: an unknown API type was provided, or + * support for the requested API was not + * built in the used libmpv binary. + * MPV_ERROR_INVALID_PARAMETER: at least one of the provided parameters was + * not valid. + */ +int mpv_render_context_create(mpv_render_context **res, mpv_handle *mpv, + mpv_render_param *params); + +/** + * Attempt to change a single parameter. Not all backends and parameter types + * support all kinds of changes. + * + * @param ctx a valid render context + * @param param the parameter type and data that should be set + * @return error code. If a parameter could actually be changed, this returns + * success, otherwise an error code depending on the parameter type + * and situation. + */ +int mpv_render_context_set_parameter(mpv_render_context *ctx, + mpv_render_param param); + +/** + * Retrieve information from the render context. This is NOT a counterpart to + * mpv_render_context_set_parameter(), because you generally can't read + * parameters set with it, and this function is not meant for this purpose. + * Instead, this is for communicating information from the renderer back to the + * user. See mpv_render_param_type; entries which support this function + * explicitly mention it, and for other entries you can assume it will fail. + * + * You pass param with param.type set and param.data pointing to a variable + * of the required data type. The function will then overwrite that variable + * with the returned value (at least on success). + * + * @param ctx a valid render context + * @param param the parameter type and data that should be retrieved + * @return error code. If a parameter could actually be retrieved, this returns + * success, otherwise an error code depending on the parameter type + * and situation. MPV_ERROR_NOT_IMPLEMENTED is used for unknown + * param.type, or if retrieving it is not supported. + */ +int mpv_render_context_get_info(mpv_render_context *ctx, + mpv_render_param param); + +typedef void (*mpv_render_update_fn)(void *cb_ctx); + +/** + * Set the callback that notifies you when a new video frame is available, or + * if the video display configuration somehow changed and requires a redraw. + * Similar to mpv_set_wakeup_callback(), you must not call any mpv API from + * the callback, and all the other listed restrictions apply (such as not + * exiting the callback by throwing exceptions). + * + * This can be called from any thread, except from an update callback. In case + * of the OpenGL backend, no OpenGL state or API is accessed. + * + * Calling this will raise an update callback immediately. + * + * @param callback callback(callback_ctx) is called if the frame should be + * redrawn + * @param callback_ctx opaque argument to the callback + */ +void mpv_render_context_set_update_callback(mpv_render_context *ctx, + mpv_render_update_fn callback, + void *callback_ctx); + +/** + * The API user is supposed to call this when the update callback was invoked + * (like all mpv_render_* functions, this has to happen on the render thread, + * and _not_ from the update callback itself). + * + * This is optional if MPV_RENDER_PARAM_ADVANCED_CONTROL was not set (default). + * Otherwise, it's a hard requirement that this is called after each update + * callback. If multiple update callback happened, and the function could not + * be called sooner, it's OK to call it once after the last callback. + * + * If an update callback happens during or after this function, the function + * must be called again at the soonest possible time. + * + * If MPV_RENDER_PARAM_ADVANCED_CONTROL was set, this will do additional work + * such as allocating textures for the video decoder. + * + * @return a bitset of mpv_render_update_flag values (i.e. multiple flags are + * combined with bitwise or). Typically, this will tell the API user + * what should happen next. E.g. if the MPV_RENDER_UPDATE_FRAME flag is + * set, mpv_render_context_render() should be called. If flags unknown + * to the API user are set, or if the return value is 0, nothing needs + * to be done. + */ +uint64_t mpv_render_context_update(mpv_render_context *ctx); + +/** + * Flags returned by mpv_render_context_update(). Each value represents a bit + * in the function's return value. + */ +typedef enum mpv_render_update_flag { + /** + * A new video frame must be rendered. mpv_render_context_render() must be + * called. + */ + MPV_RENDER_UPDATE_FRAME = 1 << 0, +} mpv_render_context_flag; + +/** + * Render video. + * + * Typically renders the video to a target surface provided via mpv_render_param + * (the details depend on the backend in use). Options like "panscan" are + * applied to determine which part of the video should be visible and how the + * video should be scaled. You can change these options at runtime by using the + * mpv property API. + * + * The renderer will reconfigure itself every time the target surface + * configuration (such as size) is changed. + * + * This function implicitly pulls a video frame from the internal queue and + * renders it. If no new frame is available, the previous frame is redrawn. + * The update callback set with mpv_render_context_set_update_callback() + * notifies you when a new frame was added. The details potentially depend on + * the backends and the provided parameters. + * + * Generally, libmpv will invoke your update callback some time before the video + * frame should be shown, and then lets this function block until the supposed + * display time. This will limit your rendering to video FPS. You can prevent + * this by setting the "video-timing-offset" global option to 0. (This applies + * only to "audio" video sync mode.) + * + * You should pass the following parameters: + * - Backend-specific target object, such as MPV_RENDER_PARAM_OPENGL_FBO. + * - Possibly transformations, such as MPV_RENDER_PARAM_FLIP_Y. + * + * @param ctx a valid render context + * @param params an array of parameters, terminated by type==0. Which parameters + * are required depends on the backend. It's left unspecified what + * happens with unknown parameters. + * @return error code + */ +int mpv_render_context_render(mpv_render_context *ctx, mpv_render_param *params); + +/** + * Tell the renderer that a frame was flipped at the given time. This is + * optional, but can help the player to achieve better timing. + * + * Note that calling this at least once informs libmpv that you will use this + * function. If you use it inconsistently, expect bad video playback. + * + * If this is called while no video is initialized, it is ignored. + * + * @param ctx a valid render context + */ +void mpv_render_context_report_swap(mpv_render_context *ctx); + +/** + * Destroy the mpv renderer state. + * + * If video is still active (e.g. a file playing), video will be disabled + * forcefully. + * + * @param ctx a valid render context. After this function returns, this is not + * a valid pointer anymore. NULL is also allowed and does nothing. + */ +void mpv_render_context_free(mpv_render_context *ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Vendor/mpv/iOS/include/render_gl.h b/Vendor/mpv/iOS/include/render_gl.h new file mode 100644 index 00000000..cb141df5 --- /dev/null +++ b/Vendor/mpv/iOS/include/render_gl.h @@ -0,0 +1,216 @@ +/* Copyright (C) 2018 the mpv developers + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MPV_CLIENT_API_RENDER_GL_H_ +#define MPV_CLIENT_API_RENDER_GL_H_ + +#include "render.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * OpenGL backend + * -------------- + * + * This header contains definitions for using OpenGL with the render.h API. + * + * OpenGL interop + * -------------- + * + * The OpenGL backend has some special rules, because OpenGL itself uses + * implicit per-thread contexts, which causes additional API problems. + * + * This assumes the OpenGL context lives on a certain thread controlled by the + * API user. All mpv_render_* APIs have to be assumed to implicitly use the + * OpenGL context if you pass a mpv_render_context using the OpenGL backend, + * unless specified otherwise. + * + * The OpenGL context is indirectly accessed through the OpenGL function + * pointers returned by the get_proc_address callback in mpv_opengl_init_params. + * Generally, mpv will not load the system OpenGL library when using this API. + * + * OpenGL state + * ------------ + * + * OpenGL has a large amount of implicit state. All the mpv functions mentioned + * above expect that the OpenGL state is reasonably set to OpenGL standard + * defaults. Likewise, mpv will attempt to leave the OpenGL context with + * standard defaults. The following state is excluded from this: + * + * - the glViewport state + * - the glScissor state (but GL_SCISSOR_TEST is in its default value) + * - glBlendFuncSeparate() state (but GL_BLEND is in its default value) + * - glClearColor() state + * - mpv may overwrite the callback set with glDebugMessageCallback() + * - mpv always disables GL_DITHER at init + * + * Messing with the state could be avoided by creating shared OpenGL contexts, + * but this is avoided for the sake of compatibility and interoperability. + * + * On OpenGL 2.1, mpv will strictly call functions like glGenTextures() to + * create OpenGL objects. You will have to do the same. This ensures that + * objects created by mpv and the API users don't clash. Also, legacy state + * must be either in its defaults, or not interfere with core state. + * + * API use + * ------- + * + * The mpv_render_* API is used. That API supports multiple backends, and this + * section documents specifics for the OpenGL backend. + * + * Use mpv_render_context_create() with MPV_RENDER_PARAM_API_TYPE set to + * MPV_RENDER_API_TYPE_OPENGL, and MPV_RENDER_PARAM_OPENGL_INIT_PARAMS provided. + * + * Call mpv_render_context_render() with MPV_RENDER_PARAM_OPENGL_FBO to render + * the video frame to an FBO. + * + * Hardware decoding + * ----------------- + * + * Hardware decoding via this API is fully supported, but requires some + * additional setup. (At least if direct hardware decoding modes are wanted, + * instead of copying back surface data from GPU to CPU RAM.) + * + * There may be certain requirements on the OpenGL implementation: + * + * - Windows: ANGLE is required (although in theory GL/DX interop could be used) + * - Intel/Linux: EGL is required, and also the native display resource needs + * to be provided (e.g. MPV_RENDER_PARAM_X11_DISPLAY for X11 and + * MPV_RENDER_PARAM_WL_DISPLAY for Wayland) + * - nVidia/Linux: Both GLX and EGL should work (GLX is required if vdpau is + * used, e.g. due to old drivers.) + * - OSX: CGL is required (CGLGetCurrentContext() returning non-NULL) + * - iOS: EAGL is required (EAGLContext.currentContext returning non-nil) + * + * Once these things are setup, hardware decoding can be enabled/disabled at + * any time by setting the "hwdec" property. + */ + +/** + * For initializing the mpv OpenGL state via MPV_RENDER_PARAM_OPENGL_INIT_PARAMS. + */ +typedef struct mpv_opengl_init_params { + /** + * This retrieves OpenGL function pointers, and will use them in subsequent + * operation. + * Usually, you can simply call the GL context APIs from this callback (e.g. + * glXGetProcAddressARB or wglGetProcAddress), but some APIs do not always + * return pointers for all standard functions (even if present); in this + * case you have to compensate by looking up these functions yourself when + * libmpv wants to resolve them through this callback. + * libmpv will not normally attempt to resolve GL functions on its own, nor + * does it link to GL libraries directly. + */ + void *(*get_proc_address)(void *ctx, const char *name); + /** + * Value passed as ctx parameter to get_proc_address(). + */ + void *get_proc_address_ctx; + /** + * This should not be used. It is deprecated and will be removed or ignored + * when the opengl_cb API is removed. + */ + const char *extra_exts; +} mpv_opengl_init_params; + +/** + * For MPV_RENDER_PARAM_OPENGL_FBO. + */ +typedef struct mpv_opengl_fbo { + /** + * Framebuffer object name. This must be either a valid FBO generated by + * glGenFramebuffers() that is complete and color-renderable, or 0. If the + * value is 0, this refers to the OpenGL default framebuffer. + */ + int fbo; + /** + * Valid dimensions. This must refer to the size of the framebuffer. This + * must always be set. + */ + int w, h; + /** + * Underlying texture internal format (e.g. GL_RGBA8), or 0 if unknown. If + * this is the default framebuffer, this can be an equivalent. + */ + int internal_format; +} mpv_opengl_fbo; + +/** + * Deprecated. For MPV_RENDER_PARAM_DRM_DISPLAY. + */ +typedef struct mpv_opengl_drm_params { + int fd; + int crtc_id; + int connector_id; + struct _drmModeAtomicReq **atomic_request_ptr; + int render_fd; +} mpv_opengl_drm_params; + +/** + * For MPV_RENDER_PARAM_DRM_DRAW_SURFACE_SIZE. + */ +typedef struct mpv_opengl_drm_draw_surface_size { + /** + * size of the draw plane surface in pixels. + */ + int width, height; +} mpv_opengl_drm_draw_surface_size; + +/** + * For MPV_RENDER_PARAM_DRM_DISPLAY_V2. + */ +typedef struct mpv_opengl_drm_params_v2 { + /** + * DRM fd (int). Set to -1 if invalid. + */ + int fd; + + /** + * Currently used crtc id + */ + int crtc_id; + + /** + * Currently used connector id + */ + int connector_id; + + /** + * Pointer to a drmModeAtomicReq pointer that is being used for the renderloop. + * This pointer should hold a pointer to the atomic request pointer + * The atomic request pointer is usually changed at every renderloop. + */ + struct _drmModeAtomicReq **atomic_request_ptr; + + /** + * DRM render node. Used for VAAPI interop. + * Set to -1 if invalid. + */ + int render_fd; +} mpv_opengl_drm_params_v2; + + +/** + * For backwards compatibility with the old naming of mpv_opengl_drm_draw_surface_size + */ +#define mpv_opengl_drm_osd_size mpv_opengl_drm_draw_surface_size + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Vendor/mpv/iOS/include/stream_cb.h b/Vendor/mpv/iOS/include/stream_cb.h new file mode 100644 index 00000000..63593d72 --- /dev/null +++ b/Vendor/mpv/iOS/include/stream_cb.h @@ -0,0 +1,240 @@ +/* Copyright (C) 2017 the mpv developers + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MPV_CLIENT_API_STREAM_CB_H_ +#define MPV_CLIENT_API_STREAM_CB_H_ + +#include "client.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Warning: this API is not stable yet. + * + * Overview + * -------- + * + * This API can be used to make mpv read from a stream with a custom + * implementation. This interface is inspired by funopen on BSD and + * fopencookie on linux. The stream is backed by user-defined callbacks + * which can implement customized open, read, seek, size and close behaviors. + * + * Usage + * ----- + * + * Register your stream callbacks with the mpv_stream_cb_add_ro() function. You + * have to provide a mpv_stream_cb_open_ro_fn callback to it (open_fn argument). + * + * Once registered, you can `loadfile myprotocol://myfile`. Your open_fn will be + * invoked with the URI and you must fill out the provided mpv_stream_cb_info + * struct. This includes your stream callbacks (like read_fn), and an opaque + * cookie, which will be passed as the first argument to all the remaining + * stream callbacks. + * + * Note that your custom callbacks must not invoke libmpv APIs as that would + * cause a deadlock. (Unless you call a different mpv_handle than the one the + * callback was registered for, and the mpv_handles refer to different mpv + * instances.) + * + * Stream lifetime + * --------------- + * + * A stream remains valid until its close callback has been called. It's up to + * libmpv to call the close callback, and the libmpv user cannot close it + * directly with the stream_cb API. + * + * For example, if you consider your custom stream to become suddenly invalid + * (maybe because the underlying stream died), libmpv will continue using your + * stream. All you can do is returning errors from each callback, until libmpv + * gives up and closes it. + * + * Protocol registration and lifetime + * ---------------------------------- + * + * Protocols remain registered until the mpv instance is terminated. This means + * in particular that it can outlive the mpv_handle that was used to register + * it, but once mpv_terminate_destroy() is called, your registered callbacks + * will not be called again. + * + * Protocol unregistration is finished after the mpv core has been destroyed + * (e.g. after mpv_terminate_destroy() has returned). + * + * If you do not call mpv_terminate_destroy() yourself (e.g. plugin-style code), + * you will have to deal with the registration or even streams outliving your + * code. Here are some possible ways to do this: + * - call mpv_terminate_destroy(), which destroys the core, and will make sure + * all streams are closed once this function returns + * - you refcount all resources your stream "cookies" reference, so that it + * doesn't matter if streams live longer than expected + * - create "cancellation" semantics: after your protocol has been unregistered, + * notify all your streams that are still opened, and make them drop all + * referenced resources - then return errors from the stream callbacks as + * long as the stream is still opened + * + */ + +/** + * Read callback used to implement a custom stream. The semantics of the + * callback match read(2) in blocking mode. Short reads are allowed (you can + * return less bytes than requested, and libmpv will retry reading the rest + * with another call). If no data can be immediately read, the callback must + * block until there is new data. A return of 0 will be interpreted as final + * EOF, although libmpv might retry the read, or seek to a different position. + * + * @param cookie opaque cookie identifying the stream, + * returned from mpv_stream_cb_open_fn + * @param buf buffer to read data into + * @param size of the buffer + * @return number of bytes read into the buffer + * @return 0 on EOF + * @return -1 on error + */ +typedef int64_t (*mpv_stream_cb_read_fn)(void *cookie, char *buf, uint64_t nbytes); + +/** + * Seek callback used to implement a custom stream. + * + * Note that mpv will issue a seek to position 0 immediately after opening. This + * is used to test whether the stream is seekable (since seekability might + * depend on the URI contents, not just the protocol). Return + * MPV_ERROR_UNSUPPORTED if seeking is not implemented for this stream. This + * seek also serves to establish the fact that streams start at position 0. + * + * This callback can be NULL, in which it behaves as if always returning + * MPV_ERROR_UNSUPPORTED. + * + * @param cookie opaque cookie identifying the stream, + * returned from mpv_stream_cb_open_fn + * @param offset target absolut stream position + * @return the resulting offset of the stream + * MPV_ERROR_UNSUPPORTED or MPV_ERROR_GENERIC if the seek failed + */ +typedef int64_t (*mpv_stream_cb_seek_fn)(void *cookie, int64_t offset); + +/** + * Size callback used to implement a custom stream. + * + * Return MPV_ERROR_UNSUPPORTED if no size is known. + * + * This callback can be NULL, in which it behaves as if always returning + * MPV_ERROR_UNSUPPORTED. + * + * @param cookie opaque cookie identifying the stream, + * returned from mpv_stream_cb_open_fn + * @return the total size in bytes of the stream + */ +typedef int64_t (*mpv_stream_cb_size_fn)(void *cookie); + +/** + * Close callback used to implement a custom stream. + * + * @param cookie opaque cookie identifying the stream, + * returned from mpv_stream_cb_open_fn + */ +typedef void (*mpv_stream_cb_close_fn)(void *cookie); + +/** + * Cancel callback used to implement a custom stream. + * + * This callback is used to interrupt any current or future read and seek + * operations. It will be called from a separate thread than the demux + * thread, and should not block. + * + * This callback can be NULL. + * + * Available since API 1.106. + * + * @param cookie opaque cookie identifying the stream, + * returned from mpv_stream_cb_open_fn + */ +typedef void (*mpv_stream_cb_cancel_fn)(void *cookie); + +/** + * See mpv_stream_cb_open_ro_fn callback. + */ +typedef struct mpv_stream_cb_info { + /** + * Opaque user-provided value, which will be passed to the other callbacks. + * The close callback will be called to release the cookie. It is not + * interpreted by mpv. It doesn't even need to be a valid pointer. + * + * The user sets this in the mpv_stream_cb_open_ro_fn callback. + */ + void *cookie; + + /** + * Callbacks set by the user in the mpv_stream_cb_open_ro_fn callback. Some + * of them are optional, and can be left unset. + * + * The following callbacks are mandatory: read_fn, close_fn + */ + mpv_stream_cb_read_fn read_fn; + mpv_stream_cb_seek_fn seek_fn; + mpv_stream_cb_size_fn size_fn; + mpv_stream_cb_close_fn close_fn; + mpv_stream_cb_cancel_fn cancel_fn; /* since API 1.106 */ +} mpv_stream_cb_info; + +/** + * Open callback used to implement a custom read-only (ro) stream. The user + * must set the callback fields in the passed info struct. The cookie field + * also can be set to store state associated to the stream instance. + * + * Note that the info struct is valid only for the duration of this callback. + * You can't change the callbacks or the pointer to the cookie at a later point. + * + * Each stream instance created by the open callback can have different + * callbacks. + * + * The close_fn callback will terminate the stream instance. The pointers to + * your callbacks and cookie will be discarded, and the callbacks will not be + * called again. + * + * @param user_data opaque user data provided via mpv_stream_cb_add() + * @param uri name of the stream to be opened (with protocol prefix) + * @param info fields which the user should fill + * @return 0 on success, MPV_ERROR_LOADING_FAILED if the URI cannot be opened. + */ +typedef int (*mpv_stream_cb_open_ro_fn)(void *user_data, char *uri, + mpv_stream_cb_info *info); + +/** + * Add a custom stream protocol. This will register a protocol handler under + * the given protocol prefix, and invoke the given callbacks if an URI with the + * matching protocol prefix is opened. + * + * The "ro" is for read-only - only read-only streams can be registered with + * this function. + * + * The callback remains registered until the mpv core is registered. + * + * If a custom stream with the same name is already registered, then the + * MPV_ERROR_INVALID_PARAMETER error is returned. + * + * @param protocol protocol prefix, for example "foo" for "foo://" URIs + * @param user_data opaque pointer passed into the mpv_stream_cb_open_fn + * callback. + * @return error code + */ +int mpv_stream_cb_add_ro(mpv_handle *ctx, const char *protocol, void *user_data, + mpv_stream_cb_open_ro_fn open_fn); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Vendor/mpv/iOS/lib/libass.a b/Vendor/mpv/iOS/lib/libass.a new file mode 100644 index 00000000..381e01d8 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libass.a differ diff --git a/Vendor/mpv/iOS/lib/libavcodec.a b/Vendor/mpv/iOS/lib/libavcodec.a new file mode 100644 index 00000000..a91f12ee Binary files /dev/null and b/Vendor/mpv/iOS/lib/libavcodec.a differ diff --git a/Vendor/mpv/iOS/lib/libavdevice.a b/Vendor/mpv/iOS/lib/libavdevice.a new file mode 100644 index 00000000..74c27ac3 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libavdevice.a differ diff --git a/Vendor/mpv/iOS/lib/libavfilter.a b/Vendor/mpv/iOS/lib/libavfilter.a new file mode 100644 index 00000000..f57bace4 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libavfilter.a differ diff --git a/Vendor/mpv/iOS/lib/libavformat.a b/Vendor/mpv/iOS/lib/libavformat.a new file mode 100644 index 00000000..79bfcc70 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libavformat.a differ diff --git a/Vendor/mpv/iOS/lib/libavutil.a b/Vendor/mpv/iOS/lib/libavutil.a new file mode 100644 index 00000000..eea828cc Binary files /dev/null and b/Vendor/mpv/iOS/lib/libavutil.a differ diff --git a/Vendor/mpv/iOS/lib/libcrypto.a b/Vendor/mpv/iOS/lib/libcrypto.a new file mode 100644 index 00000000..c8f5c6b8 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libcrypto.a differ diff --git a/Vendor/mpv/iOS/lib/libfreetype.a b/Vendor/mpv/iOS/lib/libfreetype.a new file mode 100644 index 00000000..316454bd Binary files /dev/null and b/Vendor/mpv/iOS/lib/libfreetype.a differ diff --git a/Vendor/mpv/iOS/lib/libfribidi.a b/Vendor/mpv/iOS/lib/libfribidi.a new file mode 100644 index 00000000..02ac0a09 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libfribidi.a differ diff --git a/Vendor/mpv/iOS/lib/libharfbuzz.a b/Vendor/mpv/iOS/lib/libharfbuzz.a new file mode 100644 index 00000000..a4ec0ac6 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libharfbuzz.a differ diff --git a/Vendor/mpv/iOS/lib/libmpv.a b/Vendor/mpv/iOS/lib/libmpv.a new file mode 100644 index 00000000..7b871b5d Binary files /dev/null and b/Vendor/mpv/iOS/lib/libmpv.a differ diff --git a/Vendor/mpv/iOS/lib/libssl.a b/Vendor/mpv/iOS/lib/libssl.a new file mode 100644 index 00000000..2d9ae943 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libssl.a differ diff --git a/Vendor/mpv/iOS/lib/libswresample.a b/Vendor/mpv/iOS/lib/libswresample.a new file mode 100644 index 00000000..3caea487 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libswresample.a differ diff --git a/Vendor/mpv/iOS/lib/libswscale.a b/Vendor/mpv/iOS/lib/libswscale.a new file mode 100644 index 00000000..cc5f24e3 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libswscale.a differ diff --git a/Vendor/mpv/iOS/lib/libuchardet.a b/Vendor/mpv/iOS/lib/libuchardet.a new file mode 100644 index 00000000..17c7c6c9 Binary files /dev/null and b/Vendor/mpv/iOS/lib/libuchardet.a differ diff --git a/iOS/BridgingHeader.h b/iOS/BridgingHeader.h new file mode 100644 index 00000000..bd2b395a --- /dev/null +++ b/iOS/BridgingHeader.h @@ -0,0 +1,5 @@ +#import +#import "../Vendor/mpv/iOS/include/client.h" +#import "../Vendor/mpv/iOS/include/render.h" +#import "../Vendor/mpv/iOS/include/render_gl.h" +#import "../Vendor/mpv/iOS/include/stream_cb.h" diff --git a/iOS/Info.plist b/iOS/Info.plist index 3d6360dc..9963802d 100644 --- a/iOS/Info.plist +++ b/iOS/Info.plist @@ -16,10 +16,7 @@ UIApplicationSceneManifest - - UIApplicationSupportsMultipleScenes - - + UIBackgroundModes audio diff --git a/macOS/AVPlayerView.swift b/macOS/AVPlayerView.swift new file mode 100644 index 00000000..3c36beff --- /dev/null +++ b/macOS/AVPlayerView.swift @@ -0,0 +1,27 @@ +import Defaults +import SwiftUI + +struct AVPlayerView: NSViewControllerRepresentable { + @EnvironmentObject private var player + + @State private var controller: AVPlayerViewController? + + init(controller: AVPlayerViewController? = nil) { + self.controller = controller + } + + func makeNSViewController(context _: Context) -> AVPlayerViewController { + if self.controller != nil { + return self.controller! + } + + let controller = AVPlayerViewController() + + controller.playerModel = player + player.controller = controller + + return controller + } + + func updateNSViewController(_: AVPlayerViewController, context _: Context) {} +} diff --git a/macOS/AVPlayerViewController.swift b/macOS/AVPlayerViewController.swift new file mode 100644 index 00000000..9f18b8af --- /dev/null +++ b/macOS/AVPlayerViewController.swift @@ -0,0 +1,34 @@ +import AVKit +import SwiftUI + +final class AVPlayerViewController: NSViewController { + var playerModel: PlayerModel! + var playerView = AVPlayerView() + var pictureInPictureDelegate = PictureInPictureDelegate() + + var aspectRatio: Double? { + let ratio = Double(playerView.videoBounds.width) / Double(playerView.videoBounds.height) + + if !ratio.isFinite { + return VideoPlayerView.defaultAspectRatio + } + + return [ratio, 1.0].max()! + } + + override func viewDidDisappear() { + super.viewDidDisappear() + } + + override func loadView() { + playerView.player = playerModel.avPlayer + pictureInPictureDelegate.playerModel = playerModel + + playerView.allowsPictureInPicturePlayback = true + playerView.showsFullScreenToggleButton = true + + playerView.pictureInPictureDelegate = pictureInPictureDelegate + + view = playerView + } +}