BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

shared-video-player.js 89.0 KiB Download Raw
1'use strict';
2
3(function ()
4{
5 const VIDEO_TEXT_TRACK_SETTINGS_KEY = 'vjs-text-track-settings';
6 const VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW = JSON.stringify({
7 backgroundOpacity: '0',
8 edgeStyle: 'uniform',
9 });
10 const SUBTITLE_LOG_BATCH_MAX_ITEMS = 12;
11 const SUBTITLE_LOG_FLUSH_DELAY_MS = 500;
12 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT = 15;
13 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX = 30;
14 const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_DEFAULT = 60;
15 const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_MAX = 120;
16 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_DEFAULT = 0.5;
17 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MIN = 0.25;
18 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MAX = 30;
19 const IMAGE_SUBTITLE_TIME_MATCH_EPSILON_SECONDS = 0.05;
20 const IMAGE_SUBTITLE_CACHE_MISS_FALLBACK_INTERVAL_MS_DEFAULT = 2000;
21 const IMAGE_SUBTITLE_CURRENT_REQUEST_TIMEOUT_MS_DEFAULT = 4000;
22 const IMAGE_SUBTITLE_PREFETCH_REQUEST_TIMEOUT_MS_DEFAULT = 4000;
23 const IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS_DEFAULT = 0;
24 const VIDEO_STREAM_CACHE_SW_URL = '/stream-cache-sw.js';
25 const VIDEO_STREAM_CACHE_NAME = 'filemanager-stream-cache-v1';
26 const VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT = 750;
27 const VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS = 4;
28
29 function formatClockTime (value)
30 {
31 const seconds = Number(value);
32 if (!Number.isFinite(seconds) || seconds < 0) return '00:00';
33
34 const total = Math.floor(seconds);
35 const hours = Math.floor(total / 3600);
36 const minutes = Math.floor((total % 3600) / 60);
37 const remainingSeconds = total % 60;
38
39 if (hours > 0)
40 {
41 return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
42 }
43 return `${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
44 }
45
46 function roundLogNumber (value, digits = 3)
47 {
48 const numeric = Number(value);
49 if (!Number.isFinite(numeric)) return null;
50 return Number(numeric.toFixed(digits));
51 }
52
53 function parseHeaderInt (res, name)
54 {
55 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
56 const value = Number.parseInt(String(res.headers.get(name) || ''), 10);
57 return Number.isFinite(value) ? value : null;
58 }
59
60 function parseHeaderFloat (res, name)
61 {
62 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
63 const value = Number.parseFloat(String(res.headers.get(name) || ''));
64 return Number.isFinite(value) ? value : null;
65 }
66
67 function diffMilliseconds (later, earlier)
68 {
69 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
70 return Math.round(later - earlier);
71 }
72
73 function diffSeconds (later, earlier)
74 {
75 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
76 return roundLogNumber(later - earlier, 3);
77 }
78
79 function base64ToBlob (base64, contentType = 'image/png')
80 {
81 const raw = String(base64 || '').trim();
82 if (!raw) return null;
83
84 try
85 {
86 const decoded = window.atob(raw);
87 const bytes = new Uint8Array(decoded.length);
88 for (let index = 0; index < decoded.length; index++)
89 {
90 bytes[index] = decoded.charCodeAt(index);
91 }
92 return new Blob([bytes], { type: String(contentType || '').trim() || 'image/png' });
93 } catch
94 {
95 return null;
96 }
97 }
98
99 function waitForImagePresentation (windowRef, imageEl)
100 {
101 return new Promise((resolve) =>
102 {
103 let settled = false;
104 let fallbackTimer = null;
105 const raf = typeof windowRef.requestAnimationFrame === 'function'
106 ? windowRef.requestAnimationFrame.bind(windowRef)
107 : (fn) => windowRef.setTimeout(fn, 0);
108
109 const cleanup = () =>
110 {
111 imageEl.removeEventListener('load', onLoad);
112 imageEl.removeEventListener('error', onError);
113 if (fallbackTimer !== null) windowRef.clearTimeout(fallbackTimer);
114 };
115
116 const finish = () =>
117 {
118 if (settled) return;
119 settled = true;
120 cleanup();
121 raf(() => resolve(Date.now()));
122 };
123
124 const onLoad = () => finish();
125 const onError = () => finish();
126
127 imageEl.addEventListener('load', onLoad);
128 imageEl.addEventListener('error', onError);
129 fallbackTimer = windowRef.setTimeout(finish, 250);
130
131 if (imageEl.complete && imageEl.currentSrc)
132 {
133 finish();
134 }
135 });
136 }
137
138 function normaliseTrackName (name)
139 {
140 return String(name || '').trim().toLowerCase();
141 }
142
143 function getTrackName (track)
144 {
145 if (!track || typeof track !== 'object') return '';
146 const label = String(track.label || '').trim();
147 if (label) return label;
148 const name = String(track.name || '').trim();
149 if (name) return name;
150 const language = String(track.language || '').trim();
151 if (language) return language;
152 const id = String(track.id || '').trim();
153 if (id) return id;
154 return '';
155 }
156
157 function trackListToArray (trackList)
158 {
159 if (!trackList || typeof trackList.length !== 'number') return [];
160 const out = [];
161 for (let i = 0; i < trackList.length; i++)
162 {
163 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
164 if (track) out.push(track);
165 }
166 return out;
167 }
168
169 function subtitleTracksFromPlayer (player)
170 {
171 if (!player || typeof player.textTracks !== 'function') return [];
172 return trackListToArray(player.textTracks()).filter((track) =>
173 {
174 const kind = String(track.kind || '').toLowerCase();
175 return kind === 'subtitles' || kind === 'captions';
176 });
177 }
178
179 function audioTracksFromPlayer (player)
180 {
181 if (!player || typeof player.audioTracks !== 'function') return [];
182 return trackListToArray(player.audioTracks());
183 }
184
185 function applySavedSubtitleTrack (player, savedName)
186 {
187 if (typeof savedName !== 'string') return;
188 const tracks = subtitleTracksFromPlayer(player);
189 if (!tracks.length) return;
190
191 const wanted = normaliseTrackName(savedName);
192 if (!wanted)
193 {
194 for (const track of tracks) track.mode = 'disabled';
195 return;
196 }
197
198 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
199 if (!match) return;
200
201 for (const track of tracks)
202 {
203 track.mode = track === match ? 'showing' : 'disabled';
204 }
205 }
206
207 function applySavedAudioTrack (player, savedName)
208 {
209 if (typeof savedName !== 'string') return;
210 const tracks = audioTracksFromPlayer(player);
211 if (!tracks.length) return;
212
213 const wanted = normaliseTrackName(savedName);
214 if (!wanted) return;
215
216 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
217 if (!match) return;
218
219 for (const track of tracks)
220 {
221 track.enabled = track === match;
222 }
223 }
224
225 function getSelectedSubtitleTrackName (player)
226 {
227 const tracks = subtitleTracksFromPlayer(player);
228 if (!tracks.length) return null;
229 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
230 return active ? getTrackName(active) : '';
231 }
232
233 function getSelectedAudioTrackName (player)
234 {
235 const tracks = audioTracksFromPlayer(player);
236 if (!tracks.length) return null;
237 const active = tracks.find((track) => !!track.enabled);
238 return active ? getTrackName(active) : '';
239 }
240
241 function bindTrackPrefs (player, prefs, savePrefs)
242 {
243 const save = typeof savePrefs === 'function' ? savePrefs : (() => { });
244 const applySavedTracks = () =>
245 {
246 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
247 applySavedAudioTrack(player, prefs.audioTrackName);
248 };
249
250 const captureSelectedTracks = () =>
251 {
252 const subtitleTrackName = getSelectedSubtitleTrackName(player);
253 const audioTrackName = getSelectedAudioTrackName(player);
254 const patch = {};
255
256 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
257 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
258
259 if (Object.keys(patch).length) save(patch);
260 };
261
262 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
263 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
264 const onTrackListChange = () => captureSelectedTracks();
265
266 if (textTrackList && typeof textTrackList.addEventListener === 'function')
267 {
268 textTrackList.addEventListener('change', onTrackListChange);
269 }
270
271 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
272 {
273 audioTrackList.addEventListener('change', onTrackListChange);
274 }
275
276 return {
277 applySavedTracks,
278 captureSelectedTracks,
279 detach: () =>
280 {
281 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
282 {
283 textTrackList.removeEventListener('change', onTrackListChange);
284 }
285 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
286 {
287 audioTrackList.removeEventListener('change', onTrackListChange);
288 }
289 },
290 };
291 }
292
293 function bindImageSubtitleOverlay (player, videojs, prefs, session, opts = {})
294 {
295 const imageTracks = Array.isArray(session.imageSubtitleTracks)
296 ? session.imageSubtitleTracks.map((track) => ({
297 label: String(track.label || '').trim() || `Subtitle ${Number(track.streamIndex || 0) + 1}`,
298 language: String(track.language || '').trim(),
299 isDefault: !!track.default,
300 streamIndex: Number(track.streamIndex),
301 })).filter((track) => Number.isInteger(track.streamIndex) && track.streamIndex >= 0)
302 : [];
303
304 if (!imageTracks.length) return null;
305
306 const savePrefs = typeof opts.savePrefs === 'function' ? opts.savePrefs : (() => { });
307 const buildFrameRequest = typeof opts.buildFrameRequest === 'function' ? opts.buildFrameRequest : null;
308 const buildPrefetchRequest = typeof opts.buildPrefetchRequest === 'function' ? opts.buildPrefetchRequest : buildFrameRequest;
309 const prefetchUsesRangeRequests = !!(buildFrameRequest && buildPrefetchRequest && buildPrefetchRequest !== buildFrameRequest);
310 const notifyError = typeof opts.onError === 'function' ? opts.onError : (() => { });
311 const sendSubtitleLogBatch = typeof opts.sendSubtitleLogBatch === 'function' ? opts.sendSubtitleLogBatch : null;
312 const requestedLookaheadSeconds = Number(opts.lookaheadSeconds);
313 const lookaheadSeconds = Number.isFinite(requestedLookaheadSeconds)
314 ? Math.max(0, Math.min(IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX, requestedLookaheadSeconds))
315 : IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT;
316 const requestedCurrentRequestTimeoutMs = Number(opts.currentRequestTimeoutMs);
317 const currentRequestTimeoutMs = Number.isFinite(requestedCurrentRequestTimeoutMs)
318 ? Math.max(250, requestedCurrentRequestTimeoutMs)
319 : IMAGE_SUBTITLE_CURRENT_REQUEST_TIMEOUT_MS_DEFAULT;
320 const requestedInitialPrefetchSeconds = Number(opts.initialPrefetchSeconds);
321 const initialPrefetchSeconds = Number.isFinite(requestedInitialPrefetchSeconds)
322 ? Math.max(0, Math.min(IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_MAX, requestedInitialPrefetchSeconds))
323 : IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_DEFAULT;
324 const requestedPrefetchRequestTimeoutMs = Number(opts.prefetchRequestTimeoutMs);
325 const prefetchRequestTimeoutMs = Number.isFinite(requestedPrefetchRequestTimeoutMs)
326 ? Math.max(250, requestedPrefetchRequestTimeoutMs)
327 : IMAGE_SUBTITLE_PREFETCH_REQUEST_TIMEOUT_MS_DEFAULT;
328 const requestedPrefetchRequestIntervalMs = Number(opts.prefetchRequestIntervalMs);
329 const prefetchRequestIntervalMs = Number.isFinite(requestedPrefetchRequestIntervalMs)
330 ? Math.max(0, requestedPrefetchRequestIntervalMs)
331 : IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS_DEFAULT;
332 const requestedPrefetchStepSeconds = Number(opts.prefetchStepSeconds);
333 const prefetchStepSecondsFixed = Number.isFinite(requestedPrefetchStepSeconds)
334 ? Math.max(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MIN, Math.min(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MAX, requestedPrefetchStepSeconds))
335 : null;
336 const prefetchAdaptiveStepEnabled = opts.prefetchAdaptiveStepEnabled === true;
337 const prefetchAdaptivePacingEnabled = opts.prefetchAdaptivePacingEnabled === true;
338 const requestedPrefetchStepSecondsMin = Number(opts.prefetchStepSecondsMin);
339 const requestedPrefetchStepSecondsMax = Number(opts.prefetchStepSecondsMax);
340 const prefetchStepSecondsMin = Number.isFinite(requestedPrefetchStepSecondsMin)
341 ? Math.max(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MIN, Math.min(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MAX, requestedPrefetchStepSecondsMin))
342 : (prefetchStepSecondsFixed || IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_DEFAULT);
343 const prefetchStepSecondsMaxRaw = Number.isFinite(requestedPrefetchStepSecondsMax)
344 ? Math.max(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MIN, Math.min(IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS_MAX, requestedPrefetchStepSecondsMax))
345 : (prefetchStepSecondsFixed || prefetchStepSecondsMin);
346 const prefetchStepSecondsMax = Math.max(prefetchStepSecondsMin, prefetchStepSecondsMaxRaw);
347 const requestedCacheMissFallbackIntervalMs = Number(opts.cacheMissFallbackIntervalMs);
348 const cacheMissFallbackIntervalMs = Number.isFinite(requestedCacheMissFallbackIntervalMs)
349 ? Math.max(500, requestedCacheMissFallbackIntervalMs)
350 : IMAGE_SUBTITLE_CACHE_MISS_FALLBACK_INTERVAL_MS_DEFAULT;
351 const cacheMissFallbackEnabled = opts.cacheMissFallbackEnabled !== false;
352 const currentFetchEnabled = opts.currentFetchEnabled !== false;
353 const logToConsole = opts.logToConsole !== false;
354 if (!buildFrameRequest) return null;
355
356 const trackByStreamIndex = new Map(imageTracks.map((track) => [track.streamIndex, track]));
357 let selectedStreamIndex = null;
358 let menuOpen = false;
359 let activeBucket = -1;
360 let activeObjectUrl = null;
361 let overlayEl = null;
362 let overlayImgEl = null;
363 let overlayImgElSecondary = null;
364 let primaryBufferIndex = 0;
365 let primaryFrameKey = null;
366 let secondaryFrameKey = null;
367 let menuEl = null;
368 let buttonEl = null;
369 let trackDisabled = false;
370 let failureNotified = false;
371 let lifecycleToken = 0;
372 let currentFrameToken = 0;
373 let currentFrameAbortController = null;
374 let prefetchWorkerToken = 0;
375 let prefetchAbortController = null;
376 let prefetchPromise = null;
377 let prefetchTargetTimeSeconds = -1;
378 let prefetchedThroughTimeSeconds = -1;
379 let queuedCurrentRefresh = false;
380 let queuedCurrentRefreshForce = false;
381 let currentFramePromise = null;
382 let seekMarkerContainerEl = null;
383 let seekMarkerRequestedEl = null;
384 let seekMarkerReceivedEl = null;
385 let lastRequestedCaptionStartTimeSeconds = null;
386 let lastReceivedCaptionStartTimeSeconds = null;
387 let subtitleLogSequence = 0;
388 let subtitleLogQueue = [];
389 let subtitleLogFlushTimer = null;
390 let lastCacheMissFallbackAtMs = 0;
391 let playbackClockSyncHandle = null;
392 const cachedSubtitleFrames = new Map();
393
394 const requestFrame = (fn) =>
395 {
396 if (typeof window.requestAnimationFrame === 'function')
397 {
398 return { kind: 'raf', id: window.requestAnimationFrame(fn) };
399 }
400 return { kind: 'timeout', id: window.setTimeout(fn, 16) };
401 };
402
403 const cancelFrameRequest = (handle) =>
404 {
405 if (!handle || !Number.isFinite(Number(handle.id))) return;
406 if (handle.kind === 'raf' && typeof window.cancelAnimationFrame === 'function')
407 {
408 window.cancelAnimationFrame(handle.id);
409 return;
410 }
411 window.clearTimeout(handle.id);
412 };
413
414 const flushSubtitleLogs = () =>
415 {
416 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
417 if (subtitleLogFlushTimer)
418 {
419 window.clearTimeout(subtitleLogFlushTimer);
420 subtitleLogFlushTimer = null;
421 }
422
423 const batch = subtitleLogQueue;
424 subtitleLogQueue = [];
425 Promise.resolve(sendSubtitleLogBatch(batch)).catch(() =>
426 {
427 // Keep subtitle diagnostics best-effort only.
428 });
429 };
430
431 const scheduleSubtitleLogFlush = () =>
432 {
433 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
434 if (subtitleLogQueue.length >= SUBTITLE_LOG_BATCH_MAX_ITEMS)
435 {
436 flushSubtitleLogs();
437 return;
438 }
439 if (subtitleLogFlushTimer) return;
440 subtitleLogFlushTimer = window.setTimeout(() =>
441 {
442 subtitleLogFlushTimer = null;
443 flushSubtitleLogs();
444 }, SUBTITLE_LOG_FLUSH_DELAY_MS);
445 };
446
447 const logSubtitleEvent = (eventType, details = {}) =>
448 {
449 const entry = {
450 seq: ++subtitleLogSequence,
451 loggedAtMs: Date.now(),
452 eventType,
453 sessionId: String(session.sessionId || '').trim() || null,
454 streamIndex: Number.isInteger(selectedStreamIndex) ? selectedStreamIndex : null,
455 playerTimeSeconds: roundLogNumber(player.currentTime()),
456 ...details,
457 };
458 if (logToConsole)
459 {
460 try
461 {
462 console.log('[subtitle-log]', entry);
463 } catch
464 {
465 // Ignore console availability issues.
466 }
467 }
468
469 if (!sendSubtitleLogBatch) return;
470 subtitleLogQueue.push(entry);
471 scheduleSubtitleLogFlush();
472 };
473
474 const createAbortController = () =>
475 {
476 if (typeof AbortController !== 'function') return null;
477 return new AbortController();
478 };
479
480 const abortController = (controller) =>
481 {
482 if (!controller || typeof controller.abort !== 'function') return;
483 try
484 {
485 controller.abort();
486 } catch
487 {
488 // Ignore abort races during teardown.
489 }
490 };
491
492 const isAbortError = (error) =>
493 {
494 return !!(error && typeof error === 'object' && error.name === 'AbortError');
495 };
496
497 const armRequestTimeout = (controller, timeoutMs, onTimeout) =>
498 {
499 if (!controller || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
500 return window.setTimeout(() =>
501 {
502 if (typeof onTimeout === 'function') onTimeout();
503 abortController(controller);
504 }, timeoutMs);
505 };
506
507 const clearRequestTimeout = (timeoutId) =>
508 {
509 if (timeoutId === null || timeoutId === undefined) return;
510 window.clearTimeout(timeoutId);
511 };
512
513 const cancelCurrentFrameRequest = () =>
514 {
515 currentFrameToken++;
516 abortController(currentFrameAbortController);
517 currentFrameAbortController = null;
518 };
519
520 const cancelPrefetchRequests = ({ resetProgress = false } = {}) =>
521 {
522 prefetchWorkerToken++;
523 abortController(prefetchAbortController);
524 prefetchAbortController = null;
525 prefetchPromise = null;
526 if (resetProgress)
527 {
528 prefetchTargetTimeSeconds = -1;
529 prefetchedThroughTimeSeconds = -1;
530 }
531 };
532
533 const resetRequestState = () =>
534 {
535 lifecycleToken++;
536 cancelCurrentFrameRequest();
537 cancelPrefetchRequests({ resetProgress: true });
538 };
539
540 const stopPlaybackClockSync = () =>
541 {
542 if (!playbackClockSyncHandle) return;
543 cancelFrameRequest(playbackClockSyncHandle);
544 playbackClockSyncHandle = null;
545 };
546
547 const closeObjectUrl = () =>
548 {
549 activeObjectUrl = null;
550 primaryFrameKey = null;
551 secondaryFrameKey = null;
552 };
553
554 const hideOverlay = () =>
555 {
556 if (overlayEl) overlayEl.style.display = 'none';
557 if (overlayImgEl) overlayImgEl.removeAttribute('src');
558 closeObjectUrl();
559 };
560
561 const revokeCachedFrameUrls = () =>
562 {
563 for (const frame of cachedSubtitleFrames.values())
564 {
565 if (!frame || !frame.objectUrl) continue;
566 try
567 {
568 URL.revokeObjectURL(frame.objectUrl);
569 } catch
570 {
571 // Ignore object URL cleanup races.
572 }
573 }
574 cachedSubtitleFrames.clear();
575 };
576
577 const parseFrameMetadata = (res, fallbackStartTimeSeconds, fallbackSpanSeconds = prefetchStepSecondsMin) =>
578 {
579 const rawStart = parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time');
580 const startTimeSeconds = Number.isFinite(rawStart) && rawStart >= 0
581 ? rawStart
582 : (Number.isFinite(fallbackStartTimeSeconds) && fallbackStartTimeSeconds >= 0 ? fallbackStartTimeSeconds : null);
583
584 const rawEnd = parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time');
585 const endTimeSeconds = Number.isFinite(rawEnd)
586 ? rawEnd
587 : (Number.isFinite(startTimeSeconds) ? startTimeSeconds + fallbackSpanSeconds : null);
588
589 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
590 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
591 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
592 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
593
594 return {
595 startTimeSeconds,
596 endTimeSeconds,
597 frameWidth,
598 frameHeight,
599 canvasWidth,
600 canvasHeight,
601 };
602 };
603
604 const cacheFrameKey = (streamIndex, startTimeSeconds, endTimeSeconds) =>
605 {
606 const startPart = Number.isFinite(startTimeSeconds) ? startTimeSeconds.toFixed(6) : 'none';
607 const endPart = Number.isFinite(endTimeSeconds) ? endTimeSeconds.toFixed(6) : 'none';
608 return `${streamIndex}|${startPart}|${endPart}`;
609 };
610
611 const cacheSubtitleFrame = ({ streamIndex, blob, metadata }) =>
612 {
613 if (!Number.isInteger(streamIndex) || streamIndex < 0) return null;
614 if (!blob || typeof blob.size !== 'number' || blob.size <= 0) return null;
615
616 const startTimeSeconds = Number.isFinite(metadata && metadata.startTimeSeconds) ? metadata.startTimeSeconds : null;
617 const endTimeSeconds = Number.isFinite(metadata && metadata.endTimeSeconds)
618 ? metadata.endTimeSeconds
619 : (Number.isFinite(startTimeSeconds) ? startTimeSeconds + prefetchStepSecondsMin : null);
620 if (!Number.isFinite(startTimeSeconds) || !Number.isFinite(endTimeSeconds) || endTimeSeconds <= startTimeSeconds)
621 {
622 return null;
623 }
624
625 const key = cacheFrameKey(streamIndex, startTimeSeconds, endTimeSeconds);
626 const objectUrl = URL.createObjectURL(blob);
627 const previous = cachedSubtitleFrames.get(key);
628 if (previous && previous.objectUrl)
629 {
630 try
631 {
632 URL.revokeObjectURL(previous.objectUrl);
633 } catch
634 {
635 // Ignore object URL cleanup races.
636 }
637 }
638
639 const entry = {
640 key,
641 streamIndex,
642 startTimeSeconds,
643 endTimeSeconds,
644 objectUrl,
645 frameWidth: Number(metadata && metadata.frameWidth),
646 frameHeight: Number(metadata && metadata.frameHeight),
647 canvasWidth: Number(metadata && metadata.canvasWidth),
648 canvasHeight: Number(metadata && metadata.canvasHeight),
649 };
650 cachedSubtitleFrames.set(key, entry);
651 return entry;
652 };
653
654 const findCachedFrameForTime = (streamIndex, currentTime) =>
655 {
656 if (!Number.isInteger(streamIndex) || streamIndex < 0) return null;
657 if (!Number.isFinite(currentTime) || currentTime < 0) return null;
658
659 let best = null;
660 for (const frame of cachedSubtitleFrames.values())
661 {
662 if (!frame || frame.streamIndex !== streamIndex) continue;
663 if (!Number.isFinite(frame.startTimeSeconds) || !Number.isFinite(frame.endTimeSeconds)) continue;
664 const startsAt = frame.startTimeSeconds - IMAGE_SUBTITLE_TIME_MATCH_EPSILON_SECONDS;
665 const endsAt = frame.endTimeSeconds + IMAGE_SUBTITLE_TIME_MATCH_EPSILON_SECONDS;
666 if (currentTime < startsAt || currentTime >= endsAt) continue;
667 if (!best || frame.startTimeSeconds > best.startTimeSeconds) best = frame;
668 }
669 return best;
670 };
671
672 const getAdaptivePrefetchStepSeconds = (currentTimeSeconds) =>
673 {
674 if (!prefetchAdaptiveStepEnabled || prefetchStepSecondsMax <= prefetchStepSecondsMin)
675 {
676 return prefetchStepSecondsMax;
677 }
678
679 const nowSeconds = Number(currentTimeSeconds);
680 const leadSeconds = Number.isFinite(prefetchedThroughTimeSeconds) && Number.isFinite(nowSeconds)
681 ? Math.max(0, prefetchedThroughTimeSeconds - nowSeconds)
682 : 0;
683 const targetLeadSeconds = Math.max(2, lookaheadSeconds * 0.75);
684 const highLeadSeconds = Math.max(targetLeadSeconds + prefetchStepSecondsMax, lookaheadSeconds * 2);
685 const ratio = highLeadSeconds > targetLeadSeconds
686 ? Math.max(0, Math.min(1, (leadSeconds - targetLeadSeconds) / (highLeadSeconds - targetLeadSeconds)))
687 : 1;
688 const rawStep = prefetchStepSecondsMin + ((prefetchStepSecondsMax - prefetchStepSecondsMin) * ratio);
689
690 // Keep walker increments predictable while still allowing adaptation.
691 return Math.max(
692 prefetchStepSecondsMin,
693 Math.min(prefetchStepSecondsMax, Math.round(rawStep * 4) / 4),
694 );
695 };
696
697 const getPrefetchDelayMs = (currentTimeSeconds) =>
698 {
699 if (!prefetchAdaptivePacingEnabled) return prefetchRequestIntervalMs;
700
701 const nowSeconds = Number(currentTimeSeconds);
702 const leadSeconds = Number.isFinite(prefetchedThroughTimeSeconds) && Number.isFinite(nowSeconds)
703 ? Math.max(0, prefetchedThroughTimeSeconds - nowSeconds)
704 : 0;
705 const softLeadSeconds = Math.max(lookaheadSeconds, prefetchStepSecondsMax * 2);
706 if (leadSeconds <= softLeadSeconds) return prefetchRequestIntervalMs;
707
708 const excessRatio = Math.max(0, Math.min(1, (leadSeconds - softLeadSeconds) / Math.max(softLeadSeconds, 1)));
709 return Math.round(prefetchRequestIntervalMs + (excessRatio * 250));
710 };
711
712 const renderSubtitleFrameOnBuffer = (frame, bufferIndex) =>
713 {
714 if (!frame || !frame.objectUrl) return false;
715
716 const targetEl = bufferIndex === 0 ? overlayImgEl : overlayImgElSecondary;
717 if (!targetEl) return false;
718
719 targetEl.src = frame.objectUrl;
720
721 if (frame.frameWidth > 0 && frame.frameHeight > 0 && frame.canvasWidth > 0 && frame.canvasHeight > 0)
722 {
723 const widthPercent = (frame.frameWidth / frame.canvasWidth) * 100;
724 const heightPercent = (frame.frameHeight / frame.canvasHeight) * 100;
725 targetEl.style.width = `${widthPercent}%`;
726 targetEl.style.height = `${heightPercent}%`;
727 targetEl.style.maxWidth = 'none';
728 targetEl.style.maxHeight = 'none';
729 } else
730 {
731 targetEl.style.width = 'auto';
732 targetEl.style.height = 'auto';
733 targetEl.style.maxWidth = '100%';
734 targetEl.style.maxHeight = '100%';
735 }
736
737 if (bufferIndex === 0) primaryFrameKey = frame.key;
738 else secondaryFrameKey = frame.key;
739
740 return true;
741 };
742
743 const showPrimaryBuffer = () =>
744 {
745 if (!overlayEl) return;
746 const primaryEl = primaryBufferIndex === 0 ? overlayImgEl : overlayImgElSecondary;
747 const secondaryEl = primaryBufferIndex === 0 ? overlayImgElSecondary : overlayImgEl;
748
749 if (primaryEl) primaryEl.style.display = 'block';
750 if (secondaryEl) secondaryEl.style.display = 'none';
751 overlayEl.style.display = 'block';
752 };
753
754 const swapBuffers = () =>
755 {
756 primaryBufferIndex = primaryBufferIndex === 0 ? 1 : 0;
757 };
758
759 const renderSubtitleFrame = (frame) =>
760 {
761 if (!overlayEl || !frame || !frame.objectUrl) return;
762
763 if (activeObjectUrl !== frame.objectUrl)
764 {
765 activeObjectUrl = frame.objectUrl;
766 renderSubtitleFrameOnBuffer(frame, primaryBufferIndex);
767 }
768
769 showPrimaryBuffer();
770 };
771
772 const syncOverlayToPlaybackClock = () =>
773 {
774 if (selectedStreamIndex === null || trackDisabled)
775 {
776 stopPlaybackClockSync();
777 return;
778 }
779
780 const currentTime = Number(player.currentTime());
781 if (Number.isFinite(currentTime) && currentTime >= 0)
782 {
783 const cachedFrame = findCachedFrameForTime(selectedStreamIndex, currentTime);
784
785 if (cachedFrame)
786 {
787 // Check if frame changed
788 const currentFrameKey = primaryBufferIndex === 0 ? primaryFrameKey : secondaryFrameKey;
789 if (cachedFrame.key !== currentFrameKey)
790 {
791 // Frame transition: check if it's pre-loaded on secondary buffer
792 const secondaryKey = primaryBufferIndex === 0 ? secondaryFrameKey : primaryFrameKey;
793 if (cachedFrame.key === secondaryKey)
794 {
795 // Swap to show pre-loaded secondary frame
796 swapBuffers();
797 showPrimaryBuffer();
798 activeObjectUrl = cachedFrame.objectUrl;
799 } else
800 {
801 // Not pre-loaded; render directly on secondary and swap
802 const secondaryIdx = primaryBufferIndex === 0 ? 1 : 0;
803 renderSubtitleFrameOnBuffer(cachedFrame, secondaryIdx);
804 swapBuffers();
805 showPrimaryBuffer();
806 activeObjectUrl = cachedFrame.objectUrl;
807 }
808 }
809 } else
810 {
811 hideOverlay();
812 }
813 }
814
815 playbackClockSyncHandle = requestFrame(syncOverlayToPlaybackClock);
816 };
817
818 const ensurePlaybackClockSync = () =>
819 {
820 if (selectedStreamIndex === null || trackDisabled) return;
821 if (playbackClockSyncHandle) return;
822 playbackClockSyncHandle = requestFrame(syncOverlayToPlaybackClock);
823 };
824
825 const setSeekMarkerTime = (kind, timeSeconds) =>
826 {
827 const numericTime = Number(timeSeconds);
828 const nextTime = Number.isFinite(numericTime) && numericTime >= 0 ? numericTime : null;
829
830 if (kind === 'requested')
831 {
832 if (nextTime === null)
833 {
834 lastRequestedCaptionStartTimeSeconds = null;
835 } else if (!Number.isFinite(lastRequestedCaptionStartTimeSeconds) || nextTime >= lastRequestedCaptionStartTimeSeconds)
836 {
837 lastRequestedCaptionStartTimeSeconds = nextTime;
838 }
839 } else if (kind === 'received')
840 {
841 if (nextTime === null)
842 {
843 lastReceivedCaptionStartTimeSeconds = null;
844 } else if (!Number.isFinite(lastReceivedCaptionStartTimeSeconds) || nextTime >= lastReceivedCaptionStartTimeSeconds)
845 {
846 lastReceivedCaptionStartTimeSeconds = nextTime;
847 }
848 }
849 };
850
851 const updateSeekBarMarkers = () =>
852 {
853 if (!seekMarkerRequestedEl || !seekMarkerReceivedEl) return;
854
855 const duration = Number(player.duration && player.duration());
856 if (!Number.isFinite(duration) || duration <= 0)
857 {
858 seekMarkerRequestedEl.style.display = 'none';
859 seekMarkerReceivedEl.style.display = 'none';
860 return;
861 }
862
863 const getMarkerRatio = (markerTimeSeconds) =>
864 {
865 if (!Number.isFinite(markerTimeSeconds) || markerTimeSeconds < 0)
866 {
867 return null;
868 }
869
870 return Math.max(0, Math.min(1, markerTimeSeconds / duration));
871 };
872
873 const applyMarker = (markerEl, ratio) =>
874 {
875 if (!Number.isFinite(ratio))
876 {
877 markerEl.style.display = 'none';
878 return;
879 }
880
881 markerEl.style.display = 'block';
882 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
883 };
884
885 const requestedRatio = getMarkerRatio(lastRequestedCaptionStartTimeSeconds);
886 const receivedRatio = getMarkerRatio(lastReceivedCaptionStartTimeSeconds);
887 applyMarker(seekMarkerRequestedEl, requestedRatio);
888 applyMarker(seekMarkerReceivedEl, receivedRatio);
889 };
890
891 const ensureSeekBarMarkers = () =>
892 {
893 if (seekMarkerContainerEl && seekMarkerContainerEl.isConnected)
894 {
895 updateSeekBarMarkers();
896 return;
897 }
898
899 const playerEl = player.el && player.el();
900 if (!playerEl) return;
901
902 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
903 || playerEl.querySelector('.vjs-progress-holder')
904 || playerEl.querySelector('.vjs-progress-control');
905 if (!seekBarEl) return;
906
907 const computedPosition = window.getComputedStyle(seekBarEl).position;
908 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
909
910 seekMarkerContainerEl = document.createElement('div');
911 seekMarkerContainerEl.className = 'vjs-image-subtitle-seek-markers';
912 seekMarkerContainerEl.style.position = 'absolute';
913 seekMarkerContainerEl.style.left = '0';
914 seekMarkerContainerEl.style.right = '0';
915 seekMarkerContainerEl.style.top = '50%';
916 seekMarkerContainerEl.style.height = '10px';
917 seekMarkerContainerEl.style.transform = 'translateY(-50%)';
918 seekMarkerContainerEl.style.pointerEvents = 'none';
919 seekMarkerContainerEl.style.zIndex = '5';
920
921 const buildBracketMarker = (direction) =>
922 {
923 const markerEl = document.createElement('span');
924 markerEl.className = `vjs-image-subtitle-seek-marker vjs-image-subtitle-seek-marker-${direction}`;
925 markerEl.style.position = 'absolute';
926 markerEl.style.top = '50%';
927 markerEl.style.width = '10px';
928 markerEl.style.height = '10px';
929 markerEl.style.transform = 'translate(-50%, -50%)';
930 markerEl.style.color = '#fff';
931 markerEl.style.fontFamily = 'monospace';
932 markerEl.style.fontSize = '12px';
933 markerEl.style.fontWeight = '700';
934 markerEl.style.lineHeight = '10px';
935 markerEl.style.textAlign = 'center';
936 markerEl.style.display = 'none';
937 markerEl.textContent = direction === 'left' ? '[' : ']';
938 markerEl.setAttribute('aria-hidden', 'true');
939 return markerEl;
940 };
941
942 seekMarkerReceivedEl = buildBracketMarker('left');
943 seekMarkerRequestedEl = buildBracketMarker('right');
944 seekMarkerContainerEl.appendChild(seekMarkerReceivedEl);
945 seekMarkerContainerEl.appendChild(seekMarkerRequestedEl);
946
947 seekBarEl.appendChild(seekMarkerContainerEl);
948 updateSeekBarMarkers();
949 };
950
951 const updateButtonState = () =>
952 {
953 if (!buttonEl) return;
954 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
955 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
956 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
957 };
958
959 const updateMenuState = () =>
960 {
961 if (!menuEl) return;
962 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
963 for (const itemEl of items)
964 {
965 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
966 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
967 itemEl.classList.toggle('is-selected', isSelected);
968 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
969 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
970 itemEl.style.fontWeight = isSelected ? '600' : '400';
971 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
972 }
973 };
974
975 const closeMenu = () =>
976 {
977 menuOpen = false;
978 if (menuEl) menuEl.style.display = 'none';
979 };
980
981 const openMenu = () =>
982 {
983 menuOpen = true;
984 if (menuEl)
985 {
986 updateMenuState();
987 menuEl.style.display = 'block';
988 }
989 };
990
991 const toggleMenu = () =>
992 {
993 if (menuOpen) closeMenu();
994 else openMenu();
995 };
996
997 const saveSelection = () =>
998 {
999 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
1000 savePrefs({
1001 imageSubtitleTrackStreamIndex: selectedStreamIndex,
1002 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
1003 });
1004 };
1005
1006 const disableTrack = () =>
1007 {
1008 trackDisabled = true;
1009 selectedStreamIndex = null;
1010 activeBucket = -1;
1011 stopPlaybackClockSync();
1012 setSeekMarkerTime('requested', null);
1013 setSeekMarkerTime('received', null);
1014 updateSeekBarMarkers();
1015 resetRequestState();
1016 hideOverlay();
1017 updateButtonState();
1018 updateMenuState();
1019 saveSelection();
1020
1021 if (!failureNotified)
1022 {
1023 failureNotified = true;
1024 notifyError();
1025 }
1026 };
1027
1028 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
1029 {
1030 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
1031 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
1032
1033 trackDisabled = false;
1034 failureNotified = false;
1035 selectedStreamIndex = nextStreamIndex;
1036 activeBucket = -1;
1037 setSeekMarkerTime('requested', null);
1038 setSeekMarkerTime('received', null);
1039 updateSeekBarMarkers();
1040 resetRequestState();
1041 hideOverlay();
1042 updateButtonState();
1043 updateMenuState();
1044 if (persist) saveSelection();
1045
1046 if (selectedStreamIndex !== null)
1047 {
1048 ensurePlaybackClockSync();
1049 if (initialPrefetchSeconds > 0)
1050 {
1051 queueLookaheadPrefetch(0, {
1052 reset: true,
1053 includeCurrentTime: true,
1054 maxTargetTimeSeconds: initialPrefetchSeconds,
1055 });
1056 }
1057 void refreshFrame();
1058 }
1059 else
1060 {
1061 stopPlaybackClockSync();
1062 }
1063 };
1064
1065 const queueLookaheadPrefetch = (currentTime, {
1066 reset = false,
1067 includeCurrentTime = false,
1068 maxTargetTimeSeconds = null,
1069 } = {}) =>
1070 {
1071 if (selectedStreamIndex === null) return;
1072 if (trackDisabled) return;
1073
1074 const durationSeconds = Number(player.duration && player.duration());
1075 const knownVideoEndSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0
1076 ? durationSeconds
1077 : null;
1078
1079 const bufferedVideoEndSeconds = (() =>
1080 {
1081 const candidates = [];
1082
1083 const fromPlayer = Number(player.bufferedEnd && player.bufferedEnd());
1084 if (Number.isFinite(fromPlayer) && fromPlayer >= 0) candidates.push(fromPlayer);
1085
1086 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
1087 const mediaEl = tech && typeof tech.el === 'function'
1088 ? tech.el()
1089 : (player.el && player.el() ? player.el().querySelector('video') : null);
1090
1091 const ranges = mediaEl && mediaEl.buffered;
1092 if (ranges && typeof ranges.length === 'number' && ranges.length > 0 && typeof ranges.end === 'function')
1093 {
1094 try
1095 {
1096 const endTime = Number(ranges.end(ranges.length - 1));
1097 if (Number.isFinite(endTime) && endTime >= 0) candidates.push(endTime);
1098 } catch
1099 {
1100 // Ignore buffered range read races.
1101 }
1102 }
1103
1104 if (!candidates.length) return null;
1105 return Math.max(...candidates);
1106 })();
1107
1108 const startTime = includeCurrentTime
1109 ? currentTime
1110 : currentTime + prefetchStepSecondsMin;
1111 const uncappedEndTime = Math.max(
1112 currentTime + lookaheadSeconds,
1113 Number.isFinite(bufferedVideoEndSeconds) ? bufferedVideoEndSeconds : -1,
1114 Number.isFinite(knownVideoEndSeconds) ? knownVideoEndSeconds : -1,
1115 );
1116 const capEndTime = Number.isFinite(maxTargetTimeSeconds) && maxTargetTimeSeconds >= 0
1117 ? maxTargetTimeSeconds
1118 : null;
1119 let endTime = Number.isFinite(capEndTime)
1120 ? Math.min(uncappedEndTime, capEndTime)
1121 : uncappedEndTime;
1122 if (Number.isFinite(knownVideoEndSeconds))
1123 {
1124 endTime = Math.min(endTime, knownVideoEndSeconds);
1125 }
1126 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
1127
1128 if (reset || prefetchedThroughTimeSeconds < 0)
1129 {
1130 cancelPrefetchRequests({ resetProgress: true });
1131 prefetchedThroughTimeSeconds = includeCurrentTime
1132 ? currentTime - prefetchStepSecondsMin
1133 : currentTime;
1134 } else if (prefetchedThroughTimeSeconds < currentTime)
1135 {
1136 // Keep the prefetch frontier at or ahead of current playback so
1137 // prefetch catches buffered-ahead range instead of replaying stale lag.
1138 prefetchedThroughTimeSeconds = currentTime;
1139 }
1140
1141 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
1142 if (prefetchPromise) return;
1143
1144 const workerToken = ++prefetchWorkerToken;
1145 const workerLifecycleToken = lifecycleToken;
1146 const controller = createAbortController();
1147 prefetchAbortController = controller;
1148
1149 prefetchPromise = (async () =>
1150 {
1151 while (true)
1152 {
1153 if (selectedStreamIndex === null || trackDisabled) return;
1154 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
1155
1156 const stepSeconds = getAdaptivePrefetchStepSeconds(Number(player.currentTime()));
1157
1158 const nextTime = prefetchedThroughTimeSeconds < 0
1159 ? startTime
1160 : prefetchedThroughTimeSeconds + stepSeconds;
1161 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
1162 const requestedRangeEndTimeSeconds = Math.min(prefetchTargetTimeSeconds, nextTime + stepSeconds);
1163 const prefetchProgressTimeSeconds = prefetchUsesRangeRequests
1164 ? requestedRangeEndTimeSeconds
1165 : nextTime;
1166
1167 const request = buildPrefetchRequest({
1168 streamIndex: selectedStreamIndex,
1169 currentTime: nextTime,
1170 endTime: requestedRangeEndTimeSeconds,
1171 session,
1172 });
1173 if (!request || !request.url) return;
1174
1175 const prefetchRequestStartedAtMs = Date.now();
1176 const prefetchRequestId = `prefetch-${workerToken}-${Math.round(nextTime * 1000)}`;
1177 logSubtitleEvent('subtitle_png_requested', {
1178 requestId: prefetchRequestId,
1179 requestKind: 'prefetch',
1180 requestUrl: String(request.url || ''),
1181 requestedAtMs: prefetchRequestStartedAtMs,
1182 requestedVideoTimeSeconds: roundLogNumber(nextTime),
1183 requestedRangeEndTimeSeconds: roundLogNumber(requestedRangeEndTimeSeconds),
1184 });
1185
1186 let prefetchTimedOut = false;
1187 const timeoutId = armRequestTimeout(controller, prefetchRequestTimeoutMs, () =>
1188 {
1189 prefetchTimedOut = true;
1190 });
1191
1192 try
1193 {
1194 const res = await fetch(request.url, {
1195 method: request.method || 'GET',
1196 headers: request.headers,
1197 credentials: request.credentials,
1198 signal: controller ? controller.signal : undefined,
1199 });
1200 clearRequestTimeout(timeoutId);
1201
1202 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
1203
1204 const responseMeta = {
1205 requestId: prefetchRequestId,
1206 requestKind: 'prefetch',
1207 status: res.status,
1208 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1209 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1210 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1211 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1212 responseHeadersReceivedAtMs: Date.now(),
1213 requestedVideoTimeSeconds: roundLogNumber(nextTime),
1214 requestedRangeEndTimeSeconds: roundLogNumber(requestedRangeEndTimeSeconds),
1215 };
1216 logSubtitleEvent('subtitle_png_sent', {
1217 ...responseMeta,
1218 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1219 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1220 });
1221
1222 setSeekMarkerTime('requested', prefetchProgressTimeSeconds);
1223 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1224 ? responseMeta.shouldShowAtVideoTimeSeconds
1225 : prefetchProgressTimeSeconds;
1226 setSeekMarkerTime('received', receivedMarkerTime);
1227 updateSeekBarMarkers();
1228
1229 if (res.status === 204)
1230 {
1231 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1232 logSubtitleEvent('subtitle_png_not_available', {
1233 ...responseMeta,
1234 frameStatus,
1235 });
1236 if (frameStatus === 'error') return;
1237 prefetchedThroughTimeSeconds = prefetchProgressTimeSeconds;
1238 if (prefetchUsesRangeRequests)
1239 {
1240 setSeekMarkerTime('requested', prefetchedThroughTimeSeconds);
1241 setSeekMarkerTime('received', prefetchedThroughTimeSeconds);
1242 updateSeekBarMarkers();
1243 }
1244 const waitMs = getPrefetchDelayMs(Number(player.currentTime()));
1245 if (waitMs > 0)
1246 {
1247 await new Promise((resolve) => window.setTimeout(resolve, waitMs));
1248 }
1249 continue;
1250 }
1251
1252 if (!res.ok) return;
1253 const receivedAtMs = Date.now();
1254 let cachedFrameEntry = null;
1255 let receivedBlobBytes = 0;
1256
1257 if (/application\/json/i.test(String(res.headers.get('Content-Type') || '')))
1258 {
1259 const body = await res.json().catch(() => null);
1260 if (String(body && body.status || '').toLowerCase() === 'error') return;
1261 const responseFrames = Array.isArray(body && body.frames) ? body.frames : [];
1262 for (const frame of responseFrames)
1263 {
1264 if (!frame) continue;
1265 const blob = base64ToBlob(frame.frameBase64, frame.contentType || 'image/png');
1266 if (!blob || !blob.size) continue;
1267 receivedBlobBytes += Number(blob.size) || 0;
1268 const cached = cacheSubtitleFrame({
1269 streamIndex: selectedStreamIndex,
1270 blob,
1271 metadata: {
1272 startTimeSeconds: Number(frame.startTimeSeconds),
1273 endTimeSeconds: Number(frame.endTimeSeconds),
1274 frameWidth: Number(frame.width),
1275 frameHeight: Number(frame.height),
1276 canvasWidth: Number(frame.canvasWidth),
1277 canvasHeight: Number(frame.canvasHeight),
1278 },
1279 });
1280 if (cached) cachedFrameEntry = cached;
1281 }
1282 responseMeta.shouldShowAtVideoTimeSeconds = Number.isFinite(Number(body && body.startTimeSeconds))
1283 ? Number(body.startTimeSeconds)
1284 : responseMeta.shouldShowAtVideoTimeSeconds;
1285 responseMeta.subtitleEndTimeSeconds = Number.isFinite(Number(body && body.endTimeSeconds))
1286 ? Number(body.endTimeSeconds)
1287 : responseMeta.subtitleEndTimeSeconds;
1288 } else
1289 {
1290 const payload = await res.arrayBuffer();
1291 receivedBlobBytes = Number(payload && payload.byteLength || 0);
1292 const metadata = parseFrameMetadata(res, nextTime, stepSeconds);
1293 const blob = new Blob([payload], {
1294 type: String(res.headers.get('Content-Type') || '').trim() || 'image/png',
1295 });
1296 cachedFrameEntry = cacheSubtitleFrame({
1297 streamIndex: selectedStreamIndex,
1298 blob,
1299 metadata,
1300 });
1301 }
1302
1303 // When foreground fetches are disabled, current-time rendering is
1304 // cache-only and may otherwise wait for a later timeupdate tick.
1305 // Render immediately if this prefetched frame covers current time.
1306 if (cachedFrameEntry)
1307 {
1308 const nowTime = Number(player.currentTime());
1309 if (Number.isFinite(nowTime) && nowTime >= 0)
1310 {
1311 const cachedForCurrentTime = findCachedFrameForTime(selectedStreamIndex, nowTime);
1312 if (cachedForCurrentTime)
1313 {
1314 renderSubtitleFrame(cachedForCurrentTime);
1315 }
1316 }
1317 }
1318
1319 logSubtitleEvent('subtitle_png_received', {
1320 ...responseMeta,
1321 receivedAtMs,
1322 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1323 requestedToReceivedMs: diffMilliseconds(receivedAtMs, prefetchRequestStartedAtMs),
1324 blobBytes: receivedBlobBytes,
1325 });
1326 prefetchedThroughTimeSeconds = prefetchProgressTimeSeconds;
1327 if (prefetchUsesRangeRequests)
1328 {
1329 setSeekMarkerTime('requested', prefetchedThroughTimeSeconds);
1330 setSeekMarkerTime('received', prefetchedThroughTimeSeconds);
1331 updateSeekBarMarkers();
1332 }
1333 const waitMs = getPrefetchDelayMs(Number(player.currentTime()));
1334 if (waitMs > 0)
1335 {
1336 await new Promise((resolve) => window.setTimeout(resolve, waitMs));
1337 }
1338 } catch (error)
1339 {
1340 clearRequestTimeout(timeoutId);
1341 if (prefetchTimedOut)
1342 {
1343 logSubtitleEvent('subtitle_png_request_failed', {
1344 requestId: prefetchRequestId,
1345 requestKind: 'prefetch',
1346 requestedAtMs: prefetchRequestStartedAtMs,
1347 errorName: 'AbortError',
1348 errorMessage: `Prefetch subtitle request timed out after ${Math.round(prefetchRequestTimeoutMs)}ms`,
1349 });
1350 return;
1351 }
1352 if (isAbortError(error)) return;
1353 logSubtitleEvent('subtitle_png_request_failed', {
1354 requestId: prefetchRequestId,
1355 requestKind: 'prefetch',
1356 requestedAtMs: prefetchRequestStartedAtMs,
1357 errorName: error && error.name ? String(error.name) : null,
1358 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1359 });
1360 return;
1361 }
1362 }
1363 })().finally(() =>
1364 {
1365 if (workerToken !== prefetchWorkerToken) return;
1366 prefetchAbortController = null;
1367 prefetchPromise = null;
1368 });
1369 };
1370
1371 const refreshFrame = async (force = false, allowCurrentFetchOverride = false, preservePrefetchState = false) =>
1372 {
1373 if (selectedStreamIndex === null) return;
1374 if (!overlayEl || !overlayImgEl) return;
1375 if (trackDisabled) return;
1376
1377 if (currentFramePromise && !force)
1378 {
1379 queuedCurrentRefresh = true;
1380 return;
1381 }
1382
1383 const currentTime = Number(player.currentTime());
1384 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1385
1386 const bucket = Math.floor(currentTime * 4);
1387 if (!force && bucket === activeBucket) return;
1388 activeBucket = bucket;
1389
1390 const cachedFrame = findCachedFrameForTime(selectedStreamIndex, currentTime);
1391 if (cachedFrame)
1392 {
1393 setSeekMarkerTime('requested', currentTime);
1394 setSeekMarkerTime('received', cachedFrame.startTimeSeconds);
1395 updateSeekBarMarkers();
1396 renderSubtitleFrame(cachedFrame);
1397 queueLookaheadPrefetch(currentTime, { reset: force });
1398 return;
1399 }
1400
1401 if (!currentFetchEnabled && !allowCurrentFetchOverride)
1402 {
1403 hideOverlay();
1404 const nowMs = Date.now();
1405 const shouldFallbackFetch = cacheMissFallbackEnabled
1406 && nowMs - lastCacheMissFallbackAtMs >= cacheMissFallbackIntervalMs;
1407 if (shouldFallbackFetch)
1408 {
1409 lastCacheMissFallbackAtMs = nowMs;
1410 logSubtitleEvent('subtitle_cache_miss_fallback_fetch', {
1411 requestKind: 'current',
1412 requestedAtMs: nowMs,
1413 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1414 });
1415 // Safety net for occasional cache key/window mismatches.
1416 // Uses normal current-frame path but does not reset prefetch state,
1417 // so background subtitle lead can continue growing while playing.
1418 return refreshFrame(true, true, true);
1419 }
1420 queueLookaheadPrefetch(currentTime, {
1421 reset: force,
1422 includeCurrentTime: true,
1423 });
1424 return;
1425 }
1426
1427 const refreshLifecycleToken = lifecycleToken;
1428 if (force && currentFramePromise)
1429 {
1430 cancelCurrentFrameRequest();
1431 }
1432 if (currentFramePromise)
1433 {
1434 queuedCurrentRefresh = true;
1435 queuedCurrentRefreshForce = queuedCurrentRefreshForce || !!force;
1436 return;
1437 }
1438 cancelCurrentFrameRequest();
1439 if (force && !preservePrefetchState) cancelPrefetchRequests({ resetProgress: true });
1440
1441 const token = ++currentFrameToken;
1442 const requestId = `current-${token}`;
1443 const requestStartedAtMs = Date.now();
1444 const controller = createAbortController();
1445 currentFrameAbortController = controller;
1446 const request = buildFrameRequest({
1447 streamIndex: selectedStreamIndex,
1448 currentTime,
1449 session,
1450 });
1451
1452 if (!request || !request.url)
1453 {
1454 disableTrack();
1455 return;
1456 }
1457
1458 logSubtitleEvent('subtitle_png_requested', {
1459 requestId,
1460 requestKind: 'current',
1461 requestUrl: String(request.url || ''),
1462 requestedAtMs: requestStartedAtMs,
1463 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1464 });
1465
1466 const frameRequestPromise = (async () =>
1467 {
1468 let currentTimedOut = false;
1469 const timeoutId = armRequestTimeout(controller, currentRequestTimeoutMs, () =>
1470 {
1471 currentTimedOut = true;
1472 });
1473 try
1474 {
1475 const res = await fetch(request.url, {
1476 method: request.method || 'GET',
1477 headers: request.headers,
1478 credentials: request.credentials,
1479 signal: controller ? controller.signal : undefined,
1480 });
1481 clearRequestTimeout(timeoutId);
1482
1483 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1484
1485 const responseMeta = {
1486 requestId,
1487 requestKind: 'current',
1488 status: res.status,
1489 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1490 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1491 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1492 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1493 responseHeadersReceivedAtMs: Date.now(),
1494 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1495 };
1496 logSubtitleEvent('subtitle_png_sent', {
1497 ...responseMeta,
1498 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1499 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1500 });
1501
1502 setSeekMarkerTime('requested', currentTime);
1503 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1504 ? responseMeta.shouldShowAtVideoTimeSeconds
1505 : currentTime;
1506 setSeekMarkerTime('received', receivedMarkerTime);
1507 updateSeekBarMarkers();
1508
1509 if (res.status === 204)
1510 {
1511 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1512 logSubtitleEvent('subtitle_png_not_available', {
1513 ...responseMeta,
1514 frameStatus,
1515 });
1516 hideOverlay();
1517 if (frameStatus === 'error') disableTrack();
1518 else queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1519 return;
1520 }
1521
1522 if (!res.ok)
1523 {
1524 disableTrack();
1525 return;
1526 }
1527
1528 const blob = await res.blob();
1529 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1530
1531 const receivedAtMs = Date.now();
1532 logSubtitleEvent('subtitle_png_received', {
1533 ...responseMeta,
1534 receivedAtMs,
1535 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1536 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
1537 blobBytes: Number(blob && blob.size || 0),
1538 });
1539
1540 if (!blob || blob.size === 0)
1541 {
1542 disableTrack();
1543 return;
1544 }
1545 const cachedFrameEntry = cacheSubtitleFrame({
1546 streamIndex: selectedStreamIndex,
1547 blob,
1548 metadata: parseFrameMetadata(res, currentTime, prefetchStepSecondsMin),
1549 });
1550 if (cachedFrameEntry) renderSubtitleFrame(cachedFrameEntry);
1551
1552 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
1553 {
1554 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1555 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
1556 logSubtitleEvent('subtitle_png_shown', {
1557 ...responseMeta,
1558 receivedAtMs,
1559 shownAtMs,
1560 shownAtVideoTimeSeconds,
1561 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1562 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
1563 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
1564 });
1565 });
1566
1567 queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1568 } catch (error)
1569 {
1570 clearRequestTimeout(timeoutId);
1571 if (currentTimedOut)
1572 {
1573 logSubtitleEvent('subtitle_png_request_failed', {
1574 requestId,
1575 requestKind: 'current',
1576 requestedAtMs: requestStartedAtMs,
1577 errorName: 'AbortError',
1578 errorMessage: `Current subtitle request timed out after ${Math.round(currentRequestTimeoutMs)}ms`,
1579 });
1580 return;
1581 }
1582 if (isAbortError(error)) return;
1583 logSubtitleEvent('subtitle_png_request_failed', {
1584 requestId,
1585 requestKind: 'current',
1586 requestedAtMs: requestStartedAtMs,
1587 errorName: error && error.name ? String(error.name) : null,
1588 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1589 });
1590 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
1591 }
1592 })();
1593
1594 currentFramePromise = frameRequestPromise;
1595 frameRequestPromise.finally(() =>
1596 {
1597 if (currentFramePromise !== frameRequestPromise) return;
1598 currentFrameAbortController = null;
1599 currentFramePromise = null;
1600 if (!queuedCurrentRefresh) return;
1601
1602 const queuedForce = queuedCurrentRefreshForce;
1603 queuedCurrentRefresh = false;
1604 queuedCurrentRefreshForce = false;
1605 void refreshFrame(queuedForce);
1606 });
1607
1608 return currentFramePromise;
1609 };
1610
1611 const dispose = () =>
1612 {
1613 stopPlaybackClockSync();
1614 resetRequestState();
1615 flushSubtitleLogs();
1616 closeMenu();
1617 hideOverlay();
1618 if (seekMarkerContainerEl) seekMarkerContainerEl.remove();
1619 seekMarkerContainerEl = null;
1620 seekMarkerRequestedEl = null;
1621 seekMarkerReceivedEl = null;
1622 revokeCachedFrameUrls();
1623 if (overlayEl) overlayEl.remove();
1624 if (menuEl) menuEl.remove();
1625 player.imageSubtitleOverlayController = null;
1626 buttonEl = null;
1627 };
1628
1629 overlayEl = document.createElement('div');
1630 overlayEl.className = 'video-subtitle-overlay';
1631 overlayEl.style.position = 'absolute';
1632 overlayEl.style.left = '0';
1633 overlayEl.style.right = '0';
1634 overlayEl.style.bottom = '3rem';
1635 overlayEl.style.display = 'none';
1636 overlayEl.style.zIndex = '3';
1637 overlayEl.style.pointerEvents = 'none';
1638 overlayEl.style.textAlign = 'center';
1639 overlayEl.style.padding = '0 0.75rem';
1640 overlayEl.style.maxHeight = '70%';
1641 overlayEl.style.overflow = 'hidden';
1642
1643 overlayImgEl = document.createElement('img');
1644 overlayImgEl.alt = 'Image subtitles';
1645 overlayImgEl.style.display = 'none';
1646 overlayImgEl.style.margin = '0 auto';
1647 overlayImgEl.style.objectFit = 'contain';
1648 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1649 overlayImgEl.style.maxWidth = '100%';
1650 overlayImgEl.style.height = 'auto';
1651 overlayEl.appendChild(overlayImgEl);
1652
1653 overlayImgElSecondary = document.createElement('img');
1654 overlayImgElSecondary.alt = 'Image subtitles (buffered)';
1655 overlayImgElSecondary.style.display = 'none';
1656 overlayImgElSecondary.style.margin = '0 auto';
1657 overlayImgElSecondary.style.objectFit = 'contain';
1658 overlayImgElSecondary.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1659 overlayImgElSecondary.style.maxWidth = '100%';
1660 overlayImgElSecondary.style.height = 'auto';
1661 overlayEl.appendChild(overlayImgElSecondary);
1662
1663 menuEl = document.createElement('div');
1664 menuEl.className = 'video-subtitle-overlay-menu';
1665 menuEl.style.position = 'absolute';
1666 menuEl.style.right = '0.75rem';
1667 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
1668 menuEl.style.minWidth = '14rem';
1669 menuEl.style.maxWidth = '20rem';
1670 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
1671 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
1672 menuEl.style.borderRadius = '0.5rem';
1673 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
1674 menuEl.style.padding = '0.35rem';
1675 menuEl.style.display = 'none';
1676 menuEl.style.zIndex = '4';
1677
1678 const buildMenuItem = (label, streamIndex, isSelected) =>
1679 {
1680 const itemEl = document.createElement('button');
1681 itemEl.type = 'button';
1682 itemEl.className = 'video-subtitle-overlay-menu-item';
1683 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
1684 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1685 itemEl.style.display = 'block';
1686 itemEl.style.width = '100%';
1687 itemEl.style.margin = '0';
1688 itemEl.style.padding = '0.5rem 0.75rem';
1689 itemEl.style.border = '0';
1690 itemEl.style.borderRadius = '0.35rem';
1691 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
1692 itemEl.style.color = '#fff';
1693 itemEl.style.textAlign = 'left';
1694 itemEl.style.cursor = 'pointer';
1695 itemEl.textContent = label;
1696 itemEl.addEventListener('click', () =>
1697 {
1698 setSelectedStreamIndex(streamIndex);
1699 closeMenu();
1700 });
1701 return itemEl;
1702 };
1703
1704 menuEl.appendChild(buildMenuItem('Off', null, false));
1705 for (const track of imageTracks)
1706 {
1707 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
1708 }
1709
1710 const registerButton = () =>
1711 {
1712 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
1713 if (videojs.getComponent('ImageSubtitleButton')) return;
1714
1715 const Button = videojs.getComponent('Button');
1716 class ImageSubtitleButton extends Button
1717 {
1718 buildCSSClass ()
1719 {
1720 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
1721 }
1722
1723 createEl ()
1724 {
1725 const el = super.createEl();
1726 el.type = 'button';
1727 el.setAttribute('title', 'Image subtitles');
1728 el.setAttribute('aria-label', 'Image subtitles');
1729 el.innerHTML = '<span aria-hidden="true">IM</span>';
1730 return el;
1731 }
1732
1733 handleClick ()
1734 {
1735 const controller = this.player().imageSubtitleOverlayController;
1736 if (controller) controller.toggleMenu();
1737 }
1738 }
1739
1740 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
1741 };
1742
1743 const attachUi = () =>
1744 {
1745 if (!player.el()) return;
1746 registerButton();
1747 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
1748 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
1749 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
1750 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
1751 {
1752 const button = controlBar.addChild('ImageSubtitleButton', {});
1753 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
1754 updateButtonState();
1755 }
1756 };
1757
1758 const applySavedTracks = () =>
1759 {
1760 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
1761 if (savedName)
1762 {
1763 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
1764 if (savedByName)
1765 {
1766 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
1767 return;
1768 }
1769 }
1770
1771 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
1772 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
1773 {
1774 setSelectedStreamIndex(savedIndex, { persist: false });
1775 return;
1776 }
1777
1778 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
1779 if (defaultTrack)
1780 {
1781 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
1782 return;
1783 }
1784
1785 setSelectedStreamIndex(null, { persist: false });
1786 };
1787
1788 player.imageSubtitleOverlayController = {
1789 toggleMenu,
1790 closeMenu,
1791 applySavedTracks,
1792 captureSelectedTracks: saveSelection,
1793 detach: dispose,
1794 };
1795
1796 player.on('timeupdate', () => { void refreshFrame(); });
1797 player.on('seeking', () => { void refreshFrame(true); });
1798 player.on('play', () => { void refreshFrame(true); });
1799 player.on('play', ensurePlaybackClockSync);
1800 player.on('pause', stopPlaybackClockSync);
1801 player.on('ended', stopPlaybackClockSync);
1802 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
1803 player.on('dispose', dispose);
1804 player.ready(() =>
1805 {
1806 attachUi();
1807 ensureSeekBarMarkers();
1808 updateMenuState();
1809 updateButtonState();
1810 updateSeekBarMarkers();
1811 applySavedTracks();
1812 if (menuOpen) openMenu();
1813 });
1814
1815 const onDurationHints = () =>
1816 {
1817 ensureSeekBarMarkers();
1818 updateSeekBarMarkers();
1819
1820 if (selectedStreamIndex === null || trackDisabled) return;
1821 const currentTime = Number(player.currentTime());
1822 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1823
1824 queueLookaheadPrefetch(currentTime, {
1825 includeCurrentTime: true,
1826 });
1827 };
1828
1829 player.on('durationchange', onDurationHints);
1830 player.on('loadedmetadata', onDurationHints);
1831
1832 return player.imageSubtitleOverlayController;
1833 }
1834
1835 function formatDurationForDebug (seconds)
1836 {
1837 const value = Number(seconds);
1838 if (!Number.isFinite(value) || value < 0) return 'unknown';
1839
1840 const totalSeconds = Math.floor(value);
1841 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1842 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1843 const ss = String(totalSeconds % 60).padStart(2, '0');
1844 return `${hh}:${mm}:${ss}`;
1845 }
1846
1847 function installDurationFallback (player, originalDuration, duration)
1848 {
1849 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1850
1851 player.__filemanagerDurationFallback = true;
1852 player.duration = function durationWithFallback (...args)
1853 {
1854 if (args.length) return originalDuration(...args);
1855 const current = Number(originalDuration());
1856 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1857 };
1858 }
1859
1860 function normaliseVideoDuration (player, durationSeconds)
1861 {
1862 const duration = Number(durationSeconds);
1863 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1864
1865 let originalDuration = null;
1866 let durationWasChanged = false;
1867 try
1868 {
1869 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1870 installDurationFallback(player, originalDuration, duration);
1871 if (player.__filemanagerDurationApplied) return;
1872
1873 const current = originalDuration ? Number(originalDuration()) : NaN;
1874 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1875 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1876 if (withinTolerance)
1877 {
1878 player.__filemanagerDurationApplied = true;
1879 return;
1880 }
1881
1882 if (originalDuration)
1883 {
1884 durationWasChanged = true;
1885 originalDuration(duration);
1886 }
1887 } catch
1888 {
1889 // Ignore players that do not support setting duration.
1890 }
1891
1892 try
1893 {
1894 const updated = originalDuration ? Number(originalDuration()) : NaN;
1895 if (Number.isFinite(updated) && updated >= duration * 0.95)
1896 {
1897 player.__filemanagerDurationApplied = true;
1898 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1899 return;
1900 }
1901
1902 player.__filemanagerDurationApplied = true;
1903 if (typeof player.trigger === 'function') player.trigger('durationchange');
1904 } catch
1905 {
1906 // Ignore duration fallback failures.
1907 }
1908 }
1909
1910 function ensureVideoPlaybackUi (player, durationSeconds)
1911 {
1912 if (!player || typeof player.on !== 'function') return;
1913
1914 const forceVodUi = () =>
1915 {
1916 normaliseVideoDuration(player, durationSeconds);
1917
1918 try
1919 {
1920 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1921 {
1922 player.liveTracker.stopTracking();
1923 }
1924 } catch
1925 {
1926 // Ignore live tracker availability issues.
1927 }
1928
1929 try
1930 {
1931 if (typeof player.removeClass === 'function')
1932 {
1933 player.removeClass('vjs-live');
1934 }
1935 } catch
1936 {
1937 // Ignore class update failures.
1938 }
1939
1940 try
1941 {
1942 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1943 if (display) display.style.display = 'none';
1944 } catch
1945 {
1946 // Ignore missing DOM.
1947 }
1948 };
1949
1950 player.ready(forceVodUi);
1951 player.on('loadedmetadata', forceVodUi);
1952 player.on('durationchange', forceVodUi);
1953 player.on('loadedplaylist', forceVodUi);
1954 }
1955
1956 function configureVideoJsBuffering (videojs, opts = {})
1957 {
1958 if (opts.enabled === false) return;
1959 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1960 videojs.__filemanagerBufferingConfigured = true;
1961
1962 const seconds = Number(opts.seconds);
1963 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1964
1965 try
1966 {
1967 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1968 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1969 videojs.Vhs.BUFFER_LOW_WATER_LINE = Math.max(30, Math.floor(bufferSeconds / 2));
1970 videojs.Vhs.MAX_BUFFER_LOW_WATER_LINE = bufferSeconds;
1971 } catch
1972 {
1973 // Ignore builds that do not expose VHS buffer configuration.
1974 }
1975 }
1976
1977 function enableVideoStreamClientCache ()
1978 {
1979 if (typeof navigator === 'undefined' || !navigator.serviceWorker || typeof navigator.serviceWorker.register !== 'function')
1980 {
1981 return Promise.resolve(false);
1982 }
1983
1984 if (window.__filemanagerVideoStreamCacheSwPromise)
1985 {
1986 return window.__filemanagerVideoStreamCacheSwPromise;
1987 }
1988
1989 window.__filemanagerVideoStreamCacheSwPromise = navigator.serviceWorker.register(VIDEO_STREAM_CACHE_SW_URL, {
1990 scope: '/',
1991 updateViaCache: 'none',
1992 }).then(() => true).catch(() => false);
1993
1994 return window.__filemanagerVideoStreamCacheSwPromise;
1995 }
1996
1997 function videoStreamCachePrefixFromPlaylistUrl (playlistUrl)
1998 {
1999 const raw = String(playlistUrl || '').trim();
2000 if (!raw) return null;
2001
2002 let parsed = null;
2003 try
2004 {
2005 parsed = new URL(raw, window.location.origin);
2006 } catch
2007 {
2008 return null;
2009 }
2010
2011 const pathname = String(parsed.pathname || '');
2012 if (!pathname) return null;
2013 const lastSlashIndex = pathname.lastIndexOf('/');
2014 const basePath = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '/';
2015 return `${parsed.origin}${basePath}`;
2016 }
2017
2018 function clearVideoStreamClientCache (playlistUrl)
2019 {
2020 const prefix = videoStreamCachePrefixFromPlaylistUrl(playlistUrl);
2021 if (!prefix || typeof caches === 'undefined' || typeof caches.open !== 'function')
2022 {
2023 return Promise.resolve();
2024 }
2025
2026 return caches.open(VIDEO_STREAM_CACHE_NAME).then(async (cache) =>
2027 {
2028 const requests = await cache.keys();
2029 const deletions = [];
2030 for (const request of requests)
2031 {
2032 const requestUrl = request && request.url ? String(request.url) : '';
2033 if (!requestUrl.startsWith(prefix)) continue;
2034 deletions.push(cache.delete(request));
2035 }
2036 await Promise.all(deletions);
2037 }).catch(() =>
2038 {
2039 // Keep cache cleanup best-effort only.
2040 });
2041 }
2042
2043 function parseHlsManifest (manifestText)
2044 {
2045 const lines = String(manifestText || '').split(/\r?\n/);
2046 const childPlaylists = [];
2047 const mediaAssets = [];
2048 const mediaSegmentUris = [];
2049 const mediaSegments = [];
2050 let expectPlaylistUri = false;
2051 let segmentCursorSeconds = 0;
2052 let pendingSegmentDurationSeconds = null;
2053
2054 for (const rawLine of lines)
2055 {
2056 const line = String(rawLine || '').trim();
2057 if (!line) continue;
2058
2059 if (line.startsWith('#'))
2060 {
2061 if (/^#EXT-X-STREAM-INF/i.test(line))
2062 {
2063 expectPlaylistUri = true;
2064 continue;
2065 }
2066
2067 const segmentDurationMatch = line.match(/^#EXTINF\s*:\s*([0-9]+(?:\.[0-9]+)?)/i);
2068 if (segmentDurationMatch)
2069 {
2070 const parsed = Number.parseFloat(segmentDurationMatch[1]);
2071 pendingSegmentDurationSeconds = Number.isFinite(parsed) && parsed > 0
2072 ? parsed
2073 : VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2074 continue;
2075 }
2076
2077 const mapMatch = line.match(/^#EXT-X-MAP\s*:\s*.*?URI="([^"]+)"/i);
2078 if (mapMatch && mapMatch[1]) mediaAssets.push(mapMatch[1]);
2079 continue;
2080 }
2081
2082 if (expectPlaylistUri || /\.m3u8(?:$|\?)/i.test(line))
2083 {
2084 childPlaylists.push(line);
2085 expectPlaylistUri = false;
2086 } else
2087 {
2088 mediaAssets.push(line);
2089 mediaSegmentUris.push(line);
2090 if (Number.isFinite(pendingSegmentDurationSeconds) && pendingSegmentDurationSeconds > 0)
2091 {
2092 const startTimeSeconds = segmentCursorSeconds;
2093 segmentCursorSeconds += pendingSegmentDurationSeconds;
2094 mediaSegments.push({
2095 uri: line,
2096 startTimeSeconds,
2097 endTimeSeconds: segmentCursorSeconds,
2098 });
2099 }
2100 pendingSegmentDurationSeconds = null;
2101 }
2102 }
2103
2104 return {
2105 childPlaylists,
2106 mediaAssets,
2107 mediaSegmentUris,
2108 mediaSegments,
2109 endList: /#EXT-X-ENDLIST/i.test(String(manifestText || '')),
2110 };
2111 }
2112
2113 function inferSegmentEndSecondsFromAssetUrl (assetUrl)
2114 {
2115 const value = String(assetUrl || '');
2116 if (!value) return null;
2117
2118 let pathname = value;
2119 try
2120 {
2121 pathname = new URL(value, window.location.href).pathname || value;
2122 } catch
2123 {
2124 // Ignore URL parsing failures and fall back to raw value matching.
2125 }
2126
2127 const match = pathname.match(/_segment_(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i)
2128 || pathname.match(/(?:^|[/._-])seg(?:ment)?[_-]?(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i);
2129 if (!match) return null;
2130
2131 const segmentIndex = Number.parseInt(match[1], 10);
2132 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return null;
2133 return (segmentIndex + 1) * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2134 }
2135
2136 function bindStreamAheadSeekMarker (player, streamAheadPrefetch, opts = {})
2137 {
2138 if (!player || typeof player.on !== 'function' || !streamAheadPrefetch) return null;
2139
2140 const markerChar = String(opts.markerChar || ':').slice(0, 1) || ':';
2141 const markerColor = String(opts.markerColor || '#d6d6d6');
2142 const showTimeTooltip = opts.showTimeTooltip === true;
2143 let markerEl = null;
2144 let markerContainerEl = null;
2145 let cachedThroughSeconds = null;
2146 let cachedThroughRatio = null;
2147 let detachProgressListener = null;
2148
2149 const currentDuration = () =>
2150 {
2151 const duration = Number(player.duration && player.duration());
2152 return Number.isFinite(duration) && duration > 0 ? duration : null;
2153 };
2154
2155 const updateMarker = () =>
2156 {
2157 if (!markerEl) return;
2158
2159 const duration = currentDuration();
2160 if (!duration || !Number.isFinite(cachedThroughSeconds) || cachedThroughSeconds < 0)
2161 {
2162 markerEl.style.display = 'none';
2163 return;
2164 }
2165
2166 const ratioFromSeconds = Number.isFinite(cachedThroughSeconds)
2167 ? Math.max(0, Math.min(1, cachedThroughSeconds / duration))
2168 : null;
2169 const ratioFromSections = Number.isFinite(cachedThroughRatio)
2170 ? Math.max(0, Math.min(1, cachedThroughRatio))
2171 : null;
2172 const ratio = Number.isFinite(ratioFromSeconds)
2173 ? ratioFromSeconds
2174 : ratioFromSections;
2175 if (!Number.isFinite(ratio) || ratio <= 0)
2176 {
2177 markerEl.style.display = 'none';
2178 return;
2179 }
2180
2181 markerEl.style.display = 'block';
2182 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
2183 if (showTimeTooltip)
2184 {
2185 if (Number.isFinite(cachedThroughSeconds))
2186 {
2187 markerEl.title = `Walker cached through ${formatClockTime(cachedThroughSeconds)}`;
2188 } else if (Number.isFinite(cachedThroughRatio))
2189 {
2190 markerEl.title = `Walker cached through ${Math.round(cachedThroughRatio * 100)}%`;
2191 } else
2192 {
2193 markerEl.title = 'Walker cached through';
2194 }
2195 } else
2196 {
2197 markerEl.removeAttribute('title');
2198 }
2199 };
2200
2201 const ensureMarker = () =>
2202 {
2203 if (markerContainerEl && markerContainerEl.isConnected)
2204 {
2205 updateMarker();
2206 return;
2207 }
2208
2209 const playerEl = player.el && player.el();
2210 if (!playerEl) return;
2211
2212 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
2213 || playerEl.querySelector('.vjs-progress-holder')
2214 || playerEl.querySelector('.vjs-progress-control');
2215 if (!seekBarEl) return;
2216
2217 const computedPosition = window.getComputedStyle(seekBarEl).position;
2218 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
2219
2220 markerContainerEl = document.createElement('div');
2221 markerContainerEl.className = 'vjs-stream-ahead-cache-marker-container';
2222 markerContainerEl.style.position = 'absolute';
2223 markerContainerEl.style.left = '0';
2224 markerContainerEl.style.right = '0';
2225 markerContainerEl.style.top = '50%';
2226 markerContainerEl.style.height = '10px';
2227 markerContainerEl.style.transform = 'translateY(-50%)';
2228 markerContainerEl.style.pointerEvents = 'none';
2229 markerContainerEl.style.zIndex = '4';
2230
2231 markerEl = document.createElement('span');
2232 markerEl.className = 'vjs-stream-ahead-cache-marker';
2233 markerEl.style.position = 'absolute';
2234 markerEl.style.top = '50%';
2235 markerEl.style.width = '10px';
2236 markerEl.style.height = '10px';
2237 markerEl.style.transform = 'translate(-50%, -50%)';
2238 markerEl.style.color = markerColor;
2239 markerEl.style.fontFamily = 'monospace';
2240 markerEl.style.fontSize = '12px';
2241 markerEl.style.fontWeight = '700';
2242 markerEl.style.lineHeight = '10px';
2243 markerEl.style.textAlign = 'center';
2244 markerEl.style.display = 'none';
2245 markerEl.style.textShadow = '0 0 2px rgba(0, 0, 0, 0.65)';
2246 markerEl.textContent = markerChar;
2247 markerEl.setAttribute('aria-hidden', 'true');
2248 if (showTimeTooltip)
2249 {
2250 markerEl.title = 'Walker cached through 00:00';
2251 }
2252
2253 markerContainerEl.appendChild(markerEl);
2254 seekBarEl.appendChild(markerContainerEl);
2255 updateMarker();
2256 };
2257
2258 const onDurationHint = () =>
2259 {
2260 ensureMarker();
2261 updateMarker();
2262 };
2263
2264 player.on('loadedmetadata', onDurationHint);
2265 player.on('durationchange', onDurationHint);
2266 player.on('loadedplaylist', onDurationHint);
2267 player.ready(onDurationHint);
2268
2269 if (typeof streamAheadPrefetch.subscribe === 'function')
2270 {
2271 detachProgressListener = streamAheadPrefetch.subscribe((status) =>
2272 {
2273 const nextCachedThrough = status && Number.isFinite(Number(status.cachedThroughSeconds))
2274 ? Number(status.cachedThroughSeconds)
2275 : null;
2276 cachedThroughSeconds = nextCachedThrough;
2277 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
2278 ? Number(status.cachedThroughRatio)
2279 : null;
2280 ensureMarker();
2281 updateMarker();
2282 });
2283 } else if (typeof streamAheadPrefetch.getStatus === 'function')
2284 {
2285 const status = streamAheadPrefetch.getStatus();
2286 cachedThroughSeconds = status && Number.isFinite(Number(status.cachedThroughSeconds))
2287 ? Number(status.cachedThroughSeconds)
2288 : null;
2289 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
2290 ? Number(status.cachedThroughRatio)
2291 : null;
2292 ensureMarker();
2293 updateMarker();
2294 }
2295
2296 return {
2297 detach: () =>
2298 {
2299 if (typeof detachProgressListener === 'function')
2300 {
2301 try { detachProgressListener(); } catch { /* ignore detach races */ }
2302 detachProgressListener = null;
2303 }
2304
2305 if (markerContainerEl && markerContainerEl.parentNode)
2306 {
2307 markerContainerEl.parentNode.removeChild(markerContainerEl);
2308 }
2309 markerContainerEl = null;
2310 markerEl = null;
2311 },
2312 };
2313 }
2314
2315 function bindStreamAheadPrefetch (opts = {})
2316 {
2317 const basePlaylistUrl = String(opts.playlistUrl || '').trim();
2318 if (!basePlaylistUrl) return null;
2319
2320 const pollIntervalMsRaw = Number(opts.pollIntervalMs);
2321 const pollIntervalMs = Number.isFinite(pollIntervalMsRaw) && pollIntervalMsRaw >= 0
2322 ? pollIntervalMsRaw
2323 : VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT;
2324 const headers = opts.headers;
2325 const credentials = opts.credentials;
2326
2327 const playlistStatusByUrl = new Map();
2328 const knownPlaylistUrls = new Set([basePlaylistUrl]);
2329 const fetchedAssetUrls = new Set();
2330 const segmentEndSecondsByAssetUrl = new Map();
2331 const discoveredSegmentUrls = new Set();
2332 const fetchedSegmentUrls = new Set();
2333 const progressListeners = new Set();
2334 const controller = typeof AbortController === 'function' ? new AbortController() : null;
2335 let stopped = false;
2336 let cachedThroughSeconds = null;
2337 let cachedThroughRatio = null;
2338 let fetchedTimelineAssetCount = 0;
2339
2340 const recalculateSegmentRatio = () =>
2341 {
2342 const totalSegments = discoveredSegmentUrls.size;
2343 if (totalSegments <= 0)
2344 {
2345 cachedThroughRatio = null;
2346 return;
2347 }
2348 cachedThroughRatio = Math.max(0, Math.min(1, fetchedSegmentUrls.size / totalSegments));
2349 };
2350
2351 const resolveUrl = (value, parentUrl) =>
2352 {
2353 try
2354 {
2355 return new URL(String(value || '').trim(), parentUrl || window.location.href).toString();
2356 } catch
2357 {
2358 return null;
2359 }
2360 };
2361
2362 const wait = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
2363
2364 const fetchText = async (url) =>
2365 {
2366 const res = await fetch(url, {
2367 method: 'GET',
2368 headers,
2369 credentials,
2370 cache: 'no-store',
2371 signal: controller ? controller.signal : undefined,
2372 });
2373 if (!res || !res.ok) return null;
2374 return res.text();
2375 };
2376
2377 const fetchAsset = async (url) =>
2378 {
2379 const res = await fetch(url, {
2380 method: 'GET',
2381 headers,
2382 credentials,
2383 signal: controller ? controller.signal : undefined,
2384 });
2385 if (!res || !res.ok) return false;
2386 // Ensure body fully reads so browser/service-worker caches the asset bytes.
2387 await res.arrayBuffer();
2388 return true;
2389 };
2390
2391 const getStatus = () => ({
2392 cachedThroughSeconds,
2393 cachedThroughRatio,
2394 knownPlaylistCount: knownPlaylistUrls.size,
2395 fetchedAssetCount: fetchedAssetUrls.size,
2396 fetchedTimelineAssetCount,
2397 totalSegmentCount: discoveredSegmentUrls.size,
2398 fetchedSegmentCount: fetchedSegmentUrls.size,
2399 allPlaylistsComplete: Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true),
2400 stopped,
2401 });
2402
2403 const appearsTimelineAsset = (assetUrl) =>
2404 /(?:\.ts|\.m4s|\.mp4|\.aac|\.m4a)(?:$|\?)/i.test(String(assetUrl || ''));
2405
2406 const emitProgress = () =>
2407 {
2408 const status = getStatus();
2409 for (const listener of Array.from(progressListeners))
2410 {
2411 try
2412 {
2413 listener(status);
2414 } catch
2415 {
2416 // Keep progress listeners best-effort only.
2417 }
2418 }
2419 };
2420
2421 const workerPromise = (async () =>
2422 {
2423 while (!stopped)
2424 {
2425 const nextAssetUrlSet = new Set();
2426
2427 for (const playlistUrl of Array.from(knownPlaylistUrls))
2428 {
2429 if (stopped) return;
2430 const manifestText = await fetchText(playlistUrl).catch(() => null);
2431 if (!manifestText) continue;
2432
2433 const parsed = parseHlsManifest(manifestText);
2434 playlistStatusByUrl.set(playlistUrl, !!parsed.endList);
2435
2436 for (const child of parsed.childPlaylists)
2437 {
2438 const resolved = resolveUrl(child, playlistUrl);
2439 if (!resolved) continue;
2440 knownPlaylistUrls.add(resolved);
2441 if (!playlistStatusByUrl.has(resolved)) playlistStatusByUrl.set(resolved, false);
2442 }
2443
2444 for (const asset of parsed.mediaAssets)
2445 {
2446 const resolved = resolveUrl(asset, playlistUrl);
2447 if (!resolved || fetchedAssetUrls.has(resolved)) continue;
2448 nextAssetUrlSet.add(resolved);
2449 }
2450
2451 for (const segment of parsed.mediaSegments)
2452 {
2453 if (!segment || !segment.uri) continue;
2454 const resolved = resolveUrl(segment.uri, playlistUrl);
2455 if (!resolved) continue;
2456 if (!Number.isFinite(segment.endTimeSeconds) || segment.endTimeSeconds < 0) continue;
2457 segmentEndSecondsByAssetUrl.set(resolved, Number(segment.endTimeSeconds));
2458 }
2459
2460 for (const segmentUri of parsed.mediaSegmentUris)
2461 {
2462 const resolved = resolveUrl(segmentUri, playlistUrl);
2463 if (!resolved) continue;
2464 discoveredSegmentUrls.add(resolved);
2465 }
2466 }
2467
2468 recalculateSegmentRatio();
2469 emitProgress();
2470
2471 const nextAssetUrls = Array.from(nextAssetUrlSet);
2472 for (const assetUrl of nextAssetUrls)
2473 {
2474 if (stopped) return;
2475 const fetched = await fetchAsset(assetUrl).catch(() => false);
2476 if (!fetched) continue;
2477
2478 fetchedAssetUrls.add(assetUrl);
2479 if (discoveredSegmentUrls.has(assetUrl))
2480 {
2481 fetchedSegmentUrls.add(assetUrl);
2482 }
2483 const mappedSegmentEndSeconds = segmentEndSecondsByAssetUrl.get(assetUrl);
2484 const inferredSegmentEndSeconds = inferSegmentEndSecondsFromAssetUrl(assetUrl);
2485 let fallbackSegmentEndSeconds = null;
2486 if (!Number.isFinite(mappedSegmentEndSeconds) && !Number.isFinite(inferredSegmentEndSeconds) && appearsTimelineAsset(assetUrl))
2487 {
2488 fetchedTimelineAssetCount += 1;
2489 fallbackSegmentEndSeconds = fetchedTimelineAssetCount * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2490 }
2491
2492 const segmentEndSeconds = [mappedSegmentEndSeconds, inferredSegmentEndSeconds, fallbackSegmentEndSeconds]
2493 .filter((value) => Number.isFinite(value))
2494 .reduce((maxValue, value) => (value > maxValue ? value : maxValue), -1);
2495
2496 if (Number.isFinite(segmentEndSeconds))
2497 {
2498 if (!Number.isFinite(cachedThroughSeconds) || segmentEndSeconds > cachedThroughSeconds)
2499 {
2500 cachedThroughSeconds = segmentEndSeconds;
2501 }
2502 }
2503
2504 recalculateSegmentRatio();
2505 emitProgress();
2506 }
2507
2508 const allPlaylistsComplete = Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true);
2509 if (allPlaylistsComplete && !nextAssetUrls.length)
2510 {
2511 emitProgress();
2512 return;
2513 }
2514
2515 if (pollIntervalMs > 0)
2516 {
2517 await wait(pollIntervalMs);
2518 }
2519 }
2520 })();
2521
2522 return {
2523 stop: () =>
2524 {
2525 stopped = true;
2526 if (controller && typeof controller.abort === 'function')
2527 {
2528 try { controller.abort(); } catch { /* ignore abort races */ }
2529 }
2530 emitProgress();
2531 },
2532 done: () => workerPromise,
2533 getStatus,
2534 subscribe: (listener) =>
2535 {
2536 if (typeof listener !== 'function') return () => { };
2537 progressListeners.add(listener);
2538 try { listener(getStatus()); } catch { /* ignore listener failures */ }
2539 return () =>
2540 {
2541 progressListeners.delete(listener);
2542 };
2543 },
2544 };
2545 }
2546
2547 function applyDefaultTextTrackPrefs ()
2548 {
2549 try
2550 {
2551 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
2552 } catch
2553 {
2554 // Ignore localStorage failures.
2555 }
2556 }
2557
2558 window.FilemanagerSharedVideoPlayer = {
2559 applyDefaultTextTrackPrefs,
2560 bindImageSubtitleOverlay,
2561 bindStreamAheadPrefetch,
2562 bindStreamAheadSeekMarker,
2563 bindTrackPrefs,
2564 clearVideoStreamClientCache,
2565 configureVideoJsBuffering,
2566 enableVideoStreamClientCache,
2567 ensureVideoPlaybackUi,
2568 normaliseVideoDuration,
2569 };
2570}());