UI improvements, player state refactor

Model/AudioVideoStream.swift

@@ -1,12 +0,0 @@
-import AVFoundation
-import Foundation
-
-final class AudioVideoStream: Stream {
-    var avAsset: AVURLAsset
-
-    init(avAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
-        self.avAsset = avAsset
-
-        super.init(audioAsset: avAsset, videoAsset: avAsset, resolution: resolution, type: type, encoding: encoding)
-    }
-}

Model/PlayerState.swift

@@ -9,28 +9,139 @@ final class PlayerState: ObservableObject {
     let logger = Logger(label: "net.arekf.Pearvidious.ps")
 
     var video: Video!
-    private(set) var composition = AVMutableComposition()
-    private(set) var nextComposition = AVMutableComposition()
 
-    private(set) var currentStream: Stream!
+    var player: AVPlayer!
 
-    private(set) var nextStream: Stream!
-    private(set) var streamLoading = false
+    private var compositions = [Stream: AVMutableComposition]()
 
     private(set) var currentTime: CMTime?
     private(set) var savedTime: CMTime?
 
-    var currentSegment: Segment?
-
-    private(set) var profile = Profile()
-
     private(set) var currentRate: Float = 0.0
-    static let availablePlaybackRates: [Double] = [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2]
+    static let availableRates: [Double] = [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2]
 
-    var player: AVPlayer!
+    let maxResolution: Stream.Resolution?
+    var timeObserver: Any?
 
-    var playerItem: AVPlayerItem {
-        let playerItem = AVPlayerItem(asset: composition)
+    init(_ video: Video? = nil, maxResolution: Stream.Resolution? = nil) {
+        self.video = video
+        self.maxResolution = maxResolution
+    }
+
+    deinit {
+        destroyPlayer()
+    }
+
+    func loadVideo(_ video: Video?) {
+        guard video != nil else {
+            return
+        }
+
+        InvidiousAPI.shared.video(video!.id).load().onSuccess { response in
+            if let video: Video = response.typedContent() {
+                self.video = video
+
+                self.playVideo(video)
+            }
+        }
+    }
+
+    fileprivate func playVideo(_ video: Video) {
+        if video.hlsUrl != nil {
+            playHlsUrl()
+            return
+        }
+
+        let stream = maxResolution != nil ? video.streamWithResolution(maxResolution!) : video.defaultStream
+
+        guard stream != nil else {
+            return
+        }
+
+        Task {
+            await self.loadStream(stream!)
+
+            if stream != video.bestStream {
+                await self.loadBestStream()
+            }
+        }
+    }
+
+    fileprivate func playHlsUrl() {
+        player.replaceCurrentItem(with: playerItemWithMetadata())
+        player.playImmediately(atRate: 1.0)
+    }
+
+    fileprivate func loadStream(_ stream: Stream) async {
+        if stream.oneMeaningfullAsset {
+            DispatchQueue.main.async {
+                self.playStream(stream)
+            }
+
+            return
+        } else {
+            await playComposition(for: stream)
+        }
+    }
+
+    fileprivate func playStream(_ stream: Stream) {
+        logger.warning("loading \(stream.description) to player")
+
+        DispatchQueue.main.async {
+            self.saveTime()
+            self.player?.replaceCurrentItem(with: self.playerItemWithMetadata(for: stream))
+            self.player?.playImmediately(atRate: 1.0)
+            self.seekToSavedTime()
+        }
+    }
+
+    fileprivate func playComposition(for stream: Stream) async {
+        async let assetAudioTrack = stream.audioAsset.loadTracks(withMediaType: .audio)
+        async let assetVideoTrack = stream.videoAsset.loadTracks(withMediaType: .video)
+
+        if let audioTrack = composition(for: stream).addMutableTrack(withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid),
+           let assetTrack = try? await assetAudioTrack.first
+        {
+            try! audioTrack.insertTimeRange(
+                CMTimeRange(start: .zero, duration: CMTime(seconds: video.length, preferredTimescale: 1000)),
+                of: assetTrack,
+                at: .zero
+            )
+            logger.critical("audio loaded")
+        } else {
+            fatalError("no track")
+        }
+
+        if let videoTrack = composition(for: stream).addMutableTrack(withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid),
+           let assetTrack = try? await assetVideoTrack.first
+        {
+            try! videoTrack.insertTimeRange(
+                CMTimeRange(start: .zero, duration: CMTime(seconds: video.length, preferredTimescale: 1000)),
+                of: assetTrack,
+                at: .zero
+            )
+            logger.critical("video loaded")
+
+            playStream(stream)
+        } else {
+            fatalError("no track")
+        }
+    }
+
+    fileprivate func playerItem(for stream: Stream? = nil) -> AVPlayerItem {
+        if stream != nil {
+            if stream!.oneMeaningfullAsset {
+                return AVPlayerItem(asset: stream!.videoAsset, automaticallyLoadedAssetKeys: [.isPlayable])
+            } else {
+                return AVPlayerItem(asset: composition(for: stream!))
+            }
+        }
+
+        return AVPlayerItem(url: video.hlsUrl!)
+    }
+
+    fileprivate func playerItemWithMetadata(for stream: Stream? = nil) -> AVPlayerItem {
+        let playerItemWithMetadata = playerItem(for: stream)
 
         var externalMetadata = [
             makeMetadataItem(.commonIdentifierTitle, value: video.title),
@@ -47,196 +158,34 @@ final class PlayerState: ObservableObject {
                 externalMetadata.append(artworkItem)
             }
 
-            playerItem.externalMetadata = externalMetadata
+            playerItemWithMetadata.externalMetadata = externalMetadata
         #endif
 
-        playerItem.preferredForwardBufferDuration = 10
+        playerItemWithMetadata.preferredForwardBufferDuration = 10
 
-        return playerItem
+        return playerItemWithMetadata
     }
 
-    var segmentsProvider: SponsorBlockAPI?
-    var timeObserver: Any?
-
-    init(_ video: Video? = nil) {
-        self.video = video
-
-        if self.video != nil {
-            segmentsProvider = SponsorBlockAPI(self.video.id)
-            segmentsProvider!.load()
-        }
+    func setPlayerRate(_ rate: Float) {
+        currentRate = rate
+        player.rate = rate
     }
 
-    deinit {
-        destroyPlayer()
-    }
-
-    func loadVideo(_ video: Video?) {
-        guard video != nil else {
-            return
+    fileprivate func composition(for stream: Stream) -> AVMutableComposition {
+        if compositions[stream] == nil {
+            compositions[stream] = AVMutableComposition()
         }
 
-        InvidiousAPI.shared.video(video!.id).load().onSuccess { response in
-            if let video: Video = response.typedContent() {
-                self.video = video
-                Task {
-                    let loadBest = self.profile.defaultStreamResolution == .hd720pFirstThenBest
-                    await self.loadStream(video.defaultStreamForProfile(self.profile)!, loadBest: loadBest)
-                }
-            }
-        }
-    }
-
-    func loadStream(_ stream: Stream, loadBest: Bool = false) async {
-        nextStream?.cancelLoadingAssets()
-//        removeTracksFromNextComposition()
-
-        nextComposition = AVMutableComposition()
-
-        DispatchQueue.main.async {
-            self.streamLoading = true
-            self.nextStream = stream
-        }
-        logger.info("replace streamToLoad: \(nextStream?.description ?? "nil"), streamLoading \(streamLoading)")
-
-        await addTracksAndLoadAssets(stream, loadBest: loadBest)
-    }
-
-    fileprivate func addTracksAndLoadAssets(_ stream: Stream, loadBest: Bool = false) async {
-        logger.info("adding tracks and loading assets for: \(stream.type), \(stream.description)")
-
-        stream.assets.forEach { asset in
-            Task.init {
-                if try await asset.load(.isPlayable) {
-                    handleAssetLoad(stream, asset: asset, type: asset == stream.videoAsset ? .video : .audio, loadBest: loadBest)
-
-                    if stream.assetsLoaded {
-                        logger.info("ALL assets loaded: \(stream.type), \(stream.description)")
-
-                        playStream(stream)
-
-                        if loadBest {
-                            await self.loadBestStream()
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fileprivate func handleAssetLoad(_ stream: Stream, asset: AVURLAsset, type: AVMediaType, loadBest _: Bool = false) {
-        logger.info("handling asset load: \(stream.type), \(type) \(stream.description)")
-
-        guard stream != currentStream else {
-            logger.warning("IGNORING assets loaded: \(stream.type), \(stream.description)")
-            return
-        }
-
-        addTrack(asset, stream: stream, type: type)
-    }
-
-    fileprivate func addTrack(_ asset: AVURLAsset, stream: Stream, type: AVMediaType? = nil) {
-        let types: [AVMediaType] = stream.type == .adaptive ? [type!] : [.video, .audio]
-
-        types.forEach { addTrackToNextComposition(asset, type: $0) }
+        return compositions[stream]!
     }
 
     fileprivate func loadBestStream() async {
-        guard currentStream != video.bestStream else {
-            return
-        }
-
         if let bestStream = video.bestStream {
             await loadStream(bestStream)
         }
     }
 
-    func streamDidLoad(_ stream: Stream?) {
-        logger.info("didload stream: \(stream!.description)")
-
-        currentStream?.cancelLoadingAssets()
-        currentStream = stream
-        streamLoading = nextStream != stream
-
-        if nextStream == stream {
-            nextStream = nil
-        }
-
-//        addTimeObserver()
-    }
-
-    func cancelLoadingStream(_ stream: Stream) {
-        guard nextStream == stream else {
-            return
-        }
-
-        nextStream = nil
-        streamLoading = false
-
-        logger.info("cancel streamToLoad: \(nextStream?.description ?? "nil"), streamLoading \(streamLoading)")
-    }
-
-    func playStream(_ stream: Stream) {
-//        guard player != nil else {
-//            fatalError("player does not exists for playing")
-//        }
-
-        logger.warning("loading \(stream.description) to player")
-
-        saveTime()
-        replaceCompositionTracks()
-
-        player!.replaceCurrentItem(with: playerItem)
-        streamDidLoad(stream)
-
-        DispatchQueue.main.async {
-            self.player?.play()
-            self.seekToSavedTime()
-        }
-    }
-
-    func addTrackToNextComposition(_ asset: AVURLAsset, type: AVMediaType) {
-        guard let assetTrack = asset.tracks(withMediaType: type).first else {
-            return
-        }
-
-        if let track = nextComposition.tracks(withMediaType: type).first {
-            logger.info("removing \(type) track")
-            nextComposition.removeTrack(track)
-        }
-
-        let track = nextComposition.addMutableTrack(withMediaType: type, preferredTrackID: kCMPersistentTrackID_Invalid)!
-
-        try! track.insertTimeRange(
-            CMTimeRange(start: .zero, duration: CMTime(seconds: video.length, preferredTimescale: 1000)),
-            of: assetTrack,
-            at: .zero
-        )
-
-        logger.info("inserted \(type) track")
-    }
-
-    func replaceCompositionTracks() {
-        logger.warning("replacing compositions")
-
-        composition = AVMutableComposition()
-
-        nextComposition.tracks.forEach { track in
-            let newTrack = composition.addMutableTrack(withMediaType: track.mediaType, preferredTrackID: kCMPersistentTrackID_Invalid)!
-
-            try? newTrack.insertTimeRange(
-                CMTimeRange(start: .zero, duration: CMTime(seconds: video.length, preferredTimescale: 1000)),
-                of: track,
-                at: .zero
-            )
-        }
-    }
-
-    func removeTracksFromNextComposition() {
-        nextComposition.tracks.forEach { nextComposition.removeTrack($0) }
-    }
-
-    func saveTime() {
+    fileprivate func saveTime() {
         guard player != nil else {
             return
         }
@@ -250,7 +199,7 @@ final class PlayerState: ObservableObject {
         savedTime = currentTime
     }
 
-    func seekToSavedTime() {
+    fileprivate func seekToSavedTime() {
         guard player != nil else {
             return
         }
@@ -261,51 +210,32 @@ final class PlayerState: ObservableObject {
         }
     }
 
-    func destroyPlayer() {
+    fileprivate func destroyPlayer() {
         logger.critical("destroying player")
 
         player?.currentItem?.tracks.forEach { $0.assetTrack?.asset?.cancelLoading() }
 
-        currentStream?.cancelLoadingAssets()
-        nextStream?.cancelLoadingAssets()
-
-        player?.cancelPendingPrerolls()
         player?.replaceCurrentItem(with: nil)
 
         if timeObserver != nil {
             player?.removeTimeObserver(timeObserver!)
             timeObserver = nil
         }
+
         player = nil
-        currentStream = nil
-        nextStream = nil
     }
 
-    func addTimeObserver() {
+    fileprivate func addTimeObserver() {
         let interval = CMTime(value: 1, timescale: 1)
-        timeObserver = player.addPeriodicTimeObserver(forInterval: interval, queue: .main) { time in
-            guard self.player != nil else {
-                return
-            }
-            self.currentTime = time
-
-            self.currentSegment = self.segmentsProvider?.segments.first { $0.timeInSegment(time) }
-
-            if let segment = self.currentSegment {
-                if self.profile.skippedSegmentsCategories.contains(segment.category) {
-                    if segment.shouldSkip(self.currentTime!) {
-                        self.player.seek(to: segment.skipTo)
-                    }
-                }
-            }
 
+        timeObserver = player.addPeriodicTimeObserver(forInterval: interval, queue: .main) { _ in
             if self.player.rate != self.currentRate, self.player.rate != 0, self.currentRate != 0 {
                 self.player.rate = self.currentRate
             }
         }
     }
 
-    private func makeMetadataItem(_ identifier: AVMetadataIdentifier, value: Any) -> AVMetadataItem {
+    fileprivate func makeMetadataItem(_ identifier: AVMetadataIdentifier, value: Any) -> AVMetadataItem {
         let item = AVMutableMetadataItem()
 
         item.identifier = identifier
@@ -314,9 +244,4 @@ final class PlayerState: ObservableObject {
 
         return item.copy() as! AVMetadataItem
     }
-
-    func setPlayerRate(_ rate: Float) {
-        currentRate = rate
-        player.rate = rate
-    }
 }

Model/Playlist.swift

@@ -2,9 +2,21 @@ import Foundation
 import SwiftyJSON
 
 struct Playlist: Identifiable, Equatable, Hashable {
+    enum Visibility: String, CaseIterable, Identifiable {
+        case `public`, unlisted, `private`
+
+        var id: String {
+            rawValue
+        }
+
+        var name: String {
+            rawValue.capitalized
+        }
+    }
+
     let id: String
     var title: String
-    var visibility: PlaylistVisibility
+    var visibility: Visibility
 
     var updated: TimeInterval
 

Model/PlaylistVisibility.swift

@@ -1,13 +0,0 @@
-import Foundation
-
-enum PlaylistVisibility: String, CaseIterable, Identifiable {
-    case `public`, unlisted, `private`
-
-    var id: String {
-        rawValue
-    }
-
-    var name: String {
-        rawValue.capitalized
-    }
-}

Model/Profile.swift

@@ -2,7 +2,7 @@ import Defaults
 import Foundation
 
 struct Profile {
-    var defaultStreamResolution: DefaultStreamResolution = .hd720pFirstThenBest
+    var defaultStreamResolution: DefaultStreamResolution = .hd1080p
 
     var skippedSegmentsCategories = [String]() // SponsorBlockSegmentsProvider.categories
 
@@ -15,12 +15,12 @@ struct Profile {
 enum DefaultStreamResolution: String {
     case hd720pFirstThenBest, hd1080p, hd720p, sd480p, sd360p, sd240p, sd144p
 
-    var value: StreamResolution {
+    var value: Stream.Resolution {
         switch self {
         case .hd720pFirstThenBest:
             return .hd720p
         default:
-            return StreamResolution(rawValue: rawValue)!
+            return Stream.Resolution(rawValue: rawValue)!
         }
     }
 }

Model/SearchDate.swift

@@ -1,13 +0,0 @@
-import Defaults
-
-enum SearchDate: String, CaseIterable, Identifiable, DefaultsSerializable {
-    case hour, today, week, month, year
-
-    var id: SearchDate.RawValue {
-        rawValue
-    }
-
-    var name: String {
-        rawValue.capitalized
-    }
-}

Model/SearchDuration.swift

@@ -1,13 +0,0 @@
-import Defaults
-
-enum SearchDuration: String, CaseIterable, Identifiable, DefaultsSerializable {
-    case short, long
-
-    var id: SearchDuration.RawValue {
-        rawValue
-    }
-
-    var name: String {
-        rawValue.capitalized
-    }
-}

Model/SearchQuery.swift

@@ -1,14 +1,69 @@
+import Defaults
 import Foundation
 
 final class SearchQuery: ObservableObject {
+    enum Date: String, CaseIterable, Identifiable, DefaultsSerializable {
+        case hour, today, week, month, year
+
+        var id: SearchQuery.Date.RawValue {
+            rawValue
+        }
+
+        var name: String {
+            rawValue.capitalized
+        }
+    }
+
+    enum Duration: String, CaseIterable, Identifiable, DefaultsSerializable {
+        case short, long
+
+        var id: SearchQuery.Duration.RawValue {
+            rawValue
+        }
+
+        var name: String {
+            rawValue.capitalized
+        }
+    }
+
+    enum SortOrder: String, CaseIterable, Identifiable, DefaultsSerializable {
+        case relevance, rating, uploadDate, viewCount
+
+        var id: SearchQuery.SortOrder.RawValue {
+            rawValue
+        }
+
+        var name: String {
+            switch self {
+            case .uploadDate:
+                return "Upload Date"
+            case .viewCount:
+                return "View Count"
+            default:
+                return rawValue.capitalized
+            }
+        }
+
+        var parameter: String {
+            switch self {
+            case .uploadDate:
+                return "upload_date"
+            case .viewCount:
+                return "view_count"
+            default:
+                return rawValue
+            }
+        }
+    }
+
     @Published var query: String
-    @Published var sortBy: SearchSortOrder = .relevance
-    @Published var date: SearchDate? = .month
-    @Published var duration: SearchDuration?
+    @Published var sortBy: SearchQuery.SortOrder = .relevance
+    @Published var date: SearchQuery.Date? = .month
+    @Published var duration: SearchQuery.Duration?
 
     @Published var page = 1
 
-    init(query: String = "", page: Int = 1, sortBy: SearchSortOrder = .relevance, date: SearchDate? = nil, duration: SearchDuration? = nil) {
+    init(query: String = "", page: Int = 1, sortBy: SearchQuery.SortOrder = .relevance, date: SearchQuery.Date? = nil, duration: SearchQuery.Duration? = nil) {
         self.query = query
         self.page = page
         self.sortBy = sortBy

Model/SearchSortOrder.swift

@@ -1,32 +0,0 @@
-import Defaults
-import Foundation
-
-enum SearchSortOrder: String, CaseIterable, Identifiable, DefaultsSerializable {
-    case relevance, rating, uploadDate, viewCount
-
-    var id: SearchSortOrder.RawValue {
-        rawValue
-    }
-
-    var name: String {
-        switch self {
-        case .uploadDate:
-            return "Upload Date"
-        case .viewCount:
-            return "View Count"
-        default:
-            return rawValue.capitalized
-        }
-    }
-
-    var parameter: String {
-        switch self {
-        case .uploadDate:
-            return "upload_date"
-        case .viewCount:
-            return "view_count"
-        default:
-            return rawValue
-        }
-    }
-}

Model/SingleAssetStream.swift

@@ -0,0 +1,12 @@
+import AVFoundation
+import Foundation
+
+final class SingleAssetStream: Stream {
+    var avAsset: AVURLAsset
+
+    init(avAsset: AVURLAsset, resolution: Resolution, kind: Kind, encoding: String) {
+        self.avAsset = avAsset
+
+        super.init(audioAsset: avAsset, videoAsset: avAsset, resolution: resolution, kind: kind, encoding: encoding)
+    }
+}

Model/Stream.swift

@@ -2,20 +2,53 @@ import AVFoundation
 import Foundation
 
 // swiftlint:disable:next final_class
-class Stream: Equatable {
+class Stream: Equatable, Hashable {
+    enum Resolution: String, CaseIterable, Comparable {
+        case hd1080p, hd720p, sd480p, sd360p, sd240p, sd144p
+
+        var height: Int {
+            Int(rawValue.components(separatedBy: CharacterSet.decimalDigits.inverted).joined())!
+        }
+
+        static func from(resolution: String) -> Resolution? {
+            allCases.first { "\($0)".contains(resolution) }
+        }
+
+        static func < (lhs: Resolution, rhs: Resolution) -> Bool {
+            lhs.height < rhs.height
+        }
+    }
+
+    enum Kind: String, Comparable {
+        case stream, adaptive
+
+        private var sortOrder: Int {
+            switch self {
+            case .stream:
+                return 0
+            case .adaptive:
+                return 1
+            }
+        }
+
+        static func < (lhs: Kind, rhs: Kind) -> Bool {
+            lhs.sortOrder < rhs.sortOrder
+        }
+    }
+
     var audioAsset: AVURLAsset
     var videoAsset: AVURLAsset
 
-    var resolution: StreamResolution
-    var type: StreamType
+    var resolution: Resolution
+    var kind: Kind
 
     var encoding: String
 
-    init(audioAsset: AVURLAsset, videoAsset: AVURLAsset, resolution: StreamResolution, type: StreamType, encoding: String) {
+    init(audioAsset: AVURLAsset, videoAsset: AVURLAsset, resolution: Resolution, kind: Kind, encoding: String) {
         self.audioAsset = audioAsset
         self.videoAsset = videoAsset
         self.resolution = resolution
-        self.type = type
+        self.kind = kind
         self.encoding = encoding
     }
 
@@ -27,6 +60,10 @@ class Stream: Equatable {
         [audioAsset, videoAsset]
     }
 
+    var oneMeaningfullAsset: Bool {
+        assets.dropFirst().allSatisfy { $0 == assets.first }
+    }
+
     var assetsLoaded: Bool {
         assets.allSatisfy { $0.statusOfValue(forKey: "playable", error: nil) == .loaded }
     }
@@ -40,6 +77,10 @@ class Stream: Equatable {
     }
 
     static func == (lhs: Stream, rhs: Stream) -> Bool {
-        lhs.resolution == rhs.resolution && lhs.type == rhs.type
+        lhs.resolution == rhs.resolution && lhs.kind == rhs.kind
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(videoAsset.url)
     }
 }

Model/StreamResolution.swift

@@ -1,17 +0,0 @@
-import Foundation
-
-enum StreamResolution: String, CaseIterable, Comparable {
-    case hd1080p, hd720p, sd480p, sd360p, sd240p, sd144p
-
-    var height: Int {
-        Int(rawValue.components(separatedBy: CharacterSet.decimalDigits.inverted).joined())!
-    }
-
-    static func from(resolution: String) -> StreamResolution? {
-        allCases.first { "\($0)".contains(resolution) }
-    }
-
-    static func < (lhs: StreamResolution, rhs: StreamResolution) -> Bool {
-        lhs.height < rhs.height
-    }
-}

Model/StreamType.swift

@@ -1,18 +0,0 @@
-import Foundation
-
-enum StreamType: String, Comparable {
-    case stream, adaptive
-
-    private var sortOrder: Int {
-        switch self {
-        case .stream:
-            return 0
-        case .adaptive:
-            return 1
-        }
-    }
-
-    static func < (lhs: StreamType, rhs: StreamType) -> Bool {
-        lhs.sortOrder < rhs.sortOrder
-    }
-}

Model/Thumbnail.swift

@@ -2,11 +2,20 @@ import Foundation
 import SwiftyJSON
 
 struct Thumbnail {
+    enum Quality: String, CaseIterable {
+        case maxres, maxresdefault, sddefault, high, medium, `default`, start, middle, end
+    }
+
     var url: URL
-    var quality: ThumbnailQuality
+    var quality: Quality
 
     init(_ json: JSON) {
         url = json["url"].url!
-        quality = ThumbnailQuality(rawValue: json["quality"].string!)!
+        quality = Quality(rawValue: json["quality"].string!)!
+    }
+
+    init(url: URL, quality: Quality) {
+        self.url = url
+        self.quality = quality
     }
 }

Model/ThumbnailQuality.swift

@@ -1,5 +0,0 @@
-import Foundation
-
-enum ThumbnailQuality: String {
-    case maxres, maxresdefault, sddefault, high, medium, `default`, start, middle, end
-}

Model/Video.swift

@@ -15,9 +15,44 @@ struct Video: Identifiable {
     var description: String
     var genre: String
 
+    // index used when in the Playlist
     let indexID: String?
 
+    var live: Bool
+    var upcoming: Bool
+
     var streams = [Stream]()
+    var hlsUrl: URL?
+
+    init(
+        id: String,
+        title: String,
+        author: String,
+        length: TimeInterval,
+        published: String,
+        views: Int,
+        channelID: String,
+        description: String,
+        genre: String,
+        thumbnails: [Thumbnail] = [],
+        indexID: String? = nil,
+        live: Bool = false,
+        upcoming: Bool = false
+    ) {
+        self.id = id
+        self.title = title
+        self.author = author
+        self.length = length
+        self.published = published
+        self.views = views
+        self.channelID = channelID
+        self.description = description
+        self.genre = genre
+        self.thumbnails = thumbnails
+        self.indexID = indexID
+        self.live = live
+        self.upcoming = upcoming
+    }
 
     init(_ json: JSON) {
         let videoID = json["videoId"].stringValue
@@ -41,8 +76,13 @@ struct Video: Identifiable {
 
         thumbnails = Video.extractThumbnails(from: json)
 
+        live = json["liveNow"].boolValue
+        upcoming = json["isUpcoming"].boolValue
+
         streams = Video.extractFormatStreams(from: json["formatStreams"].arrayValue)
         streams.append(contentsOf: Video.extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue))
+
+        hlsUrl = json["hlsUrl"].url
     }
 
     var playTime: String? {
@@ -59,6 +99,10 @@ struct Video: Identifiable {
         return formatter.string(from: length)
     }
 
+    var publishedDate: String? {
+        (published.isEmpty || published == "0 seconds ago") ? nil : published
+    }
+
     var viewsCount: String {
         let formatter = NumberFormatter()
         formatter.numberStyle = .decimal
@@ -82,8 +126,8 @@ struct Video: Identifiable {
         let streams = streams.sorted { $0.resolution > $1.resolution }
         var selectable = [Stream]()
 
-        StreamResolution.allCases.forEach { resolution in
-            if let stream = streams.filter({ $0.resolution == resolution }).min(by: { $0.type < $1.type }) {
+        Stream.Resolution.allCases.forEach { resolution in
+            if let stream = streams.filter({ $0.resolution == resolution }).min(by: { $0.kind < $1.kind }) {
                 selectable.append(stream)
             }
         }
@@ -92,14 +136,14 @@ struct Video: Identifiable {
     }
 
     var defaultStream: Stream? {
-        selectableStreams.first { $0.type == .stream }
+        selectableStreams.first { $0.kind == .stream }
     }
 
     var bestStream: Stream? {
         selectableStreams.min { $0.resolution > $1.resolution }
     }
 
-    func streamWithResolution(_ resolution: StreamResolution) -> Stream? {
+    func streamWithResolution(_ resolution: Stream.Resolution) -> Stream? {
         selectableStreams.first { $0.resolution == resolution }
     }
 
@@ -107,7 +151,7 @@ struct Video: Identifiable {
         streamWithResolution(profile.defaultStreamResolution.value) ?? streams.first
     }
 
-    func thumbnailURL(quality: ThumbnailQuality) -> URL? {
+    func thumbnailURL(quality: Thumbnail.Quality) -> URL? {
         thumbnails.first { $0.quality == quality }?.url
     }
 
@@ -117,12 +161,14 @@ struct Video: Identifiable {
         }
     }
 
+    static let options = [AVURLAssetPreferPreciseDurationAndTimingKey: false]
+
     private static func extractFormatStreams(from streams: [JSON]) -> [Stream] {
         streams.map {
-            AudioVideoStream(
-                avAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset($0["url"].stringValue)!),
-                resolution: StreamResolution.from(resolution: $0["resolution"].stringValue)!,
-                type: .stream,
+            SingleAssetStream(
+                avAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset($0["url"].stringValue)!, options: options),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue)!,
+                kind: .stream,
                 encoding: $0["encoding"].stringValue
             )
         }
@@ -138,10 +184,10 @@ struct Video: Identifiable {
 
         return videoAssetsURLs.map {
             Stream(
-                audioAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset(audioAssetURL!["url"].stringValue)!),
-                videoAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset($0["url"].stringValue)!),
-                resolution: StreamResolution.from(resolution: $0["resolution"].stringValue)!,
-                type: .adaptive,
+                audioAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset(audioAssetURL!["url"].stringValue)!, options: options),
+                videoAsset: AVURLAsset(url: InvidiousAPI.proxyURLForAsset($0["url"].stringValue)!, options: options),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue)!,
+                kind: .adaptive,
                 encoding: $0["encoding"].stringValue
             )
         }