Accept movie progress from all clients and return resume position on movie detail.

Recovered the ClearKey AVPlayer/proxy stack from the Mac stash, keep later UI fixes, resolve DASH segments against the redirected manifest URL and XML-unescape MPD values.

apps/ios/VMC.xcodeproj/project.pbxproj

@@ -33,6 +33,7 @@
 		668CADCCEA404B50BB19A46E /* DetailScreens.swift in Sources */ = {isa = PBXBuildFile; fileRef = F0A435950EF040DE83F30779 /* DetailScreens.swift */; };
 		A72DE8139DAE48EC9975E0CF /* LiveTvScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98E3A2A592E64C998AB1B72A /* LiveTvScreen.swift */; };
 		E5F6A7B8C9D0E1F2A3B4C5D6 /* EventsScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = F1A2B3C4D5E6F7A8B9C0D1E2 /* EventsScreen.swift */; };
+		B7C3E9F1B2D4068E5A1C3E71 /* EventHubsScreens.swift in Sources */ = {isa = PBXBuildFile; fileRef = A7C3E9F1B2D4068E5A1C3E71 /* EventHubsScreens.swift */; };
 		A1CFC814F3894773A5BEA652 /* SettingsScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = 470B4DF416DE4B3FB7A60DDB /* SettingsScreen.swift */; };
 		B8D4E1F2A3C54B6D9E0F1A2B /* DevicesScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = C1D2E3F4A5B647C8D9E0F1A3 /* DevicesScreen.swift */; };
 		B7C2E91A4F8D4A1E9C3B6D20 /* QualityBadges.swift in Sources */ = {isa = PBXBuildFile; fileRef = D4A1F82E6B9C4E7A8F1D3C50 /* QualityBadges.swift */; };
@@ -69,6 +70,7 @@
 		F0A435950EF040DE83F30779 /* DetailScreens.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DetailScreens.swift; sourceTree = "<group>"; };
 		98E3A2A592E64C998AB1B72A /* LiveTvScreen.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LiveTvScreen.swift; sourceTree = "<group>"; };
 		F1A2B3C4D5E6F7A8B9C0D1E2 /* EventsScreen.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EventsScreen.swift; sourceTree = "<group>"; };
+		A7C3E9F1B2D4068E5A1C3E71 /* EventHubsScreens.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EventHubsScreens.swift; sourceTree = "<group>"; };
 		470B4DF416DE4B3FB7A60DDB /* SettingsScreen.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SettingsScreen.swift; sourceTree = "<group>"; };
 		C1D2E3F4A5B647C8D9E0F1A3 /* DevicesScreen.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DevicesScreen.swift; sourceTree = "<group>"; };
 		D4A1F82E6B9C4E7A8F1D3C50 /* QualityBadges.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QualityBadges.swift; sourceTree = "<group>"; };
@@ -186,6 +188,7 @@
 				D4A1F82E6B9C4E7A8F1D3C50 /* QualityBadges.swift */,
 				98E3A2A592E64C998AB1B72A /* LiveTvScreen.swift */,
 				F1A2B3C4D5E6F7A8B9C0D1E2 /* EventsScreen.swift */,
+				A7C3E9F1B2D4068E5A1C3E71 /* EventHubsScreens.swift */,
 				470B4DF416DE4B3FB7A60DDB /* SettingsScreen.swift */,
 				C1D2E3F4A5B647C8D9E0F1A3 /* DevicesScreen.swift */,
 			);
@@ -291,6 +294,7 @@
 				B7C2E91A4F8D4A1E9C3B6D20 /* QualityBadges.swift in Sources */,
 				A72DE8139DAE48EC9975E0CF /* LiveTvScreen.swift in Sources */,
 				E5F6A7B8C9D0E1F2A3B4C5D6 /* EventsScreen.swift in Sources */,
+				B7C3E9F1B2D4068E5A1C3E71 /* EventHubsScreens.swift in Sources */,
 				A1CFC814F3894773A5BEA652 /* SettingsScreen.swift in Sources */,
 				B8D4E1F2A3C54B6D9E0F1A2B /* DevicesScreen.swift in Sources */,
 			);
@@ -341,7 +345,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 52;
+				CURRENT_PROJECT_VERSION = 62;
 				DEVELOPMENT_TEAM = X25NYX3K49;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -356,7 +360,7 @@
 				"$(inherited)",
 				"@executable_path/Frameworks"
 				);
-				MARKETING_VERSION = 0.5.39;
+				MARKETING_VERSION = 0.5.49;
 				OTHER_LDFLAGS = ("$(inherited)", "-ObjC");
 				PRODUCT_BUNDLE_IDENTIFIER = nl.vonas.mediacluster.ios;
 				PRODUCT_NAME = "$(TARGET_NAME)";
@@ -374,7 +378,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 52;
+				CURRENT_PROJECT_VERSION = 62;
 				DEVELOPMENT_TEAM = X25NYX3K49;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -389,7 +393,7 @@
 				"$(inherited)",
 				"@executable_path/Frameworks"
 				);
-				MARKETING_VERSION = 0.5.39;
+				MARKETING_VERSION = 0.5.49;
 				OTHER_LDFLAGS = ("$(inherited)", "-ObjC");
 				PRODUCT_BUNDLE_IDENTIFIER = nl.vonas.mediacluster.ios;
 				PRODUCT_NAME = "$(TARGET_NAME)";

apps/ios/VMC/Data/ApiClient.swift

@@ -344,6 +344,39 @@ actor ApiClient {
         return try await get("/api/v1/client/events/\(enc)/play")
     }
 
+    func eventHubs() async throws -> [EventHub] {
+        struct Wrap: Decodable { let hubs: [EventHub]? }
+        let wrap: Wrap = try await get("/api/v1/client/hubs")
+        return wrap.hubs ?? []
+    }
+
+    func f1Home() async throws -> F1HubPayload {
+        try await get("/api/v1/client/f1/home")
+    }
+
+    func f1Meeting(meetingKey: String) async throws -> F1MeetingDetail {
+        let enc = Self.encodePathSegment(meetingKey)
+        return try await get("/api/v1/client/f1/meetings/\(enc)")
+    }
+
+    func f1ContentPlay(contentId: String) async throws -> IptvPlayInfo {
+        let enc = Self.encodePathSegment(contentId)
+        return try await get("/api/v1/client/f1/content/\(enc)/play")
+    }
+
+    func viaplayHome() async throws -> ViaplayHubPayload {
+        try await get("/api/v1/client/viaplay/home")
+    }
+
+    func viaplayContentPlay(guid: String, productUrl: String?) async throws -> IptvPlayInfo {
+        let enc = Self.encodePathSegment(guid)
+        var q = ""
+        if let productUrl = productUrl?.trimmingCharacters(in: .whitespacesAndNewlines), !productUrl.isEmpty {
+            q = "?productUrl=\(Self.encodePathSegment(productUrl))"
+        }
+        return try await get("/api/v1/client/viaplay/content/\(enc)/play\(q)")
+    }
+
     /// Encode path segment (incl. `:` in `custom:uuid`) — strenger dan urlPathAllowed.
     private static func encodePathSegment(_ raw: String) -> String {
         var allowed = CharacterSet.alphanumerics

apps/ios/VMC/Data/Models.swift

@@ -593,3 +593,172 @@ struct ApiErrorBody: Decodable {
     let error: ErrorObj?
 }
 
+// MARK: - Event hubs (F1 / Viaplay)
+
+struct EventHub: Decodable, Identifiable, Hashable {
+    let id: String
+    let label: String
+    let subtitle: String?
+}
+
+struct F1Meeting: Decodable, Identifiable, Hashable {
+    var id: String { meetingKey }
+    let meetingKey: String
+    let title: String
+    let meetingNumber: Int?
+    let location: String?
+    let startMs: Double?
+    let endMs: Double?
+    let imageUrl: String?
+
+    enum CodingKeys: String, CodingKey {
+        case meetingKey, title, meetingNumber, location, startMs, endMs, imageUrl
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        meetingKey = try decodeFlexibleString(c, forKey: .meetingKey)
+        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
+        meetingNumber = try? c.decodeIfPresent(Int.self, forKey: .meetingNumber)
+        location = try c.decodeIfPresent(String.self, forKey: .location)
+        startMs = try? c.decodeIfPresent(Double.self, forKey: .startMs)
+        endMs = try? c.decodeIfPresent(Double.self, forKey: .endMs)
+        imageUrl = try c.decodeIfPresent(String.self, forKey: .imageUrl)
+    }
+}
+
+struct F1ReplayGroup: Decodable, Identifiable, Hashable {
+    var id: String { meetingKey }
+    let meetingKey: String
+    let title: String
+    let location: String?
+    let meetingNumber: Int?
+    let imageUrl: String?
+    let latestStart: String?
+    let sessions: [ScheduleEvent]
+
+    enum CodingKeys: String, CodingKey {
+        case meetingKey, title, location, meetingNumber, imageUrl, latestStart, sessions
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        meetingKey = try decodeFlexibleString(c, forKey: .meetingKey)
+        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
+        location = try c.decodeIfPresent(String.self, forKey: .location)
+        meetingNumber = try? c.decodeIfPresent(Int.self, forKey: .meetingNumber)
+        imageUrl = try c.decodeIfPresent(String.self, forKey: .imageUrl)
+        latestStart = try c.decodeIfPresent(String.self, forKey: .latestStart)
+        sessions = try c.decodeIfPresent([ScheduleEvent].self, forKey: .sessions) ?? []
+    }
+}
+
+struct F1HubPayload: Decodable {
+    let live: [ScheduleEvent]
+    let upcoming: [ScheduleEvent]
+    let recentReplays: [ScheduleEvent]
+    let replayGroups: [F1ReplayGroup]
+    let meetings: [F1Meeting]
+    let nextMeeting: F1Meeting?
+
+    enum CodingKeys: String, CodingKey {
+        case live, upcoming, recentReplays, replayGroups, meetings, nextMeeting
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
+        upcoming = try c.decodeIfPresent([ScheduleEvent].self, forKey: .upcoming) ?? []
+        recentReplays = try c.decodeIfPresent([ScheduleEvent].self, forKey: .recentReplays) ?? []
+        replayGroups = try c.decodeIfPresent([F1ReplayGroup].self, forKey: .replayGroups) ?? []
+        meetings = try c.decodeIfPresent([F1Meeting].self, forKey: .meetings) ?? []
+        nextMeeting = try c.decodeIfPresent(F1Meeting.self, forKey: .nextMeeting)
+    }
+}
+
+struct F1MeetingDetail: Decodable {
+    let meeting: F1Meeting?
+    let sessions: [ScheduleEvent]
+    let replays: [ScheduleEvent]
+    let upcoming: [ScheduleEvent]
+    let live: [ScheduleEvent]
+
+    enum CodingKeys: String, CodingKey {
+        case meeting, sessions, replays, upcoming, live
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        meeting = try c.decodeIfPresent(F1Meeting.self, forKey: .meeting)
+        sessions = try c.decodeIfPresent([ScheduleEvent].self, forKey: .sessions) ?? []
+        replays = try c.decodeIfPresent([ScheduleEvent].self, forKey: .replays) ?? []
+        upcoming = try c.decodeIfPresent([ScheduleEvent].self, forKey: .upcoming) ?? []
+        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
+    }
+}
+
+struct ViaplaySport: Decodable, Identifiable, Hashable {
+    let id: String
+    let label: String
+    let count: Int?
+}
+
+struct ViaplayHubItem: Decodable, Identifiable, Hashable {
+    let id: String
+    let guid: String
+    let title: String
+    let subtitle: String?
+    let imageUrl: String?
+    let kind: String?
+    let openAs: String?
+    let playable: Bool?
+    let durationLabel: String?
+    let start: String?
+    let badge: String?
+    let pageUrl: String?
+
+    var opensAsEvent: Bool { (openAs ?? "").lowercased() == "event" }
+}
+
+struct ViaplayHubRail: Decodable, Identifiable, Hashable {
+    let id: String
+    let title: String
+    let items: [ViaplayHubItem]
+
+    enum CodingKeys: String, CodingKey { case id, title, items }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        id = try c.decode(String.self, forKey: .id)
+        title = try c.decodeIfPresent(String.self, forKey: .title) ?? ""
+        items = (try? c.decodeIfPresent([ViaplayHubItem].self, forKey: .items)) ?? []
+    }
+}
+
+struct ViaplayHubPayload: Decodable {
+    let live: [ScheduleEvent]
+    let today: [ScheduleEvent]
+    let weekend: [ScheduleEvent]
+    let later: [ScheduleEvent]
+    let catchup: [ScheduleEvent]
+    let sports: [ViaplaySport]
+    let events: [ScheduleEvent]
+    let rails: [ViaplayHubRail]
+
+    enum CodingKeys: String, CodingKey {
+        case live, today, weekend, later, catchup, sports, events, rails
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        live = try c.decodeIfPresent([ScheduleEvent].self, forKey: .live) ?? []
+        today = try c.decodeIfPresent([ScheduleEvent].self, forKey: .today) ?? []
+        weekend = try c.decodeIfPresent([ScheduleEvent].self, forKey: .weekend) ?? []
+        later = try c.decodeIfPresent([ScheduleEvent].self, forKey: .later) ?? []
+        catchup = try c.decodeIfPresent([ScheduleEvent].self, forKey: .catchup) ?? []
+        sports = try c.decodeIfPresent([ViaplaySport].self, forKey: .sports) ?? []
+        events = try c.decodeIfPresent([ScheduleEvent].self, forKey: .events) ?? []
+        rails = try c.decodeIfPresent([ViaplayHubRail].self, forKey: .rails) ?? []
+    }
+}
+

apps/ios/VMC/Playback/AVLivePlayerController.swift

@@ -21,6 +21,8 @@ final class AVLivePlayerController: NSObject, ObservableObject {
     @Published var subtitleOptions: [AVMediaOptionItem] = []
     @Published var currentAudioId: String?
     @Published var currentSubtitleId: String?
+    /// True zodra we minstens één keer echt speelden — timeout mag dan niet meer afbreken.
+    private var everPlayed = false
 
     let player = AVPlayer()
     private var proxySession = 0
@@ -53,6 +55,7 @@ final class AVLivePlayerController: NSObject, ObservableObject {
         hasError = false
         errorMessage = nil
         hasVideo = false
+        everPlayed = false
         audioOptions = []
         subtitleOptions = []
         currentAudioId = nil
@@ -130,11 +133,25 @@ final class AVLivePlayerController: NSObject, ObservableObject {
     }
 
     func refreshMediaOptions() {
+        // ClearKey live: sporen uit de proxy (niet HLS multi-rendition — dat gaf -12312).
+        let tracks = ClearKeyDashProxy.shared.availableAudioTracks()
+        if !tracks.isEmpty {
+            audioOptions = tracks.map { AVMediaOptionItem(id: $0.id, name: $0.name) }
+            currentAudioId = ClearKeyDashProxy.shared.preferredAudioId ?? tracks.first?.id
+        }
         guard let item = player.currentItem else { return }
         Task { await loadMediaOptions(for: item) }
     }
 
     func selectAudio(id: String) {
+        // Proxy-spoor wisselen + item herladen (geen seamless HLS AUDIO switch).
+        if ClearKeyDashProxy.shared.setPreferredAudio(id: id) {
+            currentAudioId = id
+            hasError = false
+            errorMessage = nil
+            Task { await reloadCurrentItemKeepingProxy() }
+            return
+        }
         guard let item = player.currentItem, let group = audioGroup,
               let option = audioOptionById[id] else { return }
         item.select(option, in: group)
@@ -152,6 +169,15 @@ final class AVLivePlayerController: NSObject, ObservableObject {
         }
     }
 
+    /// Herlaad dezelfde lokale HLS-URL na audio-wissel zonder proxy te stoppen.
+    private func reloadCurrentItemKeepingProxy() async {
+        guard let asset = player.currentItem?.asset as? AVURLAsset else { return }
+        let url = asset.url
+        let gen = generation
+        stateText = "Audio wisselen…"
+        await startItem(url: url, gen: gen)
+    }
+
     // MARK: - Private
 
     private func startItem(url: URL, gen: Int) async {
@@ -162,7 +188,7 @@ final class AVLivePlayerController: NSObject, ObservableObject {
             AVURLAssetAllowsConstrainedNetworkAccessKey: true,
         ])
         let item = AVPlayerItem(asset: asset)
-        item.preferredForwardBufferDuration = 8
+        item.preferredForwardBufferDuration = 6
         clearObservers()
 
         itemStatusObs = item.observe(\.status, options: [.new, .initial]) { [weak self] item, _ in
@@ -173,8 +199,10 @@ final class AVLivePlayerController: NSObject, ObservableObject {
                     self.stateText = "Afspelen"
                     self.hasError = false
                     self.refreshHasVideo(from: item)
-                    await self.loadMediaOptions(for: item)
+                    // Eerst play — loadMediaOptions mag start niet blokkeren (Prime/HBO voelde traag).
                     self.player.play()
+                    self.everPlayed = true
+                    await self.loadMediaOptions(for: item)
                 case .failed:
                     self.fail(from: item.error, gen: gen)
                 default:
@@ -189,6 +217,7 @@ final class AVLivePlayerController: NSObject, ObservableObject {
                 switch player.timeControlStatus {
                 case .playing:
                     self.isPlaying = true
+                    self.everPlayed = true
                     self.stateText = "Afspelen"
                     self.hasError = false
                     if let item = player.currentItem {
@@ -196,7 +225,8 @@ final class AVLivePlayerController: NSObject, ObservableObject {
                     }
                 case .waitingToPlayAtSpecifiedRate:
                     self.isPlaying = false
-                    self.stateText = "Bufferen…"
+                    // Na first-play: bufferen is normaal — geen "Fout"-timeout.
+                    self.stateText = self.everPlayed ? "Bufferen…" : "Bufferen…"
                 case .paused:
                     self.isPlaying = false
                     if !self.hasError { self.stateText = "Pauze" }
@@ -228,6 +258,8 @@ final class AVLivePlayerController: NSObject, ObservableObject {
                 if let events = item.errorLog()?.events, let last = events.last {
                     let comment = last.errorComment ?? last.errorDomain
                     self.proxyLogState("AV errorLog: \(last.errorStatusCode) \(comment ?? "")")
+                    // -12312 bij audio-wissel: niet meteen als fatale UI-fout tonen.
+                    if last.errorStatusCode == -12312 { return }
                 }
             }
         }
@@ -236,20 +268,21 @@ final class AVLivePlayerController: NSObject, ObservableObject {
         player.automaticallyWaitsToMinimizeStalling = true
         player.play()
 
-        // Timeout alleen als er NOG NIETS speelt — nooit een werkende stream afbreken.
+        // Timeout alleen als er NOOIT iets speelde — nooit een werkende/bufferende stream afbreken.
         Task { @MainActor in
-            try? await Task.sleep(nanoseconds: 15_000_000_000)
+            try? await Task.sleep(nanoseconds: 20_000_000_000)
             guard self.generation == gen, !self.stopping else { return }
             if let item = self.player.currentItem {
                 self.refreshHasVideo(from: item)
             }
-            if !self.isPlaying && !self.hasError {
+            if self.everPlayed || self.isPlaying { return }
+            if !self.hasError {
                 if let err = item.error {
                     self.fail(from: err, gen: gen)
                 } else {
                     self.hasError = true
                     self.errorMessage = self.bestErrorMessage(for: item)
-                        ?? "Stream opende niet binnen 15s (ClearKey/HLS)."
+                        ?? "Stream opende niet binnen 20s (ClearKey/HLS)."
                     self.stateText = "Fout"
                 }
             }
@@ -270,28 +303,36 @@ final class AVLivePlayerController: NSObject, ObservableObject {
     private func loadMediaOptions(for item: AVPlayerItem) async {
         let asset = item.asset
         do {
-            let audible = try await asset.loadMediaSelectionGroup(for: .audible)
+            let proxyTracks = ClearKeyDashProxy.shared.availableAudioTracks()
-            audioGroup = audible
+            if !proxyTracks.isEmpty {
-            if let audible {
+                audioOptions = proxyTracks.map { AVMediaOptionItem(id: $0.id, name: $0.name) }
-                var opts: [AVMediaOptionItem] = []
-                var map: [String: AVMediaSelectionOption] = [:]
-                for (i, opt) in audible.options.enumerated() {
-                    let id = "a-\(i)-\(opt.displayName)"
-                    let name = opt.displayName.isEmpty ? "Audio \(i + 1)" : opt.displayName
-                    opts.append(AVMediaOptionItem(id: id, name: name))
-                    map[id] = opt
-                }
-                audioOptions = opts
-                audioOptionById = map
-                if let selected = item.selectedMediaOption(in: audible),
-                   let match = map.first(where: { $0.value == selected })?.key {
-                    currentAudioId = match
-                } else {
-                    currentAudioId = opts.first?.id
-                }
-            } else {
-                audioOptions = []
                 audioOptionById = [:]
+                audioGroup = nil
+                currentAudioId = ClearKeyDashProxy.shared.preferredAudioId ?? proxyTracks.first?.id
+            } else {
+                let audible = try await asset.loadMediaSelectionGroup(for: .audible)
+                audioGroup = audible
+                if let audible {
+                    var opts: [AVMediaOptionItem] = []
+                    var map: [String: AVMediaSelectionOption] = [:]
+                    for (i, opt) in audible.options.enumerated() {
+                        let id = "a-\(i)-\(opt.displayName)"
+                        let name = opt.displayName.isEmpty ? "Audio \(i + 1)" : opt.displayName
+                        opts.append(AVMediaOptionItem(id: id, name: name))
+                        map[id] = opt
+                    }
+                    audioOptions = opts
+                    audioOptionById = map
+                    if let selected = item.selectedMediaOption(in: audible),
+                       let match = map.first(where: { $0.value == selected })?.key {
+                        currentAudioId = match
+                    } else {
+                        currentAudioId = opts.first?.id
+                    }
+                } else {
+                    audioOptions = []
+                    audioOptionById = [:]
+                }
             }
 
             let legible = try await asset.loadMediaSelectionGroup(for: .legible)
@@ -325,6 +366,12 @@ final class AVLivePlayerController: NSObject, ObservableObject {
 
     private func fail(from error: Error?, gen: Int) {
         guard generation == gen, !stopping else { return }
+        let ns = (error as NSError?)
+        // Playlist-mismatch tijdens live/audio-wissel — negeren als we nog (opnieuw) laden.
+        if let ns, ns.domain == "CoreMediaErrorDomain", ns.code == -12312 {
+            proxyLogState("ignore -12312: \(ns.localizedDescription)")
+            return
+        }
         hasError = true
         if let error {
             errorMessage = dutchAVError(error)
@@ -333,13 +380,24 @@ final class AVLivePlayerController: NSObject, ObservableObject {
         } else {
             errorMessage = "Kon stream niet openen"
         }
+        // Toon geen -12312 als enige melding.
+        if let msg = errorMessage, msg.contains("-12312") {
+            errorMessage = nil
+            hasError = false
+            return
+        }
         stateText = "Fout"
         isPlaying = false
     }
 
     private func bestErrorMessage(for item: AVPlayerItem) -> String? {
-        if let err = item.error { return dutchAVError(err) }
+        if let err = item.error {
+            let ns = err as NSError
+            if ns.domain == "CoreMediaErrorDomain", ns.code == -12312 { return nil }
+            return dutchAVError(err)
+        }
         if let events = item.errorLog()?.events, let last = events.last {
+            if last.errorStatusCode == -12312 { return nil }
             let code = last.errorStatusCode
             let comment = last.errorComment ?? last.errorDomain
             return "Afspeelfout (\(code)): \(comment)"
@@ -394,24 +452,55 @@ final class AVLivePlayerController: NSObject, ObservableObject {
     }
 }
 
-struct AVLivePlayerView: UIViewControllerRepresentable {
+/// AVPlayerLayer i.p.v. AVPlayerViewController:
+/// - schaalt mee bij rotatie zonder seek/rebind (geen haperen)
+/// - voorkomt ESPN “alleen audio” na landscape (AVPlayerViewController-compositor-bug)
+struct AVLivePlayerView: UIViewRepresentable {
     let controller: AVLivePlayerController
 
-    func makeUIViewController(context: Context) -> AVPlayerViewController {
+    func makeUIView(context: Context) -> AVLivePlayerLayerView {
-        let vc = AVPlayerViewController()
+        let view = AVLivePlayerLayerView()
-        vc.player = controller.player
+        view.player = controller.player
-        vc.showsPlaybackControls = false
+        return view
-        vc.videoGravity = .resizeAspect
-        vc.allowsPictureInPicturePlayback = true
-        if #available(iOS 14.2, *) {
-            vc.canStartPictureInPictureAutomaticallyFromInline = true
-        }
-        return vc
     }
 
-    func updateUIViewController(_ vc: AVPlayerViewController, context: Context) {
+    func updateUIView(_ uiView: AVLivePlayerLayerView, context: Context) {
-        if vc.player !== controller.player {
+        if uiView.player !== controller.player {
-            vc.player = controller.player
+            uiView.player = controller.player
         }
     }
+
+    static func dismantleUIView(_ uiView: AVLivePlayerLayerView, coordinator: ()) {
+        uiView.player = nil
+    }
+}
+
+final class AVLivePlayerLayerView: UIView {
+    override class var layerClass: AnyClass { AVPlayerLayer.self }
+
+    private var playerLayer: AVPlayerLayer { layer as! AVPlayerLayer }
+
+    var player: AVPlayer? {
+        get { playerLayer.player }
+        set {
+            playerLayer.player = newValue
+            playerLayer.videoGravity = .resizeAspect
+        }
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .black
+        isUserInteractionEnabled = false
+        playerLayer.videoGravity = .resizeAspect
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        playerLayer.frame = bounds
+    }
 }

apps/ios/VMC/Playback/AesCtr.swift

@@ -51,7 +51,11 @@ enum AesCtr {
         return out
     }
 
-    /// CBCS pattern: decrypt `crypt` 16-byte blocks, skip `skip` blocks; leftover <16 clear.
+    /// CBCS pattern decrypt — gelijk aan Chromium `DecryptWithPattern` (ISO 23001-7 §10.4):
+    /// - IV wordt één keer gezet per protected range (subsample), niet per pattern.
+    /// - Crypt-blokken vormen één CBC-keten; skip-blokken blijven clear en updaten de IV niet.
+    /// - Pattern 0:0 = alle volle blokken encrypted (geen pattern).
+    /// - Partiële trailing bytes blijven clear.
     static func cryptCbcs(
         key: Data,
         iv: Data,
@@ -60,31 +64,59 @@ enum AesCtr {
         skipByteBlock: Int
     ) -> Data? {
         guard key.count == 16 else { return nil }
-        if cryptByteBlock <= 0 {
+        if data.isEmpty { return data }
-            return data
-        }
-        let cryptLen = 16 * cryptByteBlock
-        let skipLen = 16 * max(skipByteBlock, 0)
-        var result = data
-        var offset = 0
-        var blockIv = Data(count: 16)
-        let ivCopy = min(iv.count, 16)
-        blockIv.replaceSubrange(0..<ivCopy, with: iv.prefix(ivCopy))
 
-        while offset < result.count {
+        let blockSize = 16
-            let remaining = result.count - offset
+        let totalBlocks = data.count / blockSize
-            if remaining < cryptLen { break }
+        guard totalBlocks > 0 else { return data }
-            let slice = result.subdata(in: offset..<(offset + cryptLen))
+
-            guard let plain = aesCbcDecryptNoPad(key: key, iv: blockIv, data: slice) else { return nil }
+        var cryptBlocks = cryptByteBlock
-            result.replaceSubrange(offset..<(offset + cryptLen), with: plain)
+        var skipBlocks = skipByteBlock
-            // Next IV = last ciphertext block (CBC chain within crypt run).
+        // ISO/Chromium: 0:0 → alles encrypted als één CBC-run.
-            blockIv = slice.suffix(16)
+        if cryptBlocks == 0 && skipBlocks == 0 {
-            offset += cryptLen
+            cryptBlocks = totalBlocks
-            let skip = min(skipLen, result.count - offset)
+            skipBlocks = 0
-            offset += skip
-            // Pattern: IV resets per subsample in caller; within subsample after skip, continue with updated IV.
         }
-        return result
+        if cryptBlocks <= 0 { return data }
+
+        var out = data
+        var blockIv = Data(count: 16)
+        let ivn = min(iv.count, 16)
+        blockIv.replaceSubrange(0..<ivn, with: iv.prefix(ivn))
+
+        var blocksProcessed = 0
+        var offset = 0
+        // Chromium: start met encrypted run (toggle van false → true).
+        var isCryptRun = false
+
+        while blocksProcessed < totalBlocks {
+            isCryptRun = !isCryptRun
+            let runSize = isCryptRun ? cryptBlocks : skipBlocks
+            if runSize == 0 { continue }
+
+            let blocksToProcess = min(runSize, totalBlocks - blocksProcessed)
+            if blocksToProcess == 0 { continue }
+
+            let byteCount = blocksToProcess * blockSize
+            let range = offset..<(offset + byteCount)
+
+            if isCryptRun {
+                let cipher = out.subdata(in: range)
+                guard let plain = aesCbcDecryptNoPad(key: key, iv: blockIv, data: cipher) else {
+                    return nil
+                }
+                out.replaceSubrange(range, with: plain)
+                // CBC-keten over crypt-runs: IV = laatste ciphertext-blok.
+                if cipher.count >= blockSize {
+                    blockIv.replaceSubrange(0..<blockSize, with: cipher.suffix(blockSize))
+                }
+            }
+            // Skip-run: clear laten; IV niet aanpassen.
+
+            offset += byteCount
+            blocksProcessed += blocksToProcess
+        }
+        return out
     }
 
     private static func aesCbcDecryptNoPad(key: Data, iv: Data, data: Data) -> Data? {

apps/ios/VMC/Playback/CencMp4Decryptor.swift

@@ -16,9 +16,31 @@ enum CencMp4Decryptor {
         var fallback: TrackCrypto?
     }
 
+    /// Diagnose-hook (alleen aanroepen onder de crypto-lock van de proxy).
+    static var diagTag = ""
+    static var diagSink: ((String) -> Void)?
+    private static var diagCounts: [String: Int] = [:]
+
+    private static func diag(_ message: @autoclosure () -> String) {
+        guard let sink = diagSink else { return }
+        let n = diagCounts[diagTag, default: 0]
+        guard n < 8 else { return }
+        diagCounts[diagTag] = n + 1
+        sink("decrypt[\(diagTag)] \(message())")
+    }
+
+    static func resetDiag() {
+        diagCounts.removeAll()
+    }
+
+    private static func hex(_ d: Data) -> String {
+        d.map { String(format: "%02x", $0) }.joined()
+    }
+
     @discardableResult
     static func process(data: inout Data, keys: ClearKeyKeyMap, state: inout SessionState) -> Bool {
         guard !data.isEmpty, !keys.isEmpty else { return false }
+        // Nooit crashen op corrupte segmenten — liever ongedecrypt doorgeven dan app-kill.
         var touched = false
         if containsBox(data, type: "moov") {
             harvestAndClearInit(&data, keys: keys, state: &state)
@@ -67,19 +89,45 @@ enum CencMp4Decryptor {
         let containers: Set<String> = [
             "moov", "trak", "mdia", "minf", "stbl", "moof", "traf",
             "mvex", "edts", "sinf", "schi", "dinf", "udta", "meta",
+            // Sample-entries bevatten sinf/avcC; stsd is FullBox met entry_count.
+            "stsd", "dref",
+            "encv", "enca",
+            "avc1", "avc3", "hev1", "hvc1", "dvh1", "mp4a",
         ]
         while offset + 8 <= to {
             guard let box = readBox(data, at: offset, limit: to) else { break }
             let cont = visit(box)
             if !cont { return }
             if recursive, containers.contains(box.type), box.payloadLength > 0 {
-                walk(data, from: box.payloadStart, to: box.payloadEnd, recursive: true, visit: visit)
+                let childFrom = walkChildrenStart(box)
+                if childFrom < box.payloadEnd {
+                    walk(data, from: childFrom, to: box.payloadEnd, recursive: true, visit: visit)
+                }
             }
             offset = box.payloadEnd
             if box.size <= 0 { break }
         }
     }
 
+    /// Skip FullBox / SampleEntry vaste headers zodat child-boxes (sinf, tenc, avcC) bereikbaar zijn.
+    private static func walkChildrenStart(_ box: Box) -> Int {
+        switch box.type {
+        case "stsd", "dref":
+            // FullBox (4) + entry_count (4)
+            return box.payloadStart + 8
+        case "meta":
+            return box.payloadStart + 4
+        case "encv", "avc1", "avc3", "hev1", "hvc1", "dvh1":
+            // VisualSampleEntry: boxhdr(8) + SampleEntry(8) + visual(70) = 86
+            return box.start + 86
+        case "enca", "mp4a":
+            // AudioSampleEntry: boxhdr(8) + SampleEntry(8) + audio(20) = 36
+            return box.start + 36
+        default:
+            return box.payloadStart
+        }
+    }
+
     private static func readBox(_ data: Data, at offset: Int, limit: Int) -> Box? {
         guard offset + 8 <= limit else { return nil }
         var size = Int(readU32(data, offset))
@@ -98,19 +146,23 @@ enum CencMp4Decryptor {
     }
 
     private static func readU16(_ data: Data, _ o: Int) -> UInt16 {
-        UInt16(data[o]) << 8 | UInt16(data[o + 1])
+        guard o >= 0, o + 2 <= data.count else { return 0 }
+        return UInt16(data[o]) << 8 | UInt16(data[o + 1])
     }
 
     private static func readU32(_ data: Data, _ o: Int) -> UInt32 {
-        UInt32(data[o]) << 24 | UInt32(data[o + 1]) << 16 | UInt32(data[o + 2]) << 8 | UInt32(data[o + 3])
+        guard o >= 0, o + 4 <= data.count else { return 0 }
+        return UInt32(data[o]) << 24 | UInt32(data[o + 1]) << 16 | UInt32(data[o + 2]) << 8 | UInt32(data[o + 3])
     }
 
     private static func readU64(_ data: Data, _ o: Int) -> UInt64 {
-        (UInt64(readU32(data, o)) << 32) | UInt64(readU32(data, o + 4))
+        guard o >= 0, o + 8 <= data.count else { return 0 }
+        return (UInt64(readU32(data, o)) << 32) | UInt64(readU32(data, o + 4))
     }
 
     private static func readFourCC(_ data: Data, _ o: Int) -> String {
-        String(bytes: data[o..<(o + 4)], encoding: .ascii) ?? "????"
+        guard o >= 0, o + 4 <= data.count else { return "????" }
+        return String(bytes: data[o..<(o + 4)], encoding: .ascii) ?? "????"
     }
 
     private static func writeFourCC(_ data: inout Data, _ o: Int, _ s: String) {
@@ -122,6 +174,10 @@ enum CencMp4Decryptor {
     // MARK: - Init segment
 
     private static func harvestAndClearInit(_ data: inout Data, keys: ClearKeyKeyMap, state: inout SessionState) {
+        // Elke init is de bron van waarheid voor deze lane (CMAF track_ID is vaak 1 voor A én V).
+        state.byTrackId.removeAll(keepingCapacity: true)
+        state.fallback = nil
+
         // Track id from tkhd, crypto from sinf/tenc/frma/schm inside same trak.
         for trak in findBoxes(data, type: "trak", recursive: true) {
             var trackId: UInt32?
@@ -218,11 +274,19 @@ enum CencMp4Decryptor {
             }
 
             if let crypto {
+                diag("init track=\(trackId ?? 0) fmt=\(originalFormat ?? "-") scheme=\(crypto.scheme) pat=\(crypto.cryptByteBlock):\(crypto.skipByteBlock) iv=\(crypto.perSampleIvSize) civ=\(crypto.constantIv?.count ?? 0) kid=\(hex(crypto.kid)) exact=\(keys.hasExactKey(forKid: crypto.kid)) keys=\(keys.uniqueKeyCount)")
                 if let trackId {
                     state.byTrackId[trackId] = crypto
                 }
-                state.fallback = crypto
+                // Fallback: prefer video-achtige crypto (cbcs / pattern) boven pure audio-cenc.
+                let looksVideo = crypto.scheme == "cbcs" || crypto.scheme == "cbc1"
+                    || crypto.cryptByteBlock > 0 || crypto.constantIv != nil
+                if state.fallback == nil || looksVideo {
+                    state.fallback = crypto
+                }
                 _ = keys.key(forKid: crypto.kid)
+            } else {
+                diag("init track=\(trackId ?? 0) fmt=\(originalFormat ?? "-") clear (geen tenc)")
             }
         }
     }
@@ -272,10 +336,16 @@ enum CencMp4Decryptor {
             var dataOffsetPresent = false
             var sampleSizes: [Int] = []
             var sencSamples: [SencSample] = []
-            var perSampleIvSize = state.fallback?.perSampleIvSize ?? 8
+            var perSampleIvSize = 8
+            var tfhdFlagsSeen: UInt32 = 0
+            var trunFlagsSeen: UInt32 = 0
+            if let known = state.byTrackId.values.first, state.byTrackId.count == 1 {
+                perSampleIvSize = known.perSampleIvSize
+            }
 
             // tfhd
             for tfhd in findBoxesInRange(data, type: "tfhd", from: traf.payloadStart, to: traf.payloadEnd) {
+                guard tfhd.payloadLength >= 8 else { continue }
                 let versionFlags = readU32(data, tfhd.payloadStart)
                 let flags = versionFlags & 0x00FF_FFFF
                 var o = tfhd.payloadStart + 4
@@ -284,42 +354,65 @@ enum CencMp4Decryptor {
                     perSampleIvSize = crypto.perSampleIvSize
                 }
                 if flags & 0x000001 != 0 { // base-data-offset
+                    guard o + 8 <= tfhd.payloadEnd else { break }
                     baseDataOffset = Int64(readU64(data, o)); o += 8
                     dataOffsetPresent = true
                 }
-                if flags & 0x000002 != 0 { o += 4 } // sample-description-index
+                if flags & 0x000002 != 0 { // sample-description-index
-                if flags & 0x000008 != 0 {
+                    guard o + 4 <= tfhd.payloadEnd else { break }
+                    o += 4
+                }
+                if flags & 0x000008 != 0 { // default-sample-duration
+                    guard o + 4 <= tfhd.payloadEnd else { break }
+                    o += 4
+                }
+                if flags & 0x000010 != 0 { // default-sample-size
+                    guard o + 4 <= tfhd.payloadEnd else { break }
                     defaultSampleSize = readU32(data, o); o += 4
                 }
+                tfhdFlagsSeen = flags
                 _ = versionFlags
             }
 
             // trun
             for trun in findBoxesInRange(data, type: "trun", from: traf.payloadStart, to: traf.payloadEnd) {
+                guard trun.payloadLength >= 8 else { continue }
                 let versionFlags = readU32(data, trun.payloadStart)
                 let version = Int(versionFlags >> 24)
                 let flags = versionFlags & 0x00FF_FFFF
+                trunFlagsSeen = flags
                 var o = trun.payloadStart + 4
                 let sampleCount = Int(readU32(data, o)); o += 4
+                guard sampleCount >= 0, sampleCount < 100_000 else { continue }
                 var dataOffset: Int32 = 0
                 if flags & 0x000001 != 0 {
+                    guard o + 4 <= trun.payloadEnd else { break }
                     dataOffset = Int32(bitPattern: readU32(data, o)); o += 4
                     dataOffsetPresent = true
                 }
-                if flags & 0x000004 != 0 { o += 4 } // first-sample-flags
+                if flags & 0x000004 != 0 {
+                    guard o + 4 <= trun.payloadEnd else { break }
+                    o += 4
+                }
                 sampleSizes.removeAll(keepingCapacity: true)
                 for _ in 0..<sampleCount {
-                    if flags & 0x000100 != 0 { // sample-duration
+                    if flags & 0x000100 != 0 {
+                        guard o + 4 <= trun.payloadEnd else { break }
                         o += 4
                     }
                     var size = Int(defaultSampleSize)
                     if flags & 0x000200 != 0 {
+                        guard o + 4 <= trun.payloadEnd else { break }
                         size = Int(readU32(data, o)); o += 4
                     }
-                    sampleSizes.append(size)
+                    sampleSizes.append(max(0, size))
-                    if flags & 0x000400 != 0 { o += 4 } // sample-flags
+                    if flags & 0x000400 != 0 {
+                        guard o + 4 <= trun.payloadEnd else { break }
+                        o += 4
+                    }
                     if flags & 0x000800 != 0 {
-                        o += version == 0 ? 4 : 4 // sample-composition-time-offset
+                        guard o + 4 <= trun.payloadEnd else { break }
+                        o += 4
                     }
                 }
                 if dataOffsetPresent {
@@ -340,8 +433,10 @@ enum CencMp4Decryptor {
                 _ = version
             }
 
-            // senc
+            // Prefer track-crypto uit DÉZE lane. Fallback alleen binnen dezelfde lane.
-            let crypto = state.byTrackId[trackId] ?? state.fallback
+            let crypto: TrackCrypto? = state.byTrackId[trackId]
+                ?? (state.byTrackId.count == 1 ? state.byTrackId.values.first : nil)
+                ?? state.fallback
             if let crypto {
                 perSampleIvSize = crypto.perSampleIvSize
             }
@@ -361,17 +456,24 @@ enum CencMp4Decryptor {
                 )
             }
 
-            guard !sampleSizes.isEmpty, sencSamples.count == sampleSizes.count || sencSamples.isEmpty == false else {
+            // cbcs audio (F1TV): tenc heeft constant_IV + iv_size=0, fragmenten hebben géén senc.
+            // ISO 23001-7: elk sample ontsleutelen met die IV (geen per-sample IV, geen subsample).
+            let constantIv = crypto?.constantIv
+            let canUseConstantIv = (constantIv?.count ?? 0) >= 8
+            guard !sampleSizes.isEmpty, !sencSamples.isEmpty || canUseConstantIv else {
+                diag("frag track=\(trackId) skip: samples=\(sampleSizes.count) senc=\(sencSamples.count) tfhd=0x\(String(tfhdFlagsSeen, radix: 16)) trun=0x\(String(trunFlagsSeen, radix: 16))")
                 // Advance cursor even if we cannot decrypt.
                 for sz in sampleSizes { mdatCursor += sz }
                 continue
             }
 
+            // Exacte KID-match, anders primaryKey als er maar één key is.
             let key: Data? = {
-                if let crypto, let k = keys.key(forKid: crypto.kid) { return k }
+                guard let crypto else { return keys.primaryKey }
-                return keys.primaryKey
+                return keys.key(forKid: crypto.kid)
             }()
             guard let key else {
+                diag("frag track=\(trackId) skip: geen key (kid=\(crypto.map { hex($0.kid) } ?? "-") keys=\(keys.uniqueKeyCount))")
                 for sz in sampleSizes { mdatCursor += sz }
                 continue
             }
@@ -380,28 +482,38 @@ enum CencMp4Decryptor {
             let cryptBlocks = crypto?.cryptByteBlock ?? 0
             let skipBlocks = crypto?.skipByteBlock ?? 0
 
+            var decryptedCount = 0
             for i in 0..<sampleSizes.count {
                 let size = sampleSizes[i]
                 guard size > 0, mdatCursor + size <= data.count else { break }
                 let sampleRange = mdatCursor..<(mdatCursor + size)
                 var sample = data.subdata(in: sampleRange)
                 let senc = i < sencSamples.count ? sencSamples[i] : nil
-                if let senc {
+                let iv = senc?.iv ?? constantIv
+                if let iv {
                     if let decrypted = decryptSample(
                         sample,
                         key: key,
-                        iv: senc.iv,
+                        iv: iv,
-                        subsamples: senc.subsamples,
+                        subsamples: senc?.subsamples,
                         scheme: scheme,
                         cryptByteBlock: cryptBlocks,
                         skipByteBlock: skipBlocks
                     ) {
                         sample = decrypted
                         data.replaceSubrange(sampleRange, with: sample)
+                        decryptedCount += 1
                     }
                 }
                 mdatCursor += size
             }
+            diag("frag track=\(trackId) crypto=\(crypto != nil) scheme=\(scheme) pat=\(cryptBlocks):\(skipBlocks) samples=\(sampleSizes.count) senc=\(sencSamples.count) iv=\(sencSamples.first?.iv.count ?? 0) subs=\(sencSamples.first?.subsamples?.count ?? -1) size0=\(sampleSizes.first ?? 0) dec=\(decryptedCount) tfhd=0x\(String(tfhdFlagsSeen, radix: 16)) trun=0x\(String(trunFlagsSeen, radix: 16)) mdat=\(mdat.payloadLength)")
+            // AVPlayer/VLC mogen geen tweede decrypt-poging doen op clear samples.
+            if decryptedCount > 0 {
+                for senc in findBoxesInRange(data, type: "senc", from: traf.payloadStart, to: traf.payloadEnd) {
+                    writeFourCC(&data, senc.start + 4, "free")
+                }
+            }
         }
     }
 
@@ -466,11 +578,17 @@ enum CencMp4Decryptor {
 
         let saizFlags = readU32(data, saiz.payloadStart) & 0x00FF_FFFF
         var o = saiz.payloadStart + 4
-        if saizFlags & 0x1 != 0 { o += 8 } // aux_info_type + parameter
+        if saizFlags & 0x1 != 0 {
+            guard o + 8 <= saiz.payloadEnd else { return [] }
+            o += 8
+        }
+        guard o + 5 <= saiz.payloadEnd else { return [] }
         let defaultSize = Int(data[o]); o += 1
         let count = Int(readU32(data, o)); o += 4
+        guard count >= 0, count < 100_000 else { return [] }
         var sizes: [Int] = []
         if defaultSize == 0 {
+            guard o + count <= saiz.payloadEnd else { return [] }
             for _ in 0..<count {
                 sizes.append(Int(data[o])); o += 1
             }
@@ -545,7 +663,7 @@ enum CencMp4Decryptor {
                 key: key,
                 iv: iv,
                 subsamples: subsamples,
-                cryptByteBlock: max(cryptByteBlock, 1),
+                cryptByteBlock: cryptByteBlock,
                 skipByteBlock: skipByteBlock
             )
         }
@@ -576,6 +694,7 @@ enum CencMp4Decryptor {
         cryptByteBlock: Int,
         skipByteBlock: Int
     ) -> Data? {
+        // Per subsample: IV reset (Chromium/ISO). Pattern chaint binnen de protected range.
         var out = sample
         if let subsamples {
             var cursor = 0
@@ -609,17 +728,23 @@ enum CencMp4Decryptor {
         sampleCount: Int,
         subsamples: [(clear: Int, protected: Int)]?
     ) -> [Range<Int>]? {
+        guard sampleCount > 0 else { return nil }
         guard let subsamples else {
             return [0..<sampleCount]
         }
         var ranges: [Range<Int>] = []
         var cursor = 0
         for sub in subsamples {
-            cursor += sub.clear
+            cursor += max(0, sub.clear)
-            if sub.protected > 0 {
+            let prot = max(0, sub.protected)
-                ranges.append(cursor..<(cursor + sub.protected))
+            if prot > 0 {
+                let end = min(cursor + prot, sampleCount)
+                if cursor < end {
+                    ranges.append(cursor..<end)
+                }
             }
-            cursor += sub.protected
+            cursor += prot
+            if cursor >= sampleCount { break }
         }
         return ranges
     }

apps/ios/VMC/Playback/ClearKeyDashProxy.swift

@@ -30,14 +30,17 @@ final class ClearKeyDashProxy {
     }
 
     private let queue = DispatchQueue(label: "nl.vonas.vmc.clearkey-proxy")
-    /// Beschermt alle gedeelde session-state. payload() draait concurrent via Task{} —
+    /// Beschermt alle gedeelde session-state. Recursive: mediaPlaylist → resolveTemplateURL
-    /// zonder deze lock → data races / EXC_BAD_ACCESS.
+    /// → withManifestQuery mag genest onder withState draaien (anders deadlock = app hangt).
-    private let stateLock = NSLock()
+    private let stateLock = NSRecursiveLock()
     private let cryptoLock = NSLock()
     private var listener: NWListener?
     private var port: UInt16 = 0
     private var remoteManifest: URL?
-    /// Auth-query van het manifest (bijv. Akamai hdnts) — plakken op relatieve segment-URLs.
+    /// Eind-URL na redirects (Odido: lb → edge-sessiepad). Segmenten resolven hiertegen en
+    /// refreshes blijven op deze URL, anders wisselt het sessiepad per refresh (403 / seq-breuk).
+    private var resolvedManifest: URL?
+    /// Auth-query van het manifest (bijv. Akamai `hdnts=…`) — plakken op relatieve segment-URLs.
     private var manifestQuery: String?
     private var keyMap: ClearKeyKeyMap?
     private var cryptoVideo = CencMp4Decryptor.SessionState()
@@ -54,12 +57,17 @@ final class ClearKeyDashProxy {
     /// Stabiele MEDIA-SEQUENCE per segment-URL (voorkomt AVPlayer -12312).
     private var segmentSeqByKey: [String: Int] = [:]
     private var nextStableSeq = 1
-    /// Laatste niet-lege media-playlist per pad (lege refresh → -12312).
+    /// Laatste niet-lege media-playlist per pad (lege refresh → -12312 / [].)
     private var lastMediaPlaylistByPath: [String: String] = [:]
-    /// Gedeelde MPD-snapshot zodat /hls/v.m3u8 en /hls/a.m3u8 dezelfde live-edge zien.
+    /// Gedeelde MPD-snapshot zodat /hls/v.m3u8 en /hls/a.m3u8 dezelfde live-edge zien
+    /// (anders A/V MEDIA-SEQUENCE-desync → stall na ~8–10s).
+    /// Som van EXTINF bij VOD/ENDLIST — VLC live-pad meldt anders duur 0 / niet-zoekbaar.
+    private var lastVodDurationMs: Int64 = 0
+    /// VLC kan HLS-cbcs via de proxy niet zoeken; we knippen de playlist vanaf dit punt.
+    private var playbackStartOffsetSec: Double = 0
     private var cachedMpdXML: String?
     private var cachedMpdAt: Date?
-    private let mpdCacheTTL: TimeInterval = 1.0
+    private let mpdCacheTTL: TimeInterval = 0.8
     private let urlSession: URLSession = {
         let cfg = URLSessionConfiguration.ephemeral
         cfg.timeoutIntervalForRequest = 15
@@ -70,6 +78,7 @@ final class ClearKeyDashProxy {
     }()
 
     /// Serialiseert alleen manifest/playlist-requests (niet segment-decrypt).
+    /// Voorheen alles via één gate → segmenten blokkeerden live-refresh → stall na ~10s + zware buffer.
     private let playlistGate = PayloadGate()
 
     private init() {}
@@ -95,6 +104,7 @@ final class ClearKeyDashProxy {
         let name: String
     }
 
+    /// Audio-sporen uit de huidige DASH-sessie (voor UI; niet via HLS multi-rendition).
     func availableAudioTracks() -> [ProxyAudioTrack] {
         withState {
             dashAudioReps.enumerated().map { i, a in
@@ -107,6 +117,7 @@ final class ClearKeyDashProxy {
         withState { dashAudioRep?.id }
     }
 
+    /// Wissel actief audio-spoor. Caller herlaadt AVPlayer-item (geen HLS rendition-switch).
     @discardableResult
     func setPreferredAudio(id: String) -> Bool {
         withState {
@@ -116,6 +127,7 @@ final class ClearKeyDashProxy {
             cryptoLock.lock()
             cryptoAudio = CencMp4Decryptor.SessionState()
             cryptoLock.unlock()
+            // Alleen audio-playlist-cache legen — video MEDIA-SEQUENCE niet resetten (crash/stotter).
             lastMediaPlaylistByPath["/hls/a.m3u8"] = nil
             proxyLog.info("preferred audio → \(match.id, privacy: .public)")
             return true
@@ -126,6 +138,18 @@ final class ClearKeyDashProxy {
     struct StartResult {
         let url: URL
         let session: Int
+        let vodDurationMs: Int64
+    }
+
+    func vodDurationMs() -> Int64 {
+        withState { lastVodDurationMs }
+    }
+
+    func setPlaybackStartOffset(ms: Int64) {
+        withState {
+            playbackStartOffsetSec = Double(max(0, ms)) / 1000.0
+            lastMediaPlaylistByPath = [:]
+        }
     }
 
     /// Start (of herstart) proxy voor dit manifest + keys. Geeft lokale MPD- of m3u8-URL terug.
@@ -143,27 +167,33 @@ final class ClearKeyDashProxy {
 
         let bound: (port: UInt16, session: Int) = try await withCheckedThrowingContinuation { cont in
             queue.async {
-                self.stopLocked()
+                self.withState {
-                self.remoteManifest = manifestURL
+                    self.stopLocked()
-                self.manifestQuery = URLComponents(url: manifestURL, resolvingAgainstBaseURL: false)?.percentEncodedQuery
+                    self.remoteManifest = manifestURL
-                self.keyMap = map
+                    self.resolvedManifest = nil
-                self.isHlsMode = hls
+                    self.manifestQuery = URLComponents(url: manifestURL, resolvingAgainstBaseURL: false)?.percentEncodedQuery
-                self.preferHlsOutput = preferHlsForAVPlayer
+                    self.keyMap = map
-                self.dashVideoRep = nil
+                    self.isHlsMode = hls
-                self.dashAudioRep = nil
+                    self.preferHlsOutput = preferHlsForAVPlayer
-                self.dashAudioReps = []
+                    self.dashVideoRep = nil
-                self.segmentSeqByKey = [:]
+                    self.dashAudioRep = nil
-                self.nextStableSeq = 1
+                    self.dashAudioReps = []
-                self.lastMediaPlaylistByPath = [:]
+                    self.segmentSeqByKey = [:]
-                self.cachedMpdXML = nil
+                    self.nextStableSeq = 1
-                self.cachedMpdAt = nil
+                    self.lastMediaPlaylistByPath = [:]
-                self.cryptoLock.lock()
+                    self.lastVodDurationMs = 0
-                self.cryptoVideo = CencMp4Decryptor.SessionState()
+                    self.playbackStartOffsetSec = 0
-                self.cryptoAudio = CencMp4Decryptor.SessionState()
+                    self.cachedMpdXML = nil
-                self.cryptoShared = CencMp4Decryptor.SessionState()
+                    self.cachedMpdAt = nil
-                self.cryptoLock.unlock()
+                    self.cryptoLock.lock()
-                self.generation += 1
+                    self.cryptoVideo = CencMp4Decryptor.SessionState()
-                let session = self.generation
+                    self.cryptoAudio = CencMp4Decryptor.SessionState()
+                    self.cryptoShared = CencMp4Decryptor.SessionState()
+                    CencMp4Decryptor.resetDiag()
+                    self.cryptoLock.unlock()
+                    self.generation += 1
+                }
+                let session = self.withState { self.generation }
 
                 let once = ResumeOnce()
 
@@ -171,14 +201,14 @@ final class ClearKeyDashProxy {
                     let params = NWParameters.tcp
                     params.allowLocalEndpointReuse = true
                     let listener = try NWListener(using: params, on: .any)
-                    self.listener = listener
+                    self.withState { self.listener = listener }
 
                     listener.stateUpdateHandler = { [weak self] state in
                         guard let self else { return }
                         switch state {
                         case .ready:
                             let p = listener.port?.rawValue ?? 0
-                            self.port = p
+                            self.withState { self.port = p }
                             proxyLog.info("listener ready on port \(p, privacy: .public) session=\(session, privacy: .public)")
                             once.run {
                                 if p > 0 {
@@ -227,6 +257,10 @@ final class ClearKeyDashProxy {
             "warmup \(kind, privacy: .public) ok bytes=\(body.count, privacy: .public) head=\(preview, privacy: .public)"
         )
 
+        if hls || preferHlsForAVPlayer {
+            await peekVodDuration(fromMaster: body)
+        }
+
         // Prefetch init segments zodat CENC track-crypto klaar is vóór AVPlayer media vraagt.
         if preferHlsForAVPlayer {
             await prefetchInitsForAVPlayer()
@@ -235,7 +269,37 @@ final class ClearKeyDashProxy {
         guard let local = URL(string: "http://127.0.0.1:\(bound.port)\(entryPath)") else {
             throw ProxyError.bindFailed
         }
-        return StartResult(url: local, session: gen)
+        return StartResult(url: local, session: gen, vodDurationMs: withState { lastVodDurationMs })
+    }
+
+    /// Haal één media-playlist op zodat we ENDLIST/duur kennen vóór VLC start.
+    private func peekVodDuration(fromMaster data: Data) async {
+        let text = String(data: data, encoding: .utf8) ?? String(decoding: data, as: UTF8.self)
+        var videoPath: String?
+        var audioPath: String?
+        for raw in text.components(separatedBy: .newlines) {
+            let line = raw.trimmingCharacters(in: .whitespaces)
+            let uri: String?
+            if line.hasPrefix("#"), let q = Self.hlsMediaAttr(line, "URI") {
+                uri = q
+            } else if line.hasPrefix("http://127.0.0.1:") {
+                uri = line
+            } else {
+                uri = nil
+            }
+            guard let uri, let url = URL(string: uri) else { continue }
+            let path = url.path + (url.query.map { "?\($0)" } ?? "")
+            guard path.hasPrefix("/a/") else { continue }
+            if path.contains("ck=v") { videoPath = path }
+            else if path.contains("ck=a") { audioPath = path }
+            else if videoPath == nil { videoPath = path }
+        }
+        guard let path = videoPath ?? audioPath else { return }
+        _ = try? await payload(for: path)
+        let ms = withState { lastVodDurationMs }
+        if ms > 0 {
+            proxyLog.info("vod duration \(ms, privacy: .public)ms from peek")
+        }
     }
 
     private func prefetchInitsForAVPlayer() async {
@@ -326,6 +390,7 @@ final class ClearKeyDashProxy {
         listener = nil
         port = 0
         remoteManifest = nil
+        resolvedManifest = nil
         manifestQuery = nil
         keyMap = nil
         isHlsMode = false
@@ -336,6 +401,8 @@ final class ClearKeyDashProxy {
         segmentSeqByKey = [:]
         nextStableSeq = 1
         lastMediaPlaylistByPath = [:]
+        lastVodDurationMs = 0
+        playbackStartOffsetSec = 0
         cachedMpdXML = nil
         cachedMpdAt = nil
         cryptoLock.lock()
@@ -489,13 +556,13 @@ final class ClearKeyDashProxy {
         let query = split.count > 1 ? split[1] : nil
 
         if pathOnly == "/" || pathOnly == "/manifest.mpd" || pathOnly == "/manifest.m3u8" {
-            let raw = try await fetch(remoteManifest)
+            let (raw, manifestBase) = try await fetchManifest(remoteManifest)
             if isHlsMode || Self.looksLikeHls(raw) {
                 let text = String(data: raw, encoding: .utf8) ?? String(decoding: raw, as: UTF8.self)
                 guard text.trimmingCharacters(in: .whitespacesAndNewlines).hasPrefix("#EXTM3U") else {
                     throw ProxyError.emptyManifest
                 }
-                let rewritten = rewriteHls(text, playlistURL: remoteManifest)
+                let rewritten = rewriteHls(text, playlistURL: manifestBase)
                 return (Data(rewritten.utf8), "application/vnd.apple.mpegurl")
             }
             let xml: String = {
@@ -507,10 +574,10 @@ final class ClearKeyDashProxy {
             }
             // AVPlayer: DASH → HLS master (+ media playlists via /hls/*).
             if preferHlsOutput || pathOnly == "/manifest.m3u8" {
-                let hls = try withState { try dashToHlsMaster(xml, mpdURL: remoteManifest) }
+                let hls = try withState { try dashToHlsMaster(xml, mpdURL: manifestBase) }
                 return (Data(hls.utf8), "application/vnd.apple.mpegurl")
             }
-            let rewritten = rewriteMpd(xml, mpdURL: remoteManifest)
+            let rewritten = rewriteMpd(xml, mpdURL: manifestBase)
             if !rewritten.localizedCaseInsensitiveContains("<MPD") {
                 throw ProxyError.emptyManifest
             }
@@ -601,7 +668,7 @@ final class ClearKeyDashProxy {
         let lower = url.absoluteString.lowercased()
         if Self.isHlsURL(url) || Self.looksLikeHls(data) {
             let text = String(data: data, encoding: .utf8) ?? String(decoding: data, as: UTF8.self)
-            let rewritten = rewriteHls(text, playlistURL: url)
+            let rewritten = rewriteHls(text, playlistURL: url, laneHint: lane)
             return (Data(rewritten.utf8), "application/vnd.apple.mpegurl")
         }
         let isManifest = lower.contains(".mpd")
@@ -611,6 +678,10 @@ final class ClearKeyDashProxy {
         }
         cryptoLock.lock()
         defer { cryptoLock.unlock() }
+        if CencMp4Decryptor.diagSink == nil {
+            CencMp4Decryptor.diagSink = { proxyLog.info("\($0, privacy: .public)") }
+        }
+        CencMp4Decryptor.diagTag = lane.rawValue
         switch lane {
         case .video:
             _ = CencMp4Decryptor.process(data: &data, keys: keys, state: &cryptoVideo)
@@ -632,7 +703,7 @@ final class ClearKeyDashProxy {
 
     /// Strip Widevine/PlayReady KEY-tags; herschrijf media-URI's naar de proxy.
     /// ESPN EVENT-playlists met duizenden segmenten → trim naar live-edge (anders audio-only / geen beeld).
-    private func rewriteHls(_ text: String, playlistURL: URL) -> String {
+    private func rewriteHls(_ text: String, playlistURL: URL, laneHint: CryptoLane = .shared) -> String {
         let lines = text.components(separatedBy: .newlines)
         let isMaster = lines.contains { $0.hasPrefix("#EXT-X-STREAM-INF") }
         var out: [String] = []
@@ -644,7 +715,10 @@ final class ClearKeyDashProxy {
 
         // Gescheiden crypto-lanes: CMAF audio+video delen vaak track_ID=1.
         // Shared state → audio-init overschrijft video → geluid zonder beeld (ESPN).
-        let lane = Self.hlsMediaLane(for: playlistURL)
+        // De master kent TYPE=AUDIO al toe (ck=a); de URL-heuristiek mist o.a. F1TV-audio.
+        let guessed = Self.hlsMediaLane(for: playlistURL)
+        let lane = laneHint == .shared ? guessed : laneHint
+        proxyLog.info("media playlist lane=\(lane.rawValue, privacy: .public) hint=\(laneHint.rawValue, privacy: .public) guess=\(guessed.rawValue, privacy: .public) file=\(playlistURL.lastPathComponent, privacy: .public)")
 
         // Media playlist: verzamel tags + segmenten, trim live-edge.
         var header: [String] = []
@@ -654,6 +728,7 @@ final class ClearKeyDashProxy {
         var mediaSequence: Int?
         var targetDuration: Int = 6
         var hasEndList = false
+        var playlistType: String?
 
         for line in lines {
             let trimmed = line.trimmingCharacters(in: .whitespaces)
@@ -661,7 +736,8 @@ final class ClearKeyDashProxy {
                 continue
             }
             if trimmed.hasPrefix("#EXT-X-PLAYLIST-TYPE:") {
-                // EVENT met uren history → AVPlayer start verkeerd / audio-only. Behandel als live.
+                playlistType = trimmed.split(separator: ":").last
+                    .map { String($0).trimmingCharacters(in: .whitespaces).uppercased() }
                 continue
             }
             if trimmed.hasPrefix("#EXT-X-MEDIA-SEQUENCE:") {
@@ -707,27 +783,46 @@ final class ClearKeyDashProxy {
             }
         }
 
-        // Live-edge window: ~12–16 segmenten (±60–90s bij 5–6s ESPN, ±40–60s bij 3.8s).
+        // Live-edge alleen voor echte live (ESPN). F1-replays / VOD hebben ENDLIST of
+        // een lange statische lijst: trim + START=-12 + geen ENDLIST → ~12s beeld, dan vast.
+        let host = (playlistURL.host ?? "").lowercased()
+        let isComplete = hasEndList || playlistType == "VOD"
+        let isF1 = host.contains("formula1.com")
         let keep = 14
         let startIdx: Int
         let seqBase = mediaSequence ?? 0
-        if !hasEndList, segments.count > keep {
+        if isComplete || isF1 {
-            startIdx = segments.count - keep
+            startIdx = 0
-        } else if segments.count > 40 {
+        } else if segments.count > keep {
-            // VOD/EVENT-achtig met enorme history: toch trimmen naar einde.
             startIdx = segments.count - keep
         } else {
             startIdx = 0
         }
         let window = Array(segments.suffix(from: startIdx))
-        let seq = seqBase + startIdx
+        if isComplete || (isF1 && startIdx == 0 && window.count > 40) {
+            let ms = Self.playlistDurationMs(window.map(\.inf), fallbackSeconds: targetDuration)
+            withState {
+                if ms > self.lastVodDurationMs { self.lastVodDurationMs = ms }
+            }
+        }
+        let seekSec = withState { self.playbackStartOffsetSec }
+        var playFrom = 0
+        if seekSec > 0.4, isComplete || isF1 {
+            playFrom = Self.segmentIndex(at: seekSec, infLines: window.map(\.inf), fallbackSeconds: targetDuration)
+        }
+        let playWindow = Array(window.suffix(from: playFrom))
+        let seq = seqBase + startIdx + playFrom
+        proxyLog.info("hls rewrite segs=\(segments.count, privacy: .public) keep=\(playWindow.count, privacy: .public) endlist=\(hasEndList, privacy: .public) type=\(playlistType ?? "-", privacy: .public) f1=\(isF1, privacy: .public) startIdx=\(startIdx, privacy: .public) seek=\(Int(seekSec), privacy: .public)s vodMs=\(self.lastVodDurationMs, privacy: .public)")
 
         out.append("#EXTM3U")
         out.append("#EXT-X-VERSION:7")
         out.append("#EXT-X-TARGETDURATION:\(targetDuration)")
         out.append("#EXT-X-MEDIA-SEQUENCE:\(seq)")
         out.append("#EXT-X-INDEPENDENT-SEGMENTS")
-        // Live-achtig: start dicht bij einde.
+        if isComplete {
+            out.append("#EXT-X-PLAYLIST-TYPE:VOD")
+        }
+        // Live-achtig: start dicht bij einde. Nooit op een complete/F1-replay.
         if startIdx > 0 {
             out.append("#EXT-X-START:TIME-OFFSET=-12.0,PRECISE=YES")
         }
@@ -738,17 +833,45 @@ final class ClearKeyDashProxy {
                 out.append(h)
             }
         }
-        for seg in window {
+        for seg in playWindow {
             out.append(seg.inf)
             let resolved = join(base: asDirectory(playlistURL.deletingLastPathComponent()), relative: seg.uri)
             out.append(proxyAbsoluteURL(resolved, lane: lane))
         }
-        if hasEndList && startIdx == 0 {
+        if isComplete {
             out.append("#EXT-X-ENDLIST")
         }
         return out.joined(separator: "\n")
     }
 
+    private static func playlistDurationMs(_ infLines: [String], fallbackSeconds: Int) -> Int64 {
+        var total: Double = 0
+        for inf in infLines {
+            total += extinfSeconds(inf, fallback: fallbackSeconds)
+        }
+        return Int64(total * 1000)
+    }
+
+    private static func segmentIndex(at seconds: Double, infLines: [String], fallbackSeconds: Int) -> Int {
+        guard !infLines.isEmpty else { return 0 }
+        var acc = 0.0
+        for (i, inf) in infLines.enumerated() {
+            acc += extinfSeconds(inf, fallback: fallbackSeconds)
+            if acc >= seconds { return i }
+        }
+        return max(0, infLines.count - 1)
+    }
+
+    private static func extinfSeconds(_ inf: String, fallback: Int) -> Double {
+        let raw = inf.trimmingCharacters(in: .whitespaces)
+        let rest = raw.hasPrefix("#EXTINF:") ? String(raw.dropFirst(8)) : raw
+        let token = rest.split(separator: ",", maxSplits: 1).first.map(String.init) ?? ""
+        if let seconds = Double(token.trimmingCharacters(in: .whitespaces)) {
+            return seconds
+        }
+        return Double(max(fallback, 1))
+    }
+
     /// Audio- vs video-playlist herkennen (ESPN: `audio-aac-…` vs `cmaf-cenc-…`).
     private static func hlsMediaLane(for playlistURL: URL) -> CryptoLane {
         let s = playlistURL.path.lowercased()
@@ -763,6 +886,7 @@ final class ClearKeyDashProxy {
     /// Master: strip DRM keys, proxy alle variant/audio URI's — audio→ck=a, video→ck=v.
     private func rewriteHlsMaster(_ lines: [String], playlistURL: URL) -> String {
         var out: [String] = []
+        var audioLines: [String] = []
         var i = 0
         while i < lines.count {
             let line = lines[i]
@@ -789,7 +913,12 @@ final class ClearKeyDashProxy {
             }
             if trimmed.hasPrefix("#EXT-X-MEDIA:") {
                 let lane: CryptoLane = trimmed.contains("TYPE=AUDIO") ? .audio : .shared
-                out.append(rewriteHlsTagURIs(line, base: playlistURL, lane: lane))
+                let rewritten = rewriteHlsTagURIs(line, base: playlistURL, lane: lane)
+                if lane == .audio {
+                    audioLines.append(rewritten)
+                } else {
+                    out.append(rewritten)
+                }
                 i += 1
                 continue
             }
@@ -803,9 +932,78 @@ final class ClearKeyDashProxy {
             }
             i += 1
         }
+        if !audioLines.isEmpty {
+            let ranked = Self.rankHlsAudioLines(audioLines)
+            if let idx = out.firstIndex(where: { $0.hasPrefix("#EXT-X-STREAM-INF") }) {
+                out.insert(contentsOf: ranked, at: idx)
+            } else {
+                out.append(contentsOf: ranked)
+            }
+        }
         return out.joined(separator: "\n")
     }
 
+    /// NL → Engels → rest. Winnaar krijgt DEFAULT=YES zodat VLC niet op Spaans start.
+    private static func rankHlsAudioLines(_ lines: [String]) -> [String] {
+        let scored = lines.enumerated().map { i, line in (line, hlsAudioScore(line) * 100 - i) }
+        let sorted = scored.sorted { $0.1 > $1.1 }.map(\.0)
+        guard let first = sorted.first else { return lines }
+        var out: [String] = []
+        for (i, line) in sorted.enumerated() {
+            out.append(hlsSetAttr(hlsSetAttr(line, key: "DEFAULT", value: i == 0 ? "YES" : "NO"), key: "AUTOSELECT", value: "YES"))
+        }
+        let lang = hlsMediaAttr(first, "LANGUAGE") ?? "-"
+        let name = hlsMediaAttr(first, "NAME") ?? "-"
+        proxyLog.info("hls audio default lang=\(lang, privacy: .public) name=\(name, privacy: .public) count=\(sorted.count, privacy: .public)")
+        return out
+    }
+
+    private static func hlsAudioScore(_ line: String) -> Int {
+        let lang = (hlsMediaAttr(line, "LANGUAGE") ?? "").lowercased()
+        let name = (hlsMediaAttr(line, "NAME") ?? "").lowercased()
+        if ["nl", "dut", "nld"].contains(lang) || name.contains("nederlands") || name.contains("dutch") {
+            return 100
+        }
+        if ["en", "eng"].contains(lang) || name.contains("english") || name.contains("engels") {
+            return 50
+        }
+        if name.contains("international") { return 35 }
+        return 0
+    }
+
+    private static func hlsMediaAttr(_ line: String, _ key: String) -> String? {
+        let pattern = #"\#(key)=(?:"([^"]*)"|([^,]*))"#
+        guard let re = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else { return nil }
+        let ns = line as NSString
+        guard let m = re.firstMatch(in: line, options: [], range: NSRange(location: 0, length: ns.length)) else { return nil }
+        if m.numberOfRanges > 1, m.range(at: 1).location != NSNotFound {
+            let v = ns.substring(with: m.range(at: 1)).trimmingCharacters(in: .whitespaces)
+            return v.isEmpty ? nil : v
+        }
+        if m.numberOfRanges > 2, m.range(at: 2).location != NSNotFound {
+            let v = ns.substring(with: m.range(at: 2)).trimmingCharacters(in: .whitespaces)
+            return v.isEmpty ? nil : v
+        }
+        return nil
+    }
+
+    private static func hlsSetAttr(_ line: String, key: String, value: String) -> String {
+        let pattern = #"\#(key)=(?:"[^"]*"|[^,]*)"#
+        let replacement = "\(key)=\"\(value)\""
+        guard let re = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else {
+            return line + ",\(replacement)"
+        }
+        let ns = line as NSString
+        let range = NSRange(location: 0, length: ns.length)
+        if re.firstMatch(in: line, options: [], range: range) != nil {
+            return re.stringByReplacingMatches(in: line, options: [], range: range, withTemplate: replacement)
+        }
+        if line.hasPrefix("#EXT-X-MEDIA:") {
+            return "#EXT-X-MEDIA:\(replacement)," + String(line.dropFirst("#EXT-X-MEDIA:".count))
+        }
+        return line + ",\(replacement)"
+    }
+
     private func rewriteHlsTagURIs(_ line: String, base: URL, lane: CryptoLane = .shared) -> String {
         guard let regex = try? NSRegularExpression(pattern: #"URI="([^"]+)""#, options: []) else {
             return line
@@ -842,6 +1040,10 @@ final class ClearKeyDashProxy {
     }
 
     private func fetch(_ url: URL) async throws -> Data {
+        try await fetchFollowingRedirects(url).data
+    }
+
+    private func fetchFollowingRedirects(_ url: URL) async throws -> (data: Data, finalURL: URL) {
         var req = URLRequest(url: url)
         req.timeoutInterval = 15
         req.cachePolicy = .reloadIgnoringLocalCacheData
@@ -851,7 +1053,25 @@ final class ClearKeyDashProxy {
         if let http = resp as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
             throw ProxyError.upstream(http.statusCode)
         }
-        return data
+        return (data, resp.url ?? url)
+    }
+
+    /// Manifest ophalen via de sticky eind-URL (zoals ExoPlayer); faalt die, één keer opnieuw via het origineel.
+    private func fetchManifest(_ original: URL) async throws -> (data: Data, baseURL: URL) {
+        let sticky = withState { resolvedManifest }
+        if let sticky, sticky != original {
+            if let got = try? await fetchFollowingRedirects(sticky) {
+                withState { resolvedManifest = got.finalURL }
+                return (got.data, got.finalURL)
+            }
+            proxyLog.error("sticky manifest failed — re-resolving via original URL")
+        }
+        let got = try await fetchFollowingRedirects(original)
+        withState { resolvedManifest = got.finalURL }
+        if got.finalURL != original {
+            proxyLog.info("manifest redirected to \(got.finalURL.host ?? "?", privacy: .public)")
+        }
+        return (got.data, got.finalURL)
     }
 
     private func rewriteMpd(_ xml: String, mpdURL: URL) -> String {
@@ -881,8 +1101,8 @@ final class ClearKeyDashProxy {
             let matches = baseRegex.matches(in: s, options: [], range: NSRange(location: 0, length: ns.length))
             for match in matches.reversed() {
                 guard match.numberOfRanges >= 2 else { continue }
-                let content = ns.substring(with: match.range(at: 1))
+                let content = Self.xmlUnescape(ns.substring(with: match.range(at: 1))
-                    .trimmingCharacters(in: .whitespacesAndNewlines)
+                    .trimmingCharacters(in: .whitespacesAndNewlines))
                 if content.contains("127.0.0.1:\(port)") {
                     continue
                 }
@@ -1042,7 +1262,7 @@ final class ClearKeyDashProxy {
     private static func preferredAudioOrder(_ audios: [DashHlsRep]) -> [DashHlsRep] {
         let aac = audios.filter(\.isAac)
         let pool = aac.isEmpty ? audios : aac
-        let preferred = Locale.current.language.languageCode?.identifier.lowercased() ?? "nl"
+        let preferred = "nl"
         return pool.sorted { a, b in
             let aScore = Self.audioLocaleScore(a, preferred: preferred)
             let bScore = Self.audioLocaleScore(b, preferred: preferred)
@@ -1309,12 +1529,12 @@ final class ClearKeyDashProxy {
                 let s = String(block[initMatch])
                 if let q1 = s.range(of: "sourceURL=\"")?.upperBound,
                    let q2 = s[q1...].firstIndex(of: "\"") {
-                    out.initialization = String(s[q1..<q2])
+                    out.initialization = xmlUnescape(String(s[q1..<q2]))
                 }
             } else if let initMatch = block.range(of: #"sourceURL="([^"]+)""#, options: [.regularExpression, .caseInsensitive]) {
                 let s = String(block[initMatch])
                 if let q1 = s.firstIndex(of: "\""), let q2 = s.lastIndex(of: "\""), q1 < q2 {
-                    out.initialization = String(s[s.index(after: q1)..<q2])
+                    out.initialization = xmlUnescape(String(s[s.index(after: q1)..<q2]))
                 }
             }
             if let urlRegex = try? NSRegularExpression(
@@ -1324,7 +1544,7 @@ final class ClearKeyDashProxy {
                 let ns = block as NSString
                 for m in urlRegex.matches(in: block, options: [], range: NSRange(location: 0, length: ns.length)) {
                     guard m.numberOfRanges >= 2 else { continue }
-                    let media = ns.substring(with: m.range(at: 1))
+                    let media = xmlUnescape(ns.substring(with: m.range(at: 1)))
                     if !media.isEmpty { out.segmentListMedia.append(media) }
                 }
             }
@@ -1338,7 +1558,18 @@ final class ClearKeyDashProxy {
         }
         let block = String(xml[r])
         guard let start = block.firstIndex(of: ">"), let end = block.lastIndex(of: "<"), start < end else { return nil }
-        return String(block[block.index(after: start)..<end]).trimmingCharacters(in: .whitespacesAndNewlines)
+        return xmlUnescape(String(block[block.index(after: start)..<end]).trimmingCharacters(in: .whitespacesAndNewlines))
+    }
+
+    /// MPD is XML: `&amp;` in BaseURL/template-URLs moet `&` worden, anders weigert de CDN (Odido: 403).
+    private static func xmlUnescape(_ s: String) -> String {
+        guard s.contains("&") else { return s }
+        return s
+            .replacingOccurrences(of: "&lt;", with: "<")
+            .replacingOccurrences(of: "&gt;", with: ">")
+            .replacingOccurrences(of: "&quot;", with: "\"")
+            .replacingOccurrences(of: "&apos;", with: "'")
+            .replacingOccurrences(of: "&amp;", with: "&")
     }
 
     private static func xmlAttr(_ attrs: String, _ name: String) -> String? {
@@ -1351,7 +1582,7 @@ final class ClearKeyDashProxy {
             let ns = attrs as NSString
             if let m = re.firstMatch(in: attrs, options: [], range: NSRange(location: 0, length: ns.length)),
                m.numberOfRanges >= 2 {
-                return ns.substring(with: m.range(at: 1))
+                return xmlUnescape(ns.substring(with: m.range(at: 1)))
             }
         }
         return nil
@@ -1570,19 +1801,21 @@ final class ClearKeyDashProxy {
         let remote = withState { remoteManifest }
         guard let remoteManifest = remote else { throw ProxyError.notStarted }
 
-        let cached: String? = withState {
+        let cached: (xml: String, base: URL)? = withState {
             if let xml = cachedMpdXML, let at = cachedMpdAt,
                Date().timeIntervalSince(at) < mpdCacheTTL {
-                return xml
+                return (xml, resolvedManifest ?? remoteManifest)
             }
             return nil
         }
 
         let xml: String
+        let manifestBase: URL
         if let cached {
-            xml = cached
+            xml = cached.xml
+            manifestBase = cached.base
         } else {
-            let raw = try await fetch(remoteManifest)
+            let (raw, base) = try await fetchManifest(remoteManifest)
             let fetched: String = {
                 if let s = String(data: raw, encoding: .utf8), !s.isEmpty { return s }
                 return String(decoding: raw, as: UTF8.self)
@@ -1592,9 +1825,10 @@ final class ClearKeyDashProxy {
                 cachedMpdAt = Date()
             }
             xml = fetched
+            manifestBase = base
         }
 
-        let reps = parseDashReps(xml, mpdURL: remoteManifest)
+        let reps = parseDashReps(xml, mpdURL: manifestBase)
         let videos = reps.filter { !$0.isAudio }.map(\.rep)
         let audios = reps.filter(\.isAudio).map(\.rep)
 
@@ -1827,4 +2061,3 @@ final class ClearKeyDashProxy {
         }
     }
 }
-

apps/ios/VMC/Playback/ClearKeyMaterial.swift

@@ -22,16 +22,34 @@ struct ClearKeyKeyMap {
 
     var isEmpty: Bool { keysByKid.isEmpty }
 
-    /// Eerste key (streams hebben meestal één kid/key-paar).
+    /// Unieke key-waarden in de map (meestal 1).
-    var primaryKey: Data? { keysByKid.values.first }
+    var uniqueKeyCount: Int {
+        Set(keysByKid.values.map { $0.base64EncodedString() }).count
+    }
+
+    /// Eerste key — alleen veilig als er precies één unieke key is.
+    var primaryKey: Data? {
+        guard uniqueKeyCount == 1 else { return nil }
+        return keysByKid.values.first
+    }
+
+    func hasExactKey(forKid kid: Data) -> Bool {
+        guard kid.count == 16 else { return false }
+        if keysByKid[kid.map { String(format: "%02x", $0) }.joined()] != nil { return true }
+        let swapped = Self.swapUuidEndianness(kid)
+        return keysByKid[swapped.map { String(format: "%02x", $0) }.joined()] != nil
+    }
 
     func key(forKid kid: Data) -> Data? {
-        guard kid.count == 16 else { return primaryKey }
+        if kid.count == 16 {
-        let hex = kid.map { String(format: "%02x", $0) }.joined()
+            let hex = kid.map { String(format: "%02x", $0) }.joined()
-        if let k = keysByKid[hex] { return k }
+            if let k = keysByKid[hex] { return k }
-        let swapped = Self.swapUuidEndianness(kid)
+            let swapped = Self.swapUuidEndianness(kid)
-        let swappedHex = swapped.map { String(format: "%02x", $0) }.joined()
+            let swappedHex = swapped.map { String(format: "%02x", $0) }.joined()
-        return keysByKid[swappedHex] ?? primaryKey
+            if let k = keysByKid[swappedHex] { return k }
+        }
+        // Streams met één key (Android parity): gebruik die key als KID-match faalt.
+        return primaryKey
     }
 
     static func sanitizeHex(_ raw: String) -> String {

apps/ios/VMC/Playback/PlayerScreen.swift

@@ -18,6 +18,8 @@ struct PlayRequest: Identifiable {
     let watchSessionId: String?
     let watchKind: String?
     let watchId: String?
+    /// Provider-/titel-logo voor laad-animatie (events, films, series).
+    let logoUrl: String?
 
     static func vod(
         url: URL,
@@ -28,13 +30,15 @@ struct PlayRequest: Identifiable {
         episodeId: String?,
         seriesId: String?,
         startMs: Int64,
-        subtitleFileURL: URL? = nil
+        subtitleFileURL: URL? = nil,
+        logoUrl: String? = nil
     ) -> PlayRequest {
         PlayRequest(
             url: url, title: title, mediaType: mediaType, mediaFileId: mediaFileId,
             movieId: movieId, episodeId: episodeId, seriesId: seriesId,
             startMs: startMs, isLive: false, fallbackUrl: nil, subtitleFileURL: subtitleFileURL,
-            format: nil, drm: nil, watchSessionId: nil, watchKind: nil, watchId: nil
+            format: nil, drm: nil, watchSessionId: nil, watchKind: nil, watchId: nil,
+            logoUrl: logoUrl
         )
     }
 
@@ -46,14 +50,15 @@ struct PlayRequest: Identifiable {
         drm: DrmInfo? = nil,
         watchSessionId: String? = nil,
         watchKind: String? = nil,
-        watchId: String? = nil
+        watchId: String? = nil,
+        logoUrl: String? = nil
     ) -> PlayRequest {
         PlayRequest(
             url: url, title: title, mediaType: "live", mediaFileId: nil,
             movieId: nil, episodeId: nil, seriesId: nil,
             startMs: 0, isLive: true, fallbackUrl: fallback, subtitleFileURL: nil,
             format: format, drm: drm, watchSessionId: watchSessionId,
-            watchKind: watchKind, watchId: watchId
+            watchKind: watchKind, watchId: watchId, logoUrl: logoUrl
         )
     }
 
@@ -69,7 +74,7 @@ struct PlayerScreen: View {
 
     let request: PlayRequest
 
-    /// ClearKey live → AVPlayer + lokale decrypt-HLS. FTA live + VOD → VLC (PiP intact).
+    /// ClearKey: DASH→AVPlayer+proxy; native HLS (ESPN)→VLC+proxy. FTA live + VOD → VLC.
     @StateObject private var vlc = VLCPlayerController()
     @StateObject private var av = AVLivePlayerController()
     @State private var controlsVisible = true
@@ -79,20 +84,35 @@ struct PlayerScreen: View {
     @State private var hideTask: Task<Void, Never>?
     @State private var heartbeatTask: Task<Void, Never>?
     @State private var showTracks = false
+    @State private var sliderDraft: Double = 0
+    @State private var isScrubbing = false
     @State private var trackTab = 0
     @State private var subtitleHits: [SubtitleHit] = []
     @State private var subsLoading = false
     @State private var subsError: String?
     @State private var pendingStop: Task<Void, Never>?
 
+    /// ClearKey live: DASH→AVPlayer; native HLS (ESPN)→VLC (AV bevriest bij rotatie).
+    @State private var clearKeyPreferAV = true
+
     private var isLive: Bool { request.isLive }
-    private var useClearKeyAV: Bool { request.isLive && request.needsClearKey }
+    private var useClearKeyAV: Bool { request.isLive && request.needsClearKey && clearKeyPreferAV }
+    /// F1-replay e.d. komen via live-request binnen, maar hebben een echte duur.
+    private var showSeekChrome: Bool { !isLive || (!useClearKeyAV && vlc.canSeek) }
 
     private var stateText: String { useClearKeyAV ? av.stateText : vlc.stateText }
     private var isPlaying: Bool { useClearKeyAV ? av.isPlaying : vlc.isPlaying }
     private var playerHasError: Bool { useClearKeyAV ? av.hasError : vlc.hasError }
     private var playerErrorMessage: String? { useClearKeyAV ? av.errorMessage : vlc.errorMessage }
 
+    /// Alleen start/buffer vóór first frame — overlay mag playback niet blokkeren.
+    private var showLoadingChrome: Bool {
+        guard !playerHasError else { return false }
+        if loading && !isPlaying { return true }
+        if useClearKeyAV, !av.hasVideo, !av.isPlaying { return true }
+        return false
+    }
+
     var body: some View {
         ZStack {
             Color.black.ignoresSafeArea()
@@ -116,18 +136,16 @@ struct PlayerScreen: View {
                 .ignoresSafeArea()
             }
 
-            // Speler eet touches op — vang tikken altijd zelf af.
             Color.clear
                 .contentShape(Rectangle())
                 .ignoresSafeArea()
                 .onTapGesture { toggleControls() }
                 .allowsHitTesting(!controlsVisible)
 
-            if loading && !isPlaying {
+            if showLoadingChrome {
-                ProgressView(stateText)
+                PlayerLoadingChrome(logoUrl: request.logoUrl, status: stateText)
-                    .tint(.white)
-                    .foregroundStyle(.white)
                     .allowsHitTesting(false)
+                    .transition(.opacity)
             }
 
             if let error {
@@ -172,13 +190,35 @@ struct PlayerScreen: View {
                 }
             }
         }
-        .sheet(isPresented: $showTracks) {
+        .sheet(isPresented: $showTracks, onDismiss: { scheduleHide() }) {
             tracksSheet
                 .presentationDetents([.medium, .large])
                 .presentationDragIndicator(.visible)
         }
     }
 
+    private static func formatClock(ratio: Double, durationMs: Int64) -> String {
+        let ms = Int(Double(max(durationMs, 0)) * min(max(ratio, 0), 1) / 1000)
+        let h = ms / 3600
+        let m = (ms % 3600) / 60
+        let s = ms % 60
+        if h > 0 { return String(format: "%d:%02d:%02d", h, m, s) }
+        return String(format: "%d:%02d", m, s)
+    }
+
+    /// Letterbox/pillarbox buiten de VLC-surface zodat FreeType onderaan het beeld zit.
+    private static func fittedVideoSize(in container: CGSize, aspect: CGFloat) -> CGSize {
+        guard container.width > 1, container.height > 1, aspect > 0 else { return container }
+        let viewAspect = container.width / container.height
+        if viewAspect > aspect {
+            let h = container.height
+            return CGSize(width: h * aspect, height: h)
+        } else {
+            let w = container.width
+            return CGSize(width: w, height: w / aspect)
+        }
+    }
+
     private var controlsOverlay: some View {
         VStack(spacing: 0) {
             HStack {
@@ -201,7 +241,7 @@ struct PlayerScreen: View {
                         .foregroundStyle(.white.opacity(0.7))
                 }
                 Spacer()
-                if !useClearKeyAV && vlc.pipPossible {
+                if !isLive, vlc.pipPossible {
                     Button {
                         vlc.togglePictureInPicture()
                         scheduleHide()
@@ -215,18 +255,23 @@ struct PlayerScreen: View {
                             .background(.black.opacity(0.4), in: Circle())
                     }
                 }
-                if !request.isLive {
+                Button {
-                    Button {
+                    showTracks = true
-                        showTracks = true
+                    scheduleHide(cancelOnly: true)
-                        scheduleHide(cancelOnly: true)
+                    if useClearKeyAV {
-                        Task { await loadSubtitles() }
+                        av.refreshMediaOptions()
-                    } label: {
+                    } else {
-                        Image(systemName: "captions.bubble.fill")
+                        vlc.refreshTracks()
-                            .font(.title3)
-                            .foregroundStyle(.white)
-                            .padding(12)
-                            .background(.black.opacity(0.4), in: Circle())
                     }
+                    if !isLive {
+                        Task { await loadSubtitles() }
+                    }
+                } label: {
+                    Image(systemName: "captions.bubble.fill")
+                        .font(.title3)
+                        .foregroundStyle(.white)
+                        .padding(12)
+                        .background(.black.opacity(0.4), in: Circle())
                 }
             }
             .padding(.horizontal, 16)
@@ -237,28 +282,38 @@ struct PlayerScreen: View {
                 .onTapGesture { hideControls() }
 
             VStack(spacing: 14) {
-                if !request.isLive {
+                if showSeekChrome {
                     Slider(
                         value: Binding(
-                            get: { Double(vlc.position) },
+                            get: { isScrubbing ? sliderDraft : Double(vlc.position) },
-                            set: {
+                            set: { sliderDraft = $0 }
-                                vlc.seek(ratio: Float($0))
+                        ),
+                        in: 0...1,
+                        onEditingChanged: { editing in
+                            if editing {
+                                isScrubbing = true
+                                sliderDraft = Double(vlc.position)
+                                scheduleHide(cancelOnly: true)
+                            } else {
+                                isScrubbing = false
+                                vlc.seek(ratio: Float(sliderDraft))
                                 scheduleHide()
                             }
-                        ),
+                        }
-                        in: 0...1
                     )
                     .tint(McColors.accent)
 
                     HStack {
-                        Text(vlc.timeText).font(McFonts.caption).foregroundStyle(.white.opacity(0.85))
+                        Text(isScrubbing ? Self.formatClock(ratio: sliderDraft, durationMs: vlc.durationMs()) : vlc.timeText)
+                            .font(McFonts.caption)
+                            .foregroundStyle(.white.opacity(0.85))
                         Spacer()
                         Text(vlc.lengthText).font(McFonts.caption).foregroundStyle(.white.opacity(0.85))
                     }
                 }
 
                 HStack(spacing: 36) {
-                    if !request.isLive {
+                    if showSeekChrome {
                         Button {
                             vlc.seek(toMs: max(vlc.currentPositionMs() - 10_000, 0))
                             scheduleHide()
@@ -275,7 +330,7 @@ struct PlayerScreen: View {
                             .foregroundStyle(.white)
                             .shadow(radius: 8)
                     }
-                    if !request.isLive {
+                    if showSeekChrome {
                         Button {
                             vlc.seek(toMs: vlc.currentPositionMs() + 10_000)
                             scheduleHide()
@@ -295,86 +350,148 @@ struct PlayerScreen: View {
     private var tracksSheet: some View {
         NavigationStack {
             VStack(spacing: 0) {
-                Picker("", selection: $trackTab) {
+                if useClearKeyAV {
-                    Text("In bestand").tag(0)
+                    Picker("", selection: $trackTab) {
-                    Text("Downloaden").tag(1)
+                        Text("Audio").tag(0)
-                    Text("Audio").tag(2)
+                        Text("Ondertitel").tag(1)
-                }
-                .pickerStyle(.segmented)
-                .padding()
-
-                if trackTab == 0 {
-                    List {
-                        ForEach(vlc.subtitleTracks) { track in
-                            Button {
-                                vlc.selectSubtitle(id: track.id)
-                                showTracks = false
-                                scheduleHide()
-                            } label: {
-                                HStack {
-                                    Text(track.name).foregroundStyle(McColors.text)
-                                    Spacer()
-                                    if track.id == vlc.currentSubtitleId {
-                                        Image(systemName: "checkmark").foregroundStyle(McColors.accent)
-                                    }
-                                }
-                            }
-                            .listRowBackground(McColors.bgElevated)
-                        }
                     }
-                    .scrollContentBackground(.hidden)
+                    .pickerStyle(.segmented)
-                } else if trackTab == 1 {
+                    .padding()
-                    Group {
+
-                        if subsLoading {
+                    if trackTab == 0 {
-                            ProgressView("Zoeken…").padding(.top, 40)
+                        List {
-                        } else if let subsError {
+                            if av.audioOptions.isEmpty {
-                            Text(subsError).foregroundStyle(McColors.danger).padding()
+                                Text("Geen audio-sporen gevonden")
-                        } else if subtitleHits.isEmpty {
+                                    .foregroundStyle(McColors.textDim)
-                            ContentUnavailableView("Geen downloads", systemImage: "arrow.down.circle", description: Text("Geen OpenSubtitles-resultaten."))
+                                    .listRowBackground(McColors.bgElevated)
-                        } else {
+                            }
-                            List(subtitleHits) { hit in
+                            ForEach(av.audioOptions) { track in
                                 Button {
-                                    Task { await applySubtitle(hit) }
+                                    av.selectAudio(id: track.id)
+                                    showTracks = false
+                                    scheduleHide()
                                 } label: {
-                                    VStack(alignment: .leading, spacing: 4) {
+                                    HStack {
-                                        Text(hit.release ?? hit.fileName ?? "Ondertitel")
+                                        Text(track.name).foregroundStyle(McColors.text)
-                                            .foregroundStyle(McColors.text)
+                                        Spacer()
-                                            .lineLimit(2)
+                                        if track.id == av.currentAudioId {
-                                        HStack(spacing: 8) {
+                                            Image(systemName: "checkmark").foregroundStyle(McColors.accent)
-                                            Text((hit.language ?? "?").uppercased())
-                                            if hit.hearingImpaired == true { Text("SDH") }
-                                            if let n = hit.downloadCount { Text("↓\(n)") }
                                         }
-                                        .font(McFonts.caption)
-                                        .foregroundStyle(McColors.textDim)
                                     }
                                 }
                                 .listRowBackground(McColors.bgElevated)
                             }
-                            .scrollContentBackground(.hidden)
                         }
-                    }
+                        .scrollContentBackground(.hidden)
-                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                    } else {
-                } else {
+                        List {
-                    List {
+                            ForEach(av.subtitleOptions) { track in
-                        ForEach(vlc.audioTracks) { track in
+                                Button {
-                            Button {
+                                    av.selectSubtitle(id: track.id == "off" ? nil : track.id)
-                                vlc.selectAudio(id: track.id)
+                                    showTracks = false
-                                showTracks = false
+                                    scheduleHide()
-                                scheduleHide()
+                                } label: {
-                            } label: {
+                                    HStack {
-                                HStack {
+                                        Text(track.name).foregroundStyle(McColors.text)
-                                    Text(track.name).foregroundStyle(McColors.text)
+                                        Spacer()
-                                    Spacer()
+                                        if track.id == (av.currentSubtitleId ?? "off") {
-                                    if track.id == vlc.currentAudioId {
+                                            Image(systemName: "checkmark").foregroundStyle(McColors.accent)
-                                        Image(systemName: "checkmark").foregroundStyle(McColors.accent)
+                                        }
                                     }
                                 }
+                                .listRowBackground(McColors.bgElevated)
                             }
-                            .listRowBackground(McColors.bgElevated)
                         }
+                        .scrollContentBackground(.hidden)
+                    }
+                } else {
+                    Picker("", selection: $trackTab) {
+                        Text("In bestand").tag(0)
+                        Text("Downloaden").tag(1)
+                        Text("Audio").tag(2)
+                    }
+                    .pickerStyle(.segmented)
+                    .padding()
+
+                    if trackTab == 0 {
+                        List {
+                            ForEach(vlc.subtitleTracks) { track in
+                                Button {
+                                    vlc.selectSubtitle(id: track.id)
+                                    showTracks = false
+                                    scheduleHide()
+                                } label: {
+                                    HStack {
+                                        Text(track.name).foregroundStyle(McColors.text)
+                                        Spacer()
+                                        if track.id == vlc.currentSubtitleId {
+                                            Image(systemName: "checkmark").foregroundStyle(McColors.accent)
+                                        }
+                                    }
+                                }
+                                .listRowBackground(McColors.bgElevated)
+                            }
+                        }
+                        .scrollContentBackground(.hidden)
+                    } else if trackTab == 1 {
+                        Group {
+                            if isLive {
+                                ContentUnavailableView(
+                                    "Alleen bij VOD",
+                                    systemImage: "arrow.down.circle",
+                                    description: Text("OpenSubtitles is beschikbaar bij films/series.")
+                                )
+                            } else if subsLoading {
+                                ProgressView("Zoeken…").padding(.top, 40)
+                            } else if let subsError {
+                                Text(subsError).foregroundStyle(McColors.danger).padding()
+                            } else if subtitleHits.isEmpty {
+                                ContentUnavailableView("Geen downloads", systemImage: "arrow.down.circle", description: Text("Geen OpenSubtitles-resultaten."))
+                            } else {
+                                List(subtitleHits) { hit in
+                                    Button {
+                                        Task { await applySubtitle(hit) }
+                                    } label: {
+                                        VStack(alignment: .leading, spacing: 4) {
+                                            Text(hit.release ?? hit.fileName ?? "Ondertitel")
+                                                .foregroundStyle(McColors.text)
+                                                .lineLimit(2)
+                                            HStack(spacing: 8) {
+                                                Text((hit.language ?? "?").uppercased())
+                                                if hit.hearingImpaired == true { Text("SDH") }
+                                                if let n = hit.downloadCount { Text("↓\(n)") }
+                                            }
+                                            .font(McFonts.caption)
+                                            .foregroundStyle(McColors.textDim)
+                                        }
+                                    }
+                                    .listRowBackground(McColors.bgElevated)
+                                }
+                                .scrollContentBackground(.hidden)
+                            }
+                        }
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                    } else {
+                        List {
+                            ForEach(vlc.audioTracks) { track in
+                                Button {
+                                    vlc.selectAudio(id: track.id)
+                                    showTracks = false
+                                    scheduleHide()
+                                } label: {
+                                    HStack {
+                                        Text(track.name).foregroundStyle(McColors.text)
+                                        Spacer()
+                                        if track.id == vlc.currentAudioId {
+                                            Image(systemName: "checkmark").foregroundStyle(McColors.accent)
+                                        }
+                                    }
+                                }
+                                .listRowBackground(McColors.bgElevated)
+                            }
+                        }
+                        .scrollContentBackground(.hidden)
                     }
-                    .scrollContentBackground(.hidden)
                 }
             }
             .background(McColors.bg)
@@ -385,7 +502,14 @@ struct PlayerScreen: View {
                     Button("Sluiten") { showTracks = false }
                 }
             }
-            .onAppear { vlc.refreshTracks() }
+            .onAppear {
+                if useClearKeyAV {
+                    av.refreshMediaOptions()
+                    trackTab = 0
+                } else {
+                    vlc.refreshTracks()
+                }
+            }
         }
     }
 
@@ -441,25 +565,72 @@ struct PlayerScreen: View {
     private func start() async {
         loading = true
         error = nil
-        if useClearKeyAV {
+        if request.isLive && request.needsClearKey {
             let keys = request.drm?.keys ?? []
-            await av.play(
+            let fmt = (request.format ?? "").lowercased()
-                url: request.url,
+            // ESPN e.d.: native HLS + aparte AUDIO-rendition → AVPlayer bevriest beeld bij rotatie.
-                fallback: request.fallbackUrl,
+            // DASH→HLS (Prime/HBO/Viaplay/Ziggo) blijft op AVPlayer (rotatie is daar vloeiend).
-                format: request.format,
+            let nativeHls = fmt == "hls" || ClearKeyDashProxy.isHlsURL(request.url)
-                clearKeys: keys
+            if nativeHls {
-            )
+                clearKeyPreferAV = false
-            let maxWaitNs: UInt64 = 18_000_000_000
+                await vlc.playLive(
-            let stepNs: UInt64 = 200_000_000
+                    url: request.url,
-            var waited: UInt64 = 0
+                    fallback: request.fallbackUrl,
-            while waited < maxWaitNs && !av.hasError {
+                    format: request.format,
-                if av.isPlaying { break }
+                    clearKeys: keys,
-                try? await Task.sleep(nanoseconds: stepNs)
+                    preferHls: true
-                waited += stepNs
+                )
-            }
+                let maxWaitNs: UInt64 = 18_000_000_000
-            if !av.isPlaying || av.hasError {
+                let stepNs: UInt64 = 200_000_000
-                error = av.errorMessage
+                var waited: UInt64 = 0
-                    ?? "Kon deze ClearKey-livestream niet starten."
+                while waited < maxWaitNs && !vlc.isPlaying && !vlc.hasError {
+                    try? await Task.sleep(nanoseconds: stepNs)
+                    waited += stepNs
+                }
+                if vlc.hasError || !vlc.isPlaying {
+                    error = vlc.errorMessage ?? "Kon deze ClearKey-livestream niet starten."
+                }
+            } else {
+                clearKeyPreferAV = true
+                await av.play(
+                    url: request.url,
+                    fallback: request.fallbackUrl,
+                    format: request.format,
+                    clearKeys: keys
+                )
+                let maxWaitNs: UInt64 = 18_000_000_000
+                let stepNs: UInt64 = 200_000_000
+                var waited: UInt64 = 0
+                while waited < maxWaitNs && !av.hasError {
+                    if av.isPlaying { break }
+                    try? await Task.sleep(nanoseconds: stepNs)
+                    waited += stepNs
+                }
+                if av.isPlaying && !av.hasError {
+                    loading = false
+                    return
+                }
+                let avFailHint = av.errorMessage
+                av.stop()
+                clearKeyPreferAV = false
+                try? await Task.sleep(nanoseconds: 250_000_000)
+                await vlc.playLive(
+                    url: request.url,
+                    fallback: request.fallbackUrl,
+                    format: request.format,
+                    clearKeys: keys,
+                    preferHls: true
+                )
+                waited = 0
+                while waited < 8_000_000_000 && !vlc.isPlaying && !vlc.hasError {
+                    try? await Task.sleep(nanoseconds: stepNs)
+                    waited += stepNs
+                }
+                if vlc.hasError || !vlc.isPlaying {
+                    error = vlc.errorMessage
+                        ?? avFailHint
+                        ?? "Kon deze ClearKey-livestream niet starten."
+                }
             }
         } else if isLive {
             await vlc.playLive(
@@ -477,6 +648,8 @@ struct PlayerScreen: View {
             }
             if vlc.hasError {
                 error = vlc.errorMessage ?? "Kon deze livestream niet starten."
+            } else if !vlc.isPlaying {
+                error = vlc.errorMessage ?? "Livestream startte niet (geen beeld/geluid)."
             }
         } else {
             vlc.play(url: request.url, startMs: request.startMs, subtitleFileURL: request.subtitleFileURL)
@@ -560,18 +733,6 @@ struct PlayerScreen: View {
             subsError = error.localizedDescription
         }
     }
-
-    private static func fittedVideoSize(in container: CGSize, aspect: CGFloat) -> CGSize {
-        guard container.width > 0, container.height > 0, aspect > 0 else { return container }
-        let containerAspect = container.width / container.height
-        if containerAspect > aspect {
-            let h = container.height
-            return CGSize(width: h * aspect, height: h)
-        } else {
-            let w = container.width
-            return CGSize(width: w, height: w / aspect)
-        }
-    }
 }
 
 struct PlayLauncher: View {
@@ -583,6 +744,7 @@ struct PlayLauncher: View {
     let episodeId: String?
     let seriesId: String?
     let startMs: Int64
+    var logoUrl: String? = nil
 
     @State private var request: PlayRequest?
     @State private var error: String?
@@ -594,7 +756,7 @@ struct PlayLauncher: View {
             if let request {
                 PlayerScreen(request: request)
             } else if loading {
-                ProgressView("Stream voorbereiden…").tint(.white).foregroundStyle(.white)
+                PlayerLoadingChrome(logoUrl: logoUrl, status: "Stream voorbereiden…")
             } else if let error {
                 VStack(spacing: 12) {
                     Text(error).foregroundStyle(McColors.danger).multilineTextAlignment(.center).padding()
@@ -634,7 +796,8 @@ struct PlayLauncher: View {
             request = .vod(
                 url: url, title: title, mediaType: mediaType, mediaFileId: mediaFileId,
                 movieId: movieId, episodeId: episodeId, seriesId: seriesId, startMs: startMs,
-                subtitleFileURL: subtitleURL
+                subtitleFileURL: subtitleURL,
+                logoUrl: logoUrl
             )
             loading = false
         } catch {
@@ -643,3 +806,65 @@ struct PlayLauncher: View {
         }
     }
 }
+
+/// Centraal logo (provider / film / serie) met zachte pulse i.p.v. kale ProgressView.
+struct PlayerLoadingChrome: View {
+    let logoUrl: String?
+    let status: String
+    @State private var pulse = false
+    @State private var glow = false
+
+    private var hasLogo: Bool {
+        guard let logoUrl, !logoUrl.isEmpty, URL(string: logoUrl) != nil else { return false }
+        return true
+    }
+
+    var body: some View {
+        ZStack {
+            Color.black.opacity(0.55).ignoresSafeArea()
+
+            VStack(spacing: 22) {
+                if hasLogo {
+                    ZStack {
+                        Circle()
+                            .fill(
+                                RadialGradient(
+                                    colors: [
+                                        Color.white.opacity(glow ? 0.18 : 0.06),
+                                        Color.clear,
+                                    ],
+                                    center: .center,
+                                    startRadius: 8,
+                                    endRadius: 140
+                                )
+                            )
+                            .frame(width: 280, height: 280)
+                            .scaleEffect(glow ? 1.08 : 0.92)
+
+                        RemoteImage(url: logoUrl, contentMode: .fit, opaqueBackground: false)
+                            .frame(maxWidth: 240, maxHeight: 96)
+                            .scaleEffect(pulse ? 1.04 : 0.96)
+                            .opacity(pulse ? 1.0 : 0.72)
+                            .shadow(color: .black.opacity(0.55), radius: 18, y: 8)
+                    }
+                    .onAppear {
+                        withAnimation(.easeInOut(duration: 1.25).repeatForever(autoreverses: true)) {
+                            pulse = true
+                            glow = true
+                        }
+                    }
+                } else {
+                    ProgressView()
+                        .tint(.white)
+                        .scaleEffect(1.2)
+                }
+
+                Text(status)
+                    .font(McFonts.caption)
+                    .foregroundStyle(.white.opacity(0.85))
+                    .multilineTextAlignment(.center)
+                    .padding(.horizontal, 28)
+            }
+        }
+    }
+}

apps/ios/VMC/Playback/VLCPlayerController.swift

@@ -24,6 +24,8 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     @Published var currentAudioId: String = ""
     @Published var pipPossible = false
     @Published var pipActive = false
+    /// VOD / F1-replay via playLive: finite duration + VLC seekable.
+    @Published var canSeek = false
 
     static let offSubtitleId = PlayerTrack.offId
 
@@ -32,9 +34,12 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     private let drawableHost = VLCPipDrawableHost()
     /// Plain UIView-target voor live/ClearKey (PiP sample-buffer-vout breekt DASH/proxy).
     private weak var plainVideoView: UIView?
+    /// Sterke ref zolang er gespeeld wordt — voorkomt crash als SwiftUI de surface al freeggeeft.
+    private var retainedSurface: UIView?
     private var lengthMs: Int32 = 0
     private var tick: AnyCancellable?
     private var clearKeyProxyActive = false
+    private var clearKeyProxySession = 0
     private var liveMode = false
     private var livePlayURL: URL?
     private var livePlayFormat: String?
@@ -45,9 +50,14 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     private var sceneObserver: NSObjectProtocol?
     /// Voorkomt herhaald `drawable=` bij SwiftUI-ticks (audio-zonder-beeld).
     private weak var attachedView: UIView?
-    /// VOD: plain UIView voor FreeType-subs; PiP-drawable alleen bij PiP-start.
+    /// VOD: altijd PiP-capable drawable (officieel VLCKit-patroon). Live/ClearKey: plain UIView.
     private var usePipDrawable = false
     private var stopping = false
+    private var stopGeneration = 0
+    private var didApplyPreferredAudio = false
+    private var knownVodDurationMs: Int64 = 0
+    /// Playlist is geknipt vanaf dit punt (VLC-tijd 0 = deze offset).
+    private var seekOriginMs: Int64 = 0
 
     override init() {
         // Shared library = alle demux/access plugins (DASH adaptive in VLC 4).
@@ -64,45 +74,109 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
         if let sceneObserver {
             NotificationCenter.default.removeObserver(sceneObserver)
         }
-        mediaPlayer.drawable = nil
         mediaPlayer.stop()
+        mediaPlayer.drawable = nil
         if clearKeyProxyActive {
-            ClearKeyDashProxy.shared.stop()
+            ClearKeyDashProxy.shared.stop(session: clearKeyProxySession)
         }
     }
 
     func attach(to view: UIView) {
-        if attachedView === view { return }
+        guard !stopping else { return }
         attachedView = view
         plainVideoView = view
+        retainedSurface = view
         view.backgroundColor = .black
-        applyDrawable()
+
+        // PiP-restore: container mag wisselen zonder mediaPlayer.drawable te resetten.
+        if usePipDrawable, mediaPlayer.drawable as AnyObject? === drawableHost {
+            drawableHost.attach(to: view)
+            return
+        }
+        if mediaPlayer.drawable as AnyObject? === view {
+            return
+        }
+        // Nooit mid-play herbinden als er al een geldige drawable hangt.
+        if mediaPlayer.drawable != nil, mediaPlayer.media != nil {
+            if usePipDrawable {
+                drawableHost.attach(to: view)
+            }
+            return
+        }
+        applyDrawable(force: mediaPlayer.drawable == nil)
     }
 
-    /// Live/ClearKey of VOD-inline → plain UIView (FreeType). PiP → sample-buffer drawable.
+    /// Layout-callback: bind alleen als size OK; sta herstel toe als eerder op 0×0 gebonden.
-    private func applyDrawable() {
+    func surfaceDidLayout(_ view: UIView) {
-        guard let view = plainVideoView else { return }
+        guard !stopping else { return }
-        let wantPip = usePipDrawable && !liveMode && !clearKeyProxyActive
+        plainVideoView = view
-        if wantPip {
+        attachedView = view
+        retainedSurface = view
+        guard view.bounds.width > 1, view.bounds.height > 1 else { return }
+
+        if usePipDrawable, mediaPlayer.drawable as AnyObject? === drawableHost {
             drawableHost.attach(to: view)
-            if mediaPlayer.drawable as AnyObject? !== drawableHost {
+            return
+        }
+        if mediaPlayer.drawable == nil {
+            applyDrawable(force: true)
+        }
+    }
+
+    /// Live/ClearKey → plain UIView. VOD → VLCPipDrawableHost (PiP vanaf start).
+    private func applyDrawable(force: Bool = false) {
+        guard !stopping else { return }
+        guard let view = plainVideoView else { return }
+        // Nooit binden op 0×0 — VLC opent dan vout zonder beeld (audio-only).
+        guard view.bounds.width > 1, view.bounds.height > 1 else { return }
+        let wantPipHost = !liveMode && !clearKeyProxyActive
+        usePipDrawable = wantPipHost
+        if wantPipHost {
+            drawableHost.attach(to: view)
+            if force || mediaPlayer.drawable as AnyObject? !== drawableHost {
                 mediaPlayer.drawable = drawableHost
             }
+            if pipWindow != nil {
+                pipPossible = AVPictureInPictureController.isPictureInPictureSupported()
+            }
         } else {
+            // ClearKey/live: plain UIView. Nooit detach/rebind als al gezet tijdens play.
+            if mediaPlayer.drawable as AnyObject? === view, !force { return }
+            if mediaPlayer.media != nil, mediaPlayer.drawable != nil, !force { return }
             drawableHost.detachVideo()
-            if mediaPlayer.drawable as AnyObject? !== view {
+            mediaPlayer.drawable = view
-                mediaPlayer.drawable = view
+            pipPossible = false
-            }
-            if liveMode || clearKeyProxyActive {
-                pipPossible = false
-            }
         }
     }
 
     func startPictureInPicture() {
-        preparePipDrawableThen {
+        guard !liveMode, !clearKeyProxyActive, !stopping else { return }
-            self.pipWindow?.startPictureInPicture()
+        // FreeType-subs zitten niet in VLCKit sample-buffer PiP (Apple/VLC-beperking).
+        if currentSubtitleId != PlayerTrack.offId {
+            stateText = "PiP zonder ondertiteling"
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2.5) { [weak self] in
+                guard let self, !self.stopping, self.stateText == "PiP zonder ondertiteling" else { return }
+                self.stateText = self.isPlaying ? "Afspelen" : self.stateText
+            }
         }
+        if let pipWindow {
+            pipWindow.startPictureInPicture()
+            return
+        }
+        applyDrawable(force: true)
+        let gen = stopGeneration
+        var attempts = 0
+        func tryStart() {
+            guard self.stopGeneration == gen, !self.stopping else { return }
+            guard !self.liveMode, !self.clearKeyProxyActive else { return }
+            attempts += 1
+            if let win = self.pipWindow {
+                win.startPictureInPicture()
+            } else if attempts < 20 {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: tryStart)
+            }
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2, execute: tryStart)
     }
 
     func stopPictureInPicture() {
@@ -114,44 +188,23 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
         else { startPictureInPicture() }
     }
 
-    private func preparePipDrawableThen(_ work: @escaping () -> Void) {
-        if usePipDrawable, pipWindow != nil {
-            work()
-            return
-        }
-        usePipDrawable = true
-        applyDrawable()
-        // pictureInPictureReady komt async; kort wachten op pipWindow.
-        var attempts = 0
-        func tryStart() {
-            attempts += 1
-            if self.pipWindow != nil || attempts >= 12 {
-                work()
-            } else {
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: tryStart)
-            }
-        }
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.15, execute: tryStart)
-    }
-
-    private func restorePlainDrawableAfterPip() {
-        guard !liveMode, !clearKeyProxyActive, !stopping else { return }
-        usePipDrawable = false
-        applyDrawable()
-        applySubtitleStyle()
-    }
-
     func play(url: URL, startMs: Int64 = 0, subtitleFileURL: URL? = nil) {
+        // Annuleer pending finishStop van eerdere/spurious onDisappear.
+        stopGeneration &+= 1
+        stopping = false
         hasError = false
         errorMessage = nil
         stateText = "Verbinden…"
         subtitleTracks = []
         audioTracks = []
+        canSeek = false
+        didApplyPreferredAudio = false
+        knownVodDurationMs = 0
+        seekOriginMs = 0
         liveMode = false
         clearKeyProxyActive = false
-        usePipDrawable = false
+        plainVideoView?.layoutIfNeeded()
-        applyDrawable()
+        applyDrawable(force: true)
-        // PiP-knop tonen; drawable wisselt pas bij PiP-start (FreeType blijft werken).
         pipPossible = AVPictureInPictureController.isPictureInPictureSupported()
         guard let media = VLCMedia(url: url) else {
             hasError = true
@@ -160,35 +213,38 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
             return
         }
         media.delegate = self
-        media.addOption(":network-caching=2500")
+        media.addOption(":network-caching=2000")
         media.addOption(":http-reconnect")
         media.addOption(":avcodec-hw=any")
-        media.addOption(":sout-mux-caching=1500")
+        media.addOption(":sout-mux-caching=1200")
         media.addOption(":sub-track=0")
         media.addOption(":freetype-rel-fontsize=\(Self.subtitleRelFontSize)")
         media.addOption(":freetype-bold=1")
+        media.addOption(":sub-margin=0")
         mediaPlayer.media = media
-        // VLCKit 4: parse is on VLCMediaParser, not VLCMedia
         _ = VLCMediaParser.shared().queue(
             media,
-            options: VLCMediaParsingOptions(rawValue: 0x02 | 0x08) // network + fetchLocal
+            options: VLCMediaParsingOptions(rawValue: 0x02 | 0x08)
         )
         mediaPlayer.play()
         applySubtitleStyle()
         if startMs > 2000 {
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) { [weak self] in
-                self?.seek(toMs: startMs)
+                guard let self, !self.stopping else { return }
+                self.seek(toMs: startMs)
             }
         }
         if let subtitleFileURL {
             DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) { [weak self] in
-                self?.addExternalSubtitle(url: subtitleFileURL)
+                guard let self, !self.stopping else { return }
+                self.addExternalSubtitle(url: subtitleFileURL)
             }
         }
         startTicker()
         DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) { [weak self] in
-            self?.refreshTracks()
+            guard let self, !self.stopping else { return }
-            self?.applySubtitleStyle()
+            self.refreshTracks()
+            self.applySubtitleStyle()
         }
     }
 
@@ -196,29 +252,55 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
         url: URL,
         fallback: URL? = nil,
         format: String? = nil,
-        clearKeys: [ClearKeyEntry] = []
+        clearKeys: [ClearKeyEntry] = [],
+        preferHls: Bool = false
     ) async {
+        // Annuleer pending finishStop / delayed proxy-stop van vorige sessie.
+        stopGeneration &+= 1
+        let playGen = stopGeneration
+        stopping = false
         hasError = false
         errorMessage = nil
         stateText = "Live laden…"
         liveRetryCount = 0
         everPlayed = false
         liveStartedAt = Date()
+        canSeek = false
+        didApplyPreferredAudio = false
+        knownVodDurationMs = 0
+        seekOriginMs = 0
         liveMode = true
         usePipDrawable = false
+        pipPossible = false
 
         var playURL = url
         var playFormat = format
         clearKeyProxyActive = false
+        var proxySession = 0
 
         if !clearKeys.isEmpty {
             do {
                 stateText = "ClearKey laden…"
-                // Async: blokkeer de main thread niet (watchdog-crash).
+                let started = try await ClearKeyDashProxy.shared.start(
-                // HLS (ESPN) én DASH (Prime) via dezelfde proxy.
+                    manifestURL: url,
-                let started = try await ClearKeyDashProxy.shared.start(manifestURL: url, keys: clearKeys)
+                    keys: clearKeys,
+                    preferHlsForAVPlayer: preferHls
+                )
                 playURL = started.url
-                playFormat = ClearKeyDashProxy.isHlsURL(url) ? "hls" : "dash"
+                proxySession = started.session
+                if started.vodDurationMs > 3000 {
+                    knownVodDurationMs = started.vodDurationMs
+                    let clamped = Int32(min(started.vodDurationMs, Int64(Int32.max)))
+                    lengthMs = clamped
+                    lengthText = Self.format(ms: clamped)
+                    canSeek = true
+                }
+                // Lokale clear-HLS of remote HLS.
+                if preferHls || ClearKeyDashProxy.isHlsURL(started.url) || ClearKeyDashProxy.isHlsURL(url) {
+                    playFormat = "hls"
+                } else {
+                    playFormat = "dash"
+                }
                 clearKeyProxyActive = true
             } catch {
                 hasError = true
@@ -228,21 +310,48 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
             }
         }
 
-        applyDrawable()
+        guard stopGeneration == playGen, !stopping else { return }
+
+        await waitForSurface(timeout: 2.0)
+        await MainActor.run {
+            plainVideoView?.layoutIfNeeded()
+            applyDrawable(force: true)
+        }
+        guard stopGeneration == playGen, !stopping else { return }
+
         livePlayURL = playURL
         livePlayFormat = playFormat
+        clearKeyProxySession = proxySession
         startLiveMedia(url: playURL, format: playFormat)
 
         if let fallback, clearKeys.isEmpty {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 8) { [weak self] in
+            let gen = stopGeneration
-                guard let self, !self.isPlaying || self.hasError else { return }
+            // Snellere fallback: IPTV-HLS faalt vaak stil; probeer binnen 3.5s de fallback.
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3.5) { [weak self] in
+                guard let self, self.stopGeneration == gen, !self.stopping else { return }
+                guard !self.everPlayed else { return }
+                guard !self.isPlaying || self.hasError else { return }
+                self.stateText = "Fallback…"
                 self.startLiveMedia(url: fallback, format: nil)
             }
         }
         startTicker()
     }
 
+    private func waitForSurface(timeout: TimeInterval) async {
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            let ready = await MainActor.run { () -> Bool in
+                guard let view = plainVideoView else { return false }
+                return view.bounds.width > 1 && view.bounds.height > 1
+            }
+            if ready { return }
+            try? await Task.sleep(nanoseconds: 40_000_000)
+        }
+    }
+
     private func startLiveMedia(url: URL, format: String?) {
+        guard !stopping else { return }
         guard let media = VLCMedia(url: url) else {
             hasError = true
             errorMessage = "Kon live-stream niet openen."
@@ -250,10 +359,28 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
             return
         }
         media.delegate = self
-        Self.applyLiveOptions(to: media, url: url, format: format)
+        Self.applyLiveOptions(
+            to: media,
+            url: url,
+            format: format,
+            viaLocalProxy: clearKeyProxyActive,
+            asVod: knownVodDurationMs > 3000
+        )
+        // Drawable één keer vóór play — nooit opnieuw mid-stream (audio-only / crash).
+        if mediaPlayer.drawable == nil {
+            applyDrawable(force: true)
+        }
         mediaPlayer.media = media
         mediaPlayer.play()
-        applySubtitleStyle()
+        let gen = stopGeneration
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.6) { [weak self] in
+            guard let self, self.stopGeneration == gen, !self.stopping else { return }
+            self.refreshTracks()
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 4.0) { [weak self] in
+            guard let self, self.stopGeneration == gen, !self.stopping else { return }
+            self.refreshTracks()
+        }
     }
 
     private func dutchClearKeyError(_ error: Error) -> String {
@@ -274,16 +401,16 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     }
 
     private func retryLiveIfNeeded() {
-        guard clearKeyProxyActive, !everPlayed, liveRetryCount < 2 else { return }
+        guard liveMode, !everPlayed, liveRetryCount < 2 else { return }
         guard let url = livePlayURL else { return }
         let elapsed = Date().timeIntervalSince(liveStartedAt ?? Date())
-        guard elapsed < 12 else { return }
+        guard elapsed < 14 else { return }
         liveRetryCount += 1
         stateText = "Opnieuw verbinden…"
         hasError = false
         errorMessage = nil
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.6) { [weak self] in
-            guard let self, self.clearKeyProxyActive else { return }
+            guard let self, self.liveMode, !self.stopping else { return }
             self.startLiveMedia(url: url, format: self.livePlayFormat)
         }
     }
@@ -291,16 +418,31 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     private static func applyLiveOptions(
         to media: VLCMedia,
         url: URL,
-        format: String?
+        format: String?,
+        viaLocalProxy: Bool,
+        asVod: Bool = false
     ) {
-        media.addOption(":network-caching=1800")
+        // Stabiele live-start: te lage caching + drop-late-frames liet streams meteen stoppen.
+        // VOD (F1-replay): géén live-caching, anders blijft VLC isSeekable=false / duur=0.
+        if asVod {
+            media.addOption(":network-caching=1500")
+        } else if viaLocalProxy {
+            media.addOption(":network-caching=1200")
+            media.addOption(":live-caching=1000")
+        } else {
+            media.addOption(":network-caching=1000")
+            media.addOption(":live-caching=800")
+        }
         media.addOption(":http-reconnect")
-        media.addOption(":live-caching=1500")
         media.addOption(":avcodec-hw=any")
         media.addOption(":freetype-rel-fontsize=\(subtitleRelFontSize)")
+        // IPTV/CDN's weigeren soms exotic UA's.
+        media.addOption(":http-user-agent=VLC/3.0.21 LibVLC/3.0.21")
         // VLC 4: unified adaptive demux (DASH+HLS). Forceer GEEN :demux=dash (VLC3-module).
         media.addOption(":adaptive-logic=highest")
-        media.addOption(":adaptive-use-access")
+        if !viaLocalProxy {
+            media.addOption(":adaptive-use-access")
+        }
 
         let fmt = (format ?? "").lowercased()
         let path = url.absoluteString.lowercased()
@@ -317,18 +459,44 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     }
 
     func seek(toMs: Int64) {
-        mediaPlayer.time = VLCTime(number: NSNumber(value: toMs))
+        let target = max(0, toMs)
+        if knownVodDurationMs > 3000, clearKeyProxyActive, let base = livePlayURL {
+            let endPad = max(knownVodDurationMs - 1500, 0)
+            let clamped = min(target, endPad)
+            seekOriginMs = clamped
+            ClearKeyDashProxy.shared.setPlaybackStartOffset(ms: clamped)
+            var comps = URLComponents(url: base, resolvingAgainstBaseURL: false)
+            var items = (comps?.queryItems ?? []).filter { $0.name != "vmcSeek" }
+            items.append(URLQueryItem(name: "vmcSeek", value: String(clamped)))
+            comps?.queryItems = items
+            if let url = comps?.url {
+                position = knownVodDurationMs > 0 ? Float(Double(clamped) / Double(knownVodDurationMs)) : 0
+                timeText = Self.format(ms: Int32(min(clamped, Int64(Int32.max))))
+                startLiveMedia(url: url, format: livePlayFormat)
+                invalidatePipPlaybackState()
+                return
+            }
+        }
+        mediaPlayer.time = VLCTime(number: NSNumber(value: target))
         invalidatePipPlaybackState()
     }
 
     func seek(ratio: Float) {
+        let dur = durationMs()
+        if dur > 3000 {
+            seek(toMs: Int64(Double(dur) * Double(min(max(ratio, 0), 1))))
+            return
+        }
         mediaPlayer.position = Double(ratio)
         invalidatePipPlaybackState()
     }
 
-    func currentPositionMs() -> Int64 { Int64(mediaPlayer.time.intValue) }
+    func currentPositionMs() -> Int64 {
+        Int64(mediaPlayer.time.intValue) + seekOriginMs
+    }
 
     func durationMs() -> Int64 {
+        if knownVodDurationMs > 3000 { return knownVodDurationMs }
         let v = mediaPlayer.media?.length.intValue ?? lengthMs
         return Int64(max(v, 0))
     }
@@ -356,13 +524,9 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
         if pipActive {
             stopPictureInPicture()
         }
-        if usePipDrawable {
-            usePipDrawable = false
-            applyDrawable()
-        }
         _ = mediaPlayer.addPlaybackSlave(url, type: .subtitle, enforce: true)
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
-            guard let self else { return }
+            guard let self, !self.stopping else { return }
             self.refreshTracks()
             self.applySubtitleStyle()
             if let last = self.subtitleTracks.last(where: { $0.id != PlayerTrack.offId }) {
@@ -383,7 +547,7 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
 
     func refreshTracks() {
         // VLCKit 4 kan crashen op track-API tijdens error/opening — altijd defensief.
-        guard mediaPlayer.media != nil else {
+        guard !stopping, mediaPlayer.media != nil else {
             subtitleTracks = [PlayerTrack(id: PlayerTrack.offId, name: "Uit")]
             audioTracks = []
             return
@@ -425,6 +589,40 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
         }
         audioTracks = audios
         currentAudioId = selectedAudio
+        applyPreferredAudioIfNeeded()
+    }
+
+    private func applyPreferredAudioIfNeeded() {
+        guard !didApplyPreferredAudio else { return }
+        let list = mediaPlayer.audioTracks
+        guard !list.isEmpty else { return }
+        didApplyPreferredAudio = true
+        let ranked = list.enumerated().map { i, t in
+            (track: t, score: Self.audioPreferenceScore(language: t.language, name: t.trackName, description: t.trackDescription, index: i))
+        }
+        guard let best = ranked.max(by: { $0.score < $1.score }), best.score > 0 else { return }
+        if !best.track.isSelected {
+            best.track.isSelectedExclusively = true
+        }
+        currentAudioId = best.track.trackId
+    }
+
+    /// NL eerst, anders Engels. Geen match → 0 (niet forceren).
+    static func audioPreferenceScore(language: String?, name: String?, description: String?, index: Int) -> Int {
+        let blob = [language, name, description]
+            .compactMap { $0?.lowercased() }
+            .joined(separator: " ")
+        if blob.isEmpty { return 0 }
+        let nl = ["nederlands", "dutch", " holland", "nl ", "dut", "nld"]
+        if nl.contains(where: { blob.contains($0) }) || blob == "nl" || blob.hasPrefix("nl-") || blob.hasPrefix("nl_") {
+            return 100 - index
+        }
+        let en = ["engels", "english", "international", "eng", "en "]
+        if en.contains(where: { blob.contains($0) }) || blob == "en" || blob.hasPrefix("en-") || blob.hasPrefix("en_")
+            || blob == "eng" {
+            return 50 - index
+        }
+        return 0
     }
 
     private enum TrackKind { case subtitle, audio }
@@ -540,49 +738,85 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     func stop() {
         guard !stopping else { return }
         stopping = true
+        stopGeneration &+= 1
+        let gen = stopGeneration
+        let proxySession = clearKeyProxySession
         tick?.cancel()
         tick = nil
 
         let proxyWasActive = clearKeyProxyActive
+        let wasPip = pipActive
         clearKeyProxyActive = false
-
+        clearKeyProxySession = 0
-        // Drawable los vóór stop — voorkomt crash als SwiftUI de UIView al vrijgeeft.
-        mediaPlayer.drawable = nil
-        drawableHost.detachVideo()
-        attachedView = nil
-        plainVideoView = nil
-
-        if pipActive {
-            pipWindow?.stopPictureInPicture()
-        }
-        pipWindow = nil
         pipPossible = false
-        pipActive = false
-        usePipDrawable = false
 
-        mediaPlayer.stop()
+        // PiP eerst netjes stoppen en wachten — sync nil + media stop = EXC_BAD_ACCESS (SwiftVLC #20).
-        mediaPlayer.media = nil
+        if wasPip {
-        livePlayURL = nil
+            pipWindow?.stopPictureInPicture()
-        livePlayFormat = nil
+            pipActive = false
-        liveStartedAt = nil
+            finishStop(gen: gen, proxyWasActive: proxyWasActive, proxySession: proxySession, delay: 0.85)
-        liveRetryCount = 0
+            return
-        everPlayed = false
+        }
-        liveMode = false
+        finishStop(gen: gen, proxyWasActive: proxyWasActive, proxySession: proxySession, delay: 0.05)
+    }
 
-        if proxyWasActive {
+    private func finishStop(gen: Int, proxyWasActive: Bool, proxySession: Int, delay: TimeInterval) {
-            // Laat in-flight HTTP van VLC even afronden vóór listener-cancel.
+        let work = { [weak self] in
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            guard let self else { return }
-                ClearKeyDashProxy.shared.stop()
+            // Nieuwe play() heeft generation gebumpt of stopping gereset → niet meer tear-down'en.
+            guard self.stopGeneration == gen, self.stopping else { return }
+
+            self.pipWindow = nil
+            self.pipActive = false
+            self.usePipDrawable = false
+
+            self.mediaPlayer.stop()
+            self.mediaPlayer.media = nil
+
+            self.mediaPlayer.drawable = nil
+            self.drawableHost.detachVideo()
+            self.attachedView = nil
+            self.plainVideoView = nil
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                guard let self, self.stopGeneration == gen else { return }
+                self.retainedSurface = nil
+            }
+
+            self.livePlayURL = nil
+            self.livePlayFormat = nil
+            self.liveStartedAt = nil
+            self.liveRetryCount = 0
+            self.everPlayed = false
+            self.liveMode = false
+            self.canSeek = false
+            self.didApplyPreferredAudio = false
+            self.knownVodDurationMs = 0
+            self.seekOriginMs = 0
+            self.isPlaying = false
+            self.hasError = false
+            self.errorMessage = nil
+            self.stateText = "Gestopt"
+            self.subtitleTracks = [PlayerTrack(id: PlayerTrack.offId, name: "Uit")]
+            self.audioTracks = []
+
+            if proxyWasActive, proxySession > 0 {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
+                    ClearKeyDashProxy.shared.stop(session: proxySession)
+                }
             }
         }
-        stopping = false
+        if delay > 0 {
+            DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: work)
+        } else {
+            work()
+        }
     }
 
     // MARK: - VLCMediaPlayerDelegate (VLCKit 4)
 
     func mediaPlayerStateChanged(_ newState: VLCMediaPlayerState) {
         DispatchQueue.main.async { [weak self] in
-            guard let self else { return }
+            guard let self, !self.stopping else { return }
             self.isPlaying = self.mediaPlayer.isPlaying
             if self.pipPossible {
                 self.invalidatePipPlaybackState()
@@ -594,49 +828,65 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
                 self.hasError = false
                 self.errorMessage = nil
                 self.everPlayed = true
-                self.refreshTracks()
+                // Geen drawable-rebind hier — dat maakte ClearKey audio-only + crash.
-                self.applySubtitleStyle()
+                if !self.liveMode {
+                    self.refreshTracks()
+                    self.applySubtitleStyle()
+                }
             case .paused: self.stateText = "Pauze"
             case .stopped, .stopping:
-                if self.clearKeyProxyActive && !self.everPlayed {
+                if self.liveMode && !self.everPlayed {
                     self.stateText = "Verbinden…"
                     self.retryLiveIfNeeded()
                 } else if !self.hasError {
                     self.stateText = "Gestopt"
                 }
             case .error:
-                if self.clearKeyProxyActive && !self.everPlayed && self.liveRetryCount < 2 {
+                if self.liveMode && !self.everPlayed && self.liveRetryCount < 2 {
                     self.stateText = "Opnieuw…"
                     self.retryLiveIfNeeded()
                 } else {
                     self.hasError = true
                     self.errorMessage = self.clearKeyProxyActive
                         ? "Kon deze ClearKey-livezender niet afspelen. Controleer netwerk of probeer opnieuw."
-                        : "Kon dit bestand niet afspelen"
+                        : (self.liveMode
+                           ? "Kon deze livestream niet openen."
+                           : "Kon dit bestand niet afspelen")
                     self.stateText = "Fout"
                 }
-            @unknown default: break
+            case .nothingSpecial:
+                break
+            @unknown default:
+                break
             }
         }
     }
 
     func mediaPlayerTrackAdded(_ trackId: String, with type: VLCMedia.TrackType) {
-        DispatchQueue.main.async { [weak self] in self?.refreshTracks() }
+        DispatchQueue.main.async { [weak self] in
+            guard let self, !self.stopping, !self.liveMode else { return }
+            self.refreshTracks()
+        }
     }
 
     func mediaPlayerTrackUpdated(_ trackId: String, with type: VLCMedia.TrackType) {
-        DispatchQueue.main.async { [weak self] in self?.refreshTracks() }
+        DispatchQueue.main.async { [weak self] in
+            guard let self, !self.stopping, !self.liveMode else { return }
+            self.refreshTracks()
+        }
     }
 
     func mediaPlayerLengthChanged(_ length: Int64) {
         DispatchQueue.main.async { [weak self] in
-            self?.invalidatePipPlaybackState()
+            guard let self, !self.stopping else { return }
+            self.invalidatePipPlaybackState()
         }
     }
 
     func mediaDidFinishParsing(_ aMedia: VLCMedia) {
         DispatchQueue.main.async { [weak self] in
-            self?.refreshTracks()
+            guard let self, !self.stopping, !self.liveMode else { return }
+            self.refreshTracks()
         }
     }
 
@@ -650,13 +900,21 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     }
 
     private func refreshTime() {
-        let t = mediaPlayer.time.intValue
+        guard !stopping else { return }
+        let t = Int64(mediaPlayer.time.intValue) + seekOriginMs
         let l = mediaPlayer.media?.length.intValue ?? 0
-        if l > 0 { lengthMs = l }
+        if knownVodDurationMs > 3000 {
-        position = Float(mediaPlayer.position)
+            lengthMs = Int32(min(knownVodDurationMs, Int64(Int32.max)))
-        timeText = Self.format(ms: t)
+            position = Float(Double(t) / Double(knownVodDurationMs))
+        } else {
+            if l > 0 { lengthMs = l }
+            position = Float(mediaPlayer.position)
+        }
+        timeText = Self.format(ms: Int32(min(max(t, 0), Int64(Int32.max))))
         lengthText = Self.format(ms: lengthMs)
         isPlaying = mediaPlayer.isPlaying
+        let seekable = (knownVodDurationMs > 3000 || mediaPlayer.isSeekable) && lengthMs > 3000
+        if seekable != canSeek { canSeek = seekable }
     }
 
     private static func format(ms: Int32) -> String {
@@ -671,14 +929,39 @@ final class VLCPlayerController: NSObject, ObservableObject, VLCMediaPlayerDeleg
     // MARK: - PiP / audio
 
     fileprivate func onPictureInPictureReady(_ controller: VLCPictureInPictureWindowControlling) {
+        guard !stopping, !liveMode, !clearKeyProxyActive else { return }
         pipWindow = controller
-        pipPossible = true
+        pipPossible = AVPictureInPictureController.isPictureInPictureSupported()
         controller.stateChangeEventHandler = { [weak self] isStarted in
             DispatchQueue.main.async {
                 guard let self else { return }
+                if self.stopping {
+                    self.pipActive = false
+                    return
+                }
+                let wasActive = self.pipActive
                 self.pipActive = isStarted
-                if !isStarted {
+                if wasActive && !isStarted {
-                    self.restorePlainDrawableAfterPip()
+                    // PiP-X gesloten: herkoppel video-subview aan inline surface (geen drawable-reset).
+                    if let view = self.plainVideoView ?? self.retainedSurface {
+                        self.drawableHost.attach(to: view)
+                    }
+                    // Opnieuw FreeType/subs activeren na terugkeer uit PiP.
+                    if self.currentSubtitleId != PlayerTrack.offId {
+                        self.selectSubtitle(id: self.currentSubtitleId)
+                    }
+                    self.applySubtitleStyle()
+                    self.invalidatePipPlaybackState()
+                }
+                if !wasActive && isStarted {
+                    // Net PiP gestart: forceer spu opnieuw (sample-buffer kan spu laten vallen).
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self] in
+                        guard let self, self.pipActive, !self.stopping else { return }
+                        if self.currentSubtitleId != PlayerTrack.offId {
+                            self.selectSubtitle(id: self.currentSubtitleId)
+                        }
+                        self.applySubtitleStyle()
+                    }
                 }
             }
         }
@@ -733,6 +1016,11 @@ final class VLCPipDrawableHost: NSObject, VLCDrawable, VLCPictureInPictureDrawab
     private weak var container: UIView?
     private var videoSubview: UIView?
 
+    var hasVideoSubview: Bool {
+        guard let videoSubview else { return false }
+        return videoSubview.superview != nil && videoSubview.bounds.width > 1
+    }
+
     func attach(to view: UIView) {
         container = view
         view.backgroundColor = .black
@@ -810,17 +1098,35 @@ final class VLCPipDrawableHost: NSObject, VLCDrawable, VLCPictureInPictureDrawab
     }
 }
 
+/// UIKit surface met layout-callback — voorkomt zero-bounds drawable (audio-only).
+final class VLCSurfaceView: UIView {
+    var onLayout: ((UIView) -> Void)?
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        onLayout?(self)
+    }
+}
+
 struct VLCVideoView: UIViewRepresentable {
     let controller: VLCPlayerController
 
-    func makeUIView(context: Context) -> UIView {
+    func makeUIView(context: Context) -> VLCSurfaceView {
-        let view = UIView()
+        let view = VLCSurfaceView()
         view.backgroundColor = .black
+        view.clipsToBounds = true
+        view.onLayout = { [weak controller] surface in
+            controller?.surfaceDidLayout(surface)
+        }
         controller.attach(to: view)
         return view
     }
 
-    func updateUIView(_ uiView: UIView, context: Context) {
+    func updateUIView(_ uiView: VLCSurfaceView, context: Context) {
-        // Geen herhaalde drawable-bind bij SwiftUI ticks (breekt video-vout / audio-only).
+        uiView.onLayout = { [weak controller] surface in
+            controller?.surfaceDidLayout(surface)
+        }
+        // Geen herhaalde drawable-bind bij SwiftUI ticks (breekt video-vout).
+        controller.attach(to: uiView)
     }
 }

apps/ios/VMC/UI/DetailScreens.swift

@@ -93,7 +93,8 @@ struct MovieDetailScreen: View {
                         movieId: movie.id,
                         episodeId: nil,
                         seriesId: nil,
-                        startMs: 0
+                        startMs: 0,
+                        logoUrl: movie.logoUrl
                     )
                     .environmentObject(app)
                 }
@@ -227,7 +228,8 @@ struct SeriesDetailScreen: View {
                         movieId: nil,
                         episodeId: target.episodeId,
                         seriesId: seriesId,
-                        startMs: target.startMs
+                        startMs: target.startMs,
+                        logoUrl: series.logoUrl
                     )
                     .environmentObject(app)
                 }

apps/ios/VMC/UI/EventsScreen.swift

@@ -19,6 +19,7 @@ struct EventsScreen: View {
     @EnvironmentObject private var app: AppModel
 
     @State private var events: [ScheduleEvent] = []
+    @State private var hubs: [EventHub] = []
     @State private var loading = true
     @State private var error: String?
     @State private var sportFilter: String?
@@ -93,6 +94,10 @@ struct EventsScreen: View {
                 EventDetailScreen(eventId: eventId)
                     .environmentObject(app)
             }
+            .navigationDestination(for: EventHubRoute.self) { route in
+                EventHubDestination(route: route)
+                    .environmentObject(app)
+            }
         }
         .task { await refresh() }
         .onAppear {
@@ -149,6 +154,9 @@ struct EventsScreen: View {
             ScrollView {
                 VStack(alignment: .leading, spacing: 22) {
                     headerBlock
+                    if !hubs.isEmpty {
+                        hubRow
+                    }
                     filterChips
                     if filtered.isEmpty {
                         emptyBlock
@@ -215,6 +223,20 @@ struct EventsScreen: View {
         .padding(.top, 8)
     }
 
+    private var hubRow: some View {
+        HStack(spacing: 12) {
+            ForEach(hubs) { hub in
+                if let route = EventHubRoute.forHub(hub.id) {
+                    NavigationLink(value: route) {
+                        EventHubEntryCard(hub: hub)
+                    }
+                    .buttonStyle(HubPressStyle())
+                }
+            }
+        }
+        .padding(.horizontal, 16)
+    }
+
     private var subtitleLine: String {
         if let sportFilter {
             return EventSport.label(for: sportFilter)
@@ -359,6 +381,9 @@ struct EventsScreen: View {
                 self.error = error.localizedDescription
             }
         }
+        if let list = try? await app.api.eventHubs() {
+            hubs = list.filter { EventHubRoute.forHub($0.id) != nil }
+        }
         loading = false
     }
 }
@@ -612,7 +637,8 @@ struct EventDetailScreen: View {
                     drm: item.info.drm,
                     watchSessionId: item.info.watchSessionId,
                     watchKind: "event",
-                    watchId: eventId
+                    watchId: eventId,
+                    logoUrl: item.info.logoUrl ?? event?.logoUrl
                 ))
                 .environmentObject(app)
             }

apps/ios/VMC/UI/LiveTvScreen.swift

@@ -134,7 +134,8 @@ struct LiveTvScreen: View {
                     drm: item.info.drm,
                     watchSessionId: item.info.watchSessionId,
                     watchKind: kind,
-                    watchId: item.info.streamId
+                    watchId: item.info.streamId,
+                    logoUrl: item.info.logoUrl
                 ))
                 .environmentObject(app)
             }

apps/ios/VMC/UI/SettingsScreen.swift

@@ -96,7 +96,7 @@ struct SettingsScreen: View {
 
             Section("Info") {
                 LabeledContent("App", value: "VMC iOS")
-                LabeledContent("Versie", value: "0.5.6")
+                LabeledContent("Versie", value: "0.5.49")
                 LabeledContent("Live TV", value: app.iptvEnabled ? "Aan" : "Uit")
                 LabeledContent("Events", value: app.eventsEnabled ? "Aan" : "Uit")
             }

apps/master-api/src/viewer/routes.ts

@@ -642,9 +642,9 @@ export function registerViewerRoutes(
 
   app.get("/api/v1/client/movies/:id", async (request) => {
     const auth = await viewers.authFromBearer(request.headers.authorization);
-    requireProfile(auth);
+    const profileId = requireProfile(auth);
     const { id } = request.params as { id: string };
-    return viewers.movieDetail(id, auth.profile?.isKids === true);
+    return viewers.movieDetail(id, auth.profile?.isKids === true, profileId);
   });
 
   app.get("/api/v1/client/series/:id", async (request) => {
@@ -684,8 +684,12 @@ export function registerViewerRoutes(
       hiddenFromContinue?: boolean;
     };
     if (!body.mediaType) throw new AppError("INVALID_REQUEST", "mediaType verplicht", 400);
+    const mediaType = String(body.mediaType).trim().toUpperCase();
+    if (mediaType !== "MOVIE" && mediaType !== "EPISODE") {
+      throw new AppError("INVALID_REQUEST", "mediaType moet MOVIE of EPISODE zijn", 400);
+    }
     const row = await viewers.upsertProgress(profileId, {
-      mediaType: body.mediaType,
+      mediaType: mediaType as "MOVIE" | "EPISODE",
       movieId: body.movieId,
       episodeId: body.episodeId,
       seriesId: body.seriesId,

apps/master-api/src/viewer/service.ts

@@ -2026,13 +2026,17 @@ export class ViewerService {
       hiddenFromContinue?: boolean;
     }
   ) {
+    const mediaType = String(body.mediaType || "").trim().toUpperCase();
+    if (mediaType !== "MOVIE" && mediaType !== "EPISODE") {
+      throw new AppError("INVALID_REQUEST", "mediaType moet MOVIE of EPISODE zijn", 400);
+    }
     const positionMs = Math.max(0, Math.floor(body.positionMs || 0));
     const durationMs = Math.max(0, Math.floor(body.durationMs || 0));
     const autoComplete =
       body.completed === true ||
       (durationMs > 0 && positionMs / durationMs >= 0.9);
 
-    if (body.mediaType === "MOVIE") {
+    if (mediaType === "MOVIE") {
       if (!body.movieId) throw new AppError("INVALID_REQUEST", "movieId verplicht", 400);
       const existingMovie = await prisma.watchProgress.findUnique({
         where: { profileId_movieId: { profileId, movieId: body.movieId } },
@@ -2523,7 +2527,7 @@ export class ViewerService {
     return this.getShelfPrefs(profileId);
   }
 
-  async movieDetail(movieId: string, kidsMode = false) {
+  async movieDetail(movieId: string, kidsMode = false, profileId?: string | null) {
     const movie = await prisma.movie.findUnique({
       where: { id: movieId },
       include: {
@@ -2552,6 +2556,12 @@ export class ViewerService {
         .catch(() => undefined);
     }
 
+    const progress = profileId
+      ? await prisma.watchProgress.findUnique({
+          where: { profileId_movieId: { profileId, movieId: movie.id } },
+        })
+      : null;
+
     return {
       type: "movie" as const,
       id: movie.id,
@@ -2567,6 +2577,10 @@ export class ViewerService {
       cast: extras.cast ?? [],
       director: extras.director ?? [],
       trailerYoutubeKey: extras.trailers?.[0]?.source ?? null,
+      positionMs: progress && !progress.completed ? progress.positionMs : 0,
+      durationMs: progress?.durationMs ?? 0,
+      completed: progress?.completed === true,
+      progressId: progress?.id ?? null,
       mediaFiles: movie.mediaFiles.map((f, index) => ({
         id: f.id,
         resolution: cleanMeta(f.resolution),