BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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