BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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