BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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