BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

bim
timfa Tim Falken · pushed by timfa · 5 months ago
b942d635 History
shared-video-player.js 49.9 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
19 function roundLogNumber (value, digits = 3)
20 {
21 const numeric = Number(value);
22 if (!Number.isFinite(numeric)) return null;
23 return Number(numeric.toFixed(digits));
24 }
25
26 function parseHeaderInt (res, name)
27 {
28 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
29 const value = Number.parseInt(String(res.headers.get(name) || ''), 10);
30 return Number.isFinite(value) ? value : null;
31 }
32
33 function parseHeaderFloat (res, name)
34 {
35 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
36 const value = Number.parseFloat(String(res.headers.get(name) || ''));
37 return Number.isFinite(value) ? value : null;
38 }
39
40 function diffMilliseconds (later, earlier)
41 {
42 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
43 return Math.round(later - earlier);
44 }
45
46 function diffSeconds (later, earlier)
47 {
48 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
49 return roundLogNumber(later - earlier, 3);
50 }
51
52 function waitForImagePresentation (windowRef, imageEl)
53 {
54 return new Promise((resolve) =>
55 {
56 let settled = false;
57 let fallbackTimer = null;
58 const raf = typeof windowRef.requestAnimationFrame === 'function'
59 ? windowRef.requestAnimationFrame.bind(windowRef)
60 : (fn) => windowRef.setTimeout(fn, 0);
61
62 const cleanup = () =>
63 {
64 imageEl.removeEventListener('load', onLoad);
65 imageEl.removeEventListener('error', onError);
66 if (fallbackTimer !== null) windowRef.clearTimeout(fallbackTimer);
67 };
68
69 const finish = () =>
70 {
71 if (settled) return;
72 settled = true;
73 cleanup();
74 raf(() => resolve(Date.now()));
75 };
76
77 const onLoad = () => finish();
78 const onError = () => finish();
79
80 imageEl.addEventListener('load', onLoad);
81 imageEl.addEventListener('error', onError);
82 fallbackTimer = windowRef.setTimeout(finish, 250);
83
84 if (imageEl.complete && imageEl.currentSrc)
85 {
86 finish();
87 }
88 });
89 }
90
91 function normaliseTrackName (name)
92 {
93 return String(name || '').trim().toLowerCase();
94 }
95
96 function getTrackName (track)
97 {
98 if (!track || typeof track !== 'object') return '';
99 const label = String(track.label || '').trim();
100 if (label) return label;
101 const name = String(track.name || '').trim();
102 if (name) return name;
103 const language = String(track.language || '').trim();
104 if (language) return language;
105 const id = String(track.id || '').trim();
106 if (id) return id;
107 return '';
108 }
109
110 function trackListToArray (trackList)
111 {
112 if (!trackList || typeof trackList.length !== 'number') return [];
113 const out = [];
114 for (let i = 0; i < trackList.length; i++)
115 {
116 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
117 if (track) out.push(track);
118 }
119 return out;
120 }
121
122 function subtitleTracksFromPlayer (player)
123 {
124 if (!player || typeof player.textTracks !== 'function') return [];
125 return trackListToArray(player.textTracks()).filter((track) =>
126 {
127 const kind = String(track.kind || '').toLowerCase();
128 return kind === 'subtitles' || kind === 'captions';
129 });
130 }
131
132 function audioTracksFromPlayer (player)
133 {
134 if (!player || typeof player.audioTracks !== 'function') return [];
135 return trackListToArray(player.audioTracks());
136 }
137
138 function applySavedSubtitleTrack (player, savedName)
139 {
140 if (typeof savedName !== 'string') return;
141 const tracks = subtitleTracksFromPlayer(player);
142 if (!tracks.length) return;
143
144 const wanted = normaliseTrackName(savedName);
145 if (!wanted)
146 {
147 for (const track of tracks) track.mode = 'disabled';
148 return;
149 }
150
151 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
152 if (!match) return;
153
154 for (const track of tracks)
155 {
156 track.mode = track === match ? 'showing' : 'disabled';
157 }
158 }
159
160 function applySavedAudioTrack (player, savedName)
161 {
162 if (typeof savedName !== 'string') return;
163 const tracks = audioTracksFromPlayer(player);
164 if (!tracks.length) return;
165
166 const wanted = normaliseTrackName(savedName);
167 if (!wanted) return;
168
169 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
170 if (!match) return;
171
172 for (const track of tracks)
173 {
174 track.enabled = track === match;
175 }
176 }
177
178 function getSelectedSubtitleTrackName (player)
179 {
180 const tracks = subtitleTracksFromPlayer(player);
181 if (!tracks.length) return null;
182 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
183 return active ? getTrackName(active) : '';
184 }
185
186 function getSelectedAudioTrackName (player)
187 {
188 const tracks = audioTracksFromPlayer(player);
189 if (!tracks.length) return null;
190 const active = tracks.find((track) => !!track.enabled);
191 return active ? getTrackName(active) : '';
192 }
193
194 function bindTrackPrefs (player, prefs, savePrefs)
195 {
196 const save = typeof savePrefs === 'function' ? savePrefs : (() => { });
197 const applySavedTracks = () =>
198 {
199 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
200 applySavedAudioTrack(player, prefs.audioTrackName);
201 };
202
203 const captureSelectedTracks = () =>
204 {
205 const subtitleTrackName = getSelectedSubtitleTrackName(player);
206 const audioTrackName = getSelectedAudioTrackName(player);
207 const patch = {};
208
209 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
210 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
211
212 if (Object.keys(patch).length) save(patch);
213 };
214
215 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
216 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
217 const onTrackListChange = () => captureSelectedTracks();
218
219 if (textTrackList && typeof textTrackList.addEventListener === 'function')
220 {
221 textTrackList.addEventListener('change', onTrackListChange);
222 }
223
224 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
225 {
226 audioTrackList.addEventListener('change', onTrackListChange);
227 }
228
229 return {
230 applySavedTracks,
231 captureSelectedTracks,
232 detach: () =>
233 {
234 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
235 {
236 textTrackList.removeEventListener('change', onTrackListChange);
237 }
238 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
239 {
240 audioTrackList.removeEventListener('change', onTrackListChange);
241 }
242 },
243 };
244 }
245
246 function bindImageSubtitleOverlay (player, videojs, prefs, session, opts = {})
247 {
248 const imageTracks = Array.isArray(session.imageSubtitleTracks)
249 ? session.imageSubtitleTracks.map((track) => ({
250 label: String(track.label || '').trim() || `Subtitle ${Number(track.streamIndex || 0) + 1}`,
251 language: String(track.language || '').trim(),
252 isDefault: !!track.default,
253 streamIndex: Number(track.streamIndex),
254 })).filter((track) => Number.isInteger(track.streamIndex) && track.streamIndex >= 0)
255 : [];
256
257 if (!imageTracks.length) return null;
258
259 const savePrefs = typeof opts.savePrefs === 'function' ? opts.savePrefs : (() => { });
260 const buildFrameRequest = typeof opts.buildFrameRequest === 'function' ? opts.buildFrameRequest : null;
261 const notifyError = typeof opts.onError === 'function' ? opts.onError : (() => { });
262 const sendSubtitleLogBatch = typeof opts.sendSubtitleLogBatch === 'function' ? opts.sendSubtitleLogBatch : null;
263 const requestedLookaheadSeconds = Number(opts.lookaheadSeconds);
264 const lookaheadSeconds = Number.isFinite(requestedLookaheadSeconds)
265 ? Math.max(0, Math.min(IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX, requestedLookaheadSeconds))
266 : IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT;
267 const requestedCurrentRequestTimeoutMs = Number(opts.currentRequestTimeoutMs);
268 const currentRequestTimeoutMs = Number.isFinite(requestedCurrentRequestTimeoutMs)
269 ? Math.max(250, requestedCurrentRequestTimeoutMs)
270 : IMAGE_SUBTITLE_CURRENT_REQUEST_TIMEOUT_MS_DEFAULT;
271 const requestedPrefetchRequestTimeoutMs = Number(opts.prefetchRequestTimeoutMs);
272 const prefetchRequestTimeoutMs = Number.isFinite(requestedPrefetchRequestTimeoutMs)
273 ? Math.max(250, requestedPrefetchRequestTimeoutMs)
274 : IMAGE_SUBTITLE_PREFETCH_REQUEST_TIMEOUT_MS_DEFAULT;
275 const requestedPrefetchRequestIntervalMs = Number(opts.prefetchRequestIntervalMs);
276 const prefetchRequestIntervalMs = Number.isFinite(requestedPrefetchRequestIntervalMs)
277 ? Math.max(0, requestedPrefetchRequestIntervalMs)
278 : IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS_DEFAULT;
279 const logToConsole = opts.logToConsole !== false;
280 if (!buildFrameRequest) return null;
281
282 const trackByStreamIndex = new Map(imageTracks.map((track) => [track.streamIndex, track]));
283 let selectedStreamIndex = null;
284 let menuOpen = false;
285 let activeBucket = -1;
286 let activeObjectUrl = null;
287 let overlayEl = null;
288 let overlayImgEl = null;
289 let menuEl = null;
290 let buttonEl = null;
291 let trackDisabled = false;
292 let failureNotified = false;
293 let lifecycleToken = 0;
294 let currentFrameToken = 0;
295 let currentFrameAbortController = null;
296 let prefetchWorkerToken = 0;
297 let prefetchAbortController = null;
298 let prefetchPromise = null;
299 let prefetchTargetTimeSeconds = -1;
300 let prefetchedThroughTimeSeconds = -1;
301 let queuedCurrentRefresh = false;
302 let queuedCurrentRefreshForce = false;
303 let currentFramePromise = null;
304 let seekMarkerContainerEl = null;
305 let seekMarkerRequestedEl = null;
306 let seekMarkerReceivedEl = null;
307 let seekMarkerCombinedEl = null;
308 let lastRequestedCaptionStartTimeSeconds = null;
309 let lastReceivedCaptionStartTimeSeconds = null;
310 let subtitleLogSequence = 0;
311 let subtitleLogQueue = [];
312 let subtitleLogFlushTimer = null;
313
314 const flushSubtitleLogs = () =>
315 {
316 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
317 if (subtitleLogFlushTimer)
318 {
319 window.clearTimeout(subtitleLogFlushTimer);
320 subtitleLogFlushTimer = null;
321 }
322
323 const batch = subtitleLogQueue;
324 subtitleLogQueue = [];
325 Promise.resolve(sendSubtitleLogBatch(batch)).catch(() =>
326 {
327 // Keep subtitle diagnostics best-effort only.
328 });
329 };
330
331 const scheduleSubtitleLogFlush = () =>
332 {
333 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
334 if (subtitleLogQueue.length >= SUBTITLE_LOG_BATCH_MAX_ITEMS)
335 {
336 flushSubtitleLogs();
337 return;
338 }
339 if (subtitleLogFlushTimer) return;
340 subtitleLogFlushTimer = window.setTimeout(() =>
341 {
342 subtitleLogFlushTimer = null;
343 flushSubtitleLogs();
344 }, SUBTITLE_LOG_FLUSH_DELAY_MS);
345 };
346
347 const logSubtitleEvent = (eventType, details = {}) =>
348 {
349 const entry = {
350 seq: ++subtitleLogSequence,
351 loggedAtMs: Date.now(),
352 eventType,
353 sessionId: String(session.sessionId || '').trim() || null,
354 streamIndex: Number.isInteger(selectedStreamIndex) ? selectedStreamIndex : null,
355 playerTimeSeconds: roundLogNumber(player.currentTime()),
356 ...details,
357 };
358 if (logToConsole)
359 {
360 try
361 {
362 console.log('[subtitle-log]', entry);
363 } catch
364 {
365 // Ignore console availability issues.
366 }
367 }
368
369 if (!sendSubtitleLogBatch) return;
370 subtitleLogQueue.push(entry);
371 scheduleSubtitleLogFlush();
372 };
373
374 const createAbortController = () =>
375 {
376 if (typeof AbortController !== 'function') return null;
377 return new AbortController();
378 };
379
380 const abortController = (controller) =>
381 {
382 if (!controller || typeof controller.abort !== 'function') return;
383 try
384 {
385 controller.abort();
386 } catch
387 {
388 // Ignore abort races during teardown.
389 }
390 };
391
392 const isAbortError = (error) =>
393 {
394 return !!(error && typeof error === 'object' && error.name === 'AbortError');
395 };
396
397 const armRequestTimeout = (controller, timeoutMs, onTimeout) =>
398 {
399 if (!controller || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
400 return window.setTimeout(() =>
401 {
402 if (typeof onTimeout === 'function') onTimeout();
403 abortController(controller);
404 }, timeoutMs);
405 };
406
407 const clearRequestTimeout = (timeoutId) =>
408 {
409 if (timeoutId === null || timeoutId === undefined) return;
410 window.clearTimeout(timeoutId);
411 };
412
413 const cancelCurrentFrameRequest = () =>
414 {
415 currentFrameToken++;
416 abortController(currentFrameAbortController);
417 currentFrameAbortController = null;
418 };
419
420 const cancelPrefetchRequests = ({ resetProgress = false } = {}) =>
421 {
422 prefetchWorkerToken++;
423 abortController(prefetchAbortController);
424 prefetchAbortController = null;
425 prefetchPromise = null;
426 if (resetProgress)
427 {
428 prefetchTargetTimeSeconds = -1;
429 prefetchedThroughTimeSeconds = -1;
430 }
431 };
432
433 const resetRequestState = () =>
434 {
435 lifecycleToken++;
436 cancelCurrentFrameRequest();
437 cancelPrefetchRequests({ resetProgress: true });
438 };
439
440 const closeObjectUrl = () =>
441 {
442 if (activeObjectUrl)
443 {
444 URL.revokeObjectURL(activeObjectUrl);
445 activeObjectUrl = null;
446 }
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 setSeekMarkerTime = (kind, timeSeconds) =>
457 {
458 const numericTime = Number(timeSeconds);
459 const nextTime = Number.isFinite(numericTime) && numericTime >= 0 ? numericTime : null;
460
461 if (kind === 'requested')
462 {
463 lastRequestedCaptionStartTimeSeconds = nextTime;
464 } else if (kind === 'received')
465 {
466 lastReceivedCaptionStartTimeSeconds = nextTime;
467 }
468 };
469
470 const updateSeekBarMarkers = () =>
471 {
472 if (!seekMarkerRequestedEl || !seekMarkerReceivedEl || !seekMarkerCombinedEl) return;
473
474 const duration = Number(player.duration && player.duration());
475 if (!Number.isFinite(duration) || duration <= 0)
476 {
477 seekMarkerRequestedEl.style.display = 'none';
478 seekMarkerReceivedEl.style.display = 'none';
479 seekMarkerCombinedEl.style.display = 'none';
480 return;
481 }
482
483 const getMarkerRatio = (markerTimeSeconds) =>
484 {
485 if (!Number.isFinite(markerTimeSeconds) || markerTimeSeconds < 0)
486 {
487 return null;
488 }
489
490 return Math.max(0, Math.min(1, markerTimeSeconds / duration));
491 };
492
493 const applyMarker = (markerEl, ratio) =>
494 {
495 if (!Number.isFinite(ratio))
496 {
497 markerEl.style.display = 'none';
498 return;
499 }
500
501 markerEl.style.display = 'block';
502 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
503 };
504
505 const requestedRatio = getMarkerRatio(lastRequestedCaptionStartTimeSeconds);
506 const receivedRatio = getMarkerRatio(lastReceivedCaptionStartTimeSeconds);
507 const shouldCombine = Number.isFinite(requestedRatio)
508 && Number.isFinite(receivedRatio)
509 && Math.abs(requestedRatio - receivedRatio) <= 1e-6;
510
511 if (shouldCombine)
512 {
513 applyMarker(seekMarkerCombinedEl, requestedRatio);
514 seekMarkerRequestedEl.style.display = 'none';
515 seekMarkerReceivedEl.style.display = 'none';
516 return;
517 }
518
519 seekMarkerCombinedEl.style.display = 'none';
520 applyMarker(seekMarkerRequestedEl, requestedRatio);
521 applyMarker(seekMarkerReceivedEl, receivedRatio);
522 };
523
524 const ensureSeekBarMarkers = () =>
525 {
526 if (seekMarkerContainerEl && seekMarkerContainerEl.isConnected)
527 {
528 updateSeekBarMarkers();
529 return;
530 }
531
532 const playerEl = player.el && player.el();
533 if (!playerEl) return;
534
535 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
536 || playerEl.querySelector('.vjs-progress-holder')
537 || playerEl.querySelector('.vjs-progress-control');
538 if (!seekBarEl) return;
539
540 const computedPosition = window.getComputedStyle(seekBarEl).position;
541 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
542
543 seekMarkerContainerEl = document.createElement('div');
544 seekMarkerContainerEl.className = 'vjs-image-subtitle-seek-markers';
545 seekMarkerContainerEl.style.position = 'absolute';
546 seekMarkerContainerEl.style.left = '0';
547 seekMarkerContainerEl.style.right = '0';
548 seekMarkerContainerEl.style.top = '50%';
549 seekMarkerContainerEl.style.height = '10px';
550 seekMarkerContainerEl.style.transform = 'translateY(-50%)';
551 seekMarkerContainerEl.style.pointerEvents = 'none';
552 seekMarkerContainerEl.style.zIndex = '5';
553
554 const buildBracketMarker = (direction) =>
555 {
556 const markerEl = document.createElement('span');
557 markerEl.className = `vjs-image-subtitle-seek-marker vjs-image-subtitle-seek-marker-${direction}`;
558 markerEl.style.position = 'absolute';
559 markerEl.style.top = '50%';
560 markerEl.style.width = '10px';
561 markerEl.style.height = '10px';
562 markerEl.style.transform = 'translate(-50%, -50%)';
563 markerEl.style.color = '#fff';
564 markerEl.style.fontFamily = 'monospace';
565 markerEl.style.fontSize = '12px';
566 markerEl.style.fontWeight = '700';
567 markerEl.style.lineHeight = '10px';
568 markerEl.style.textAlign = 'center';
569 markerEl.style.display = 'none';
570 markerEl.textContent = direction === 'left' ? '[' : ']';
571 markerEl.setAttribute('aria-hidden', 'true');
572 return markerEl;
573 };
574
575 const buildCombinedMarker = () =>
576 {
577 const markerEl = document.createElement('span');
578 markerEl.className = 'vjs-image-subtitle-seek-marker vjs-image-subtitle-seek-marker-combined';
579 markerEl.style.position = 'absolute';
580 markerEl.style.top = '50%';
581 markerEl.style.width = '16px';
582 markerEl.style.height = '10px';
583 markerEl.style.transform = 'translate(-50%, -50%)';
584 markerEl.style.color = '#fff';
585 markerEl.style.fontFamily = 'monospace';
586 markerEl.style.fontSize = '12px';
587 markerEl.style.fontWeight = '700';
588 markerEl.style.lineHeight = '10px';
589 markerEl.style.textAlign = 'center';
590 markerEl.style.display = 'none';
591 markerEl.textContent = '[]';
592 markerEl.setAttribute('aria-hidden', 'true');
593 return markerEl;
594 };
595
596 seekMarkerReceivedEl = buildBracketMarker('left');
597 seekMarkerRequestedEl = buildBracketMarker('right');
598 seekMarkerCombinedEl = buildCombinedMarker();
599 seekMarkerContainerEl.appendChild(seekMarkerReceivedEl);
600 seekMarkerContainerEl.appendChild(seekMarkerRequestedEl);
601 seekMarkerContainerEl.appendChild(seekMarkerCombinedEl);
602
603 seekBarEl.appendChild(seekMarkerContainerEl);
604 updateSeekBarMarkers();
605 };
606
607 const updateButtonState = () =>
608 {
609 if (!buttonEl) return;
610 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
611 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
612 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
613 };
614
615 const updateMenuState = () =>
616 {
617 if (!menuEl) return;
618 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
619 for (const itemEl of items)
620 {
621 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
622 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
623 itemEl.classList.toggle('is-selected', isSelected);
624 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
625 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
626 itemEl.style.fontWeight = isSelected ? '600' : '400';
627 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
628 }
629 };
630
631 const closeMenu = () =>
632 {
633 menuOpen = false;
634 if (menuEl) menuEl.style.display = 'none';
635 };
636
637 const openMenu = () =>
638 {
639 menuOpen = true;
640 if (menuEl)
641 {
642 updateMenuState();
643 menuEl.style.display = 'block';
644 }
645 };
646
647 const toggleMenu = () =>
648 {
649 if (menuOpen) closeMenu();
650 else openMenu();
651 };
652
653 const saveSelection = () =>
654 {
655 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
656 savePrefs({
657 imageSubtitleTrackStreamIndex: selectedStreamIndex,
658 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
659 });
660 };
661
662 const disableTrack = () =>
663 {
664 trackDisabled = true;
665 selectedStreamIndex = null;
666 activeBucket = -1;
667 setSeekMarkerTime('requested', null);
668 setSeekMarkerTime('received', null);
669 updateSeekBarMarkers();
670 resetRequestState();
671 hideOverlay();
672 updateButtonState();
673 updateMenuState();
674 saveSelection();
675
676 if (!failureNotified)
677 {
678 failureNotified = true;
679 notifyError();
680 }
681 };
682
683 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
684 {
685 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
686 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
687
688 trackDisabled = false;
689 failureNotified = false;
690 selectedStreamIndex = nextStreamIndex;
691 activeBucket = -1;
692 setSeekMarkerTime('requested', null);
693 setSeekMarkerTime('received', null);
694 updateSeekBarMarkers();
695 resetRequestState();
696 hideOverlay();
697 updateButtonState();
698 updateMenuState();
699 if (persist) saveSelection();
700
701 if (selectedStreamIndex !== null)
702 {
703 void refreshFrame(true);
704 }
705 };
706
707 const queueLookaheadPrefetch = (currentTime, { reset = false } = {}) =>
708 {
709 if (selectedStreamIndex === null) return;
710 if (trackDisabled) return;
711
712 const bufferedVideoEndSeconds = (() =>
713 {
714 const fromPlayer = Number(player.bufferedEnd && player.bufferedEnd());
715 if (Number.isFinite(fromPlayer) && fromPlayer >= 0) return fromPlayer;
716
717 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
718 const mediaEl = tech && typeof tech.el === 'function'
719 ? tech.el()
720 : (player.el && player.el() ? player.el().querySelector('video') : null);
721
722 const ranges = mediaEl && mediaEl.buffered;
723 if (!ranges || typeof ranges.length !== 'number' || ranges.length <= 0 || typeof ranges.end !== 'function')
724 {
725 return null;
726 }
727
728 try
729 {
730 const endTime = Number(ranges.end(ranges.length - 1));
731 return Number.isFinite(endTime) && endTime >= 0 ? endTime : null;
732 } catch
733 {
734 return null;
735 }
736 })();
737
738 const startTime = currentTime + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
739 const endTime = Math.max(currentTime + lookaheadSeconds, Number.isFinite(bufferedVideoEndSeconds) ? bufferedVideoEndSeconds : -1);
740 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
741
742 if (reset || prefetchedThroughTimeSeconds < 0 || prefetchedThroughTimeSeconds < currentTime - IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS)
743 {
744 cancelPrefetchRequests({ resetProgress: true });
745 prefetchedThroughTimeSeconds = currentTime;
746 }
747
748 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
749 if (prefetchPromise) return;
750
751 const workerToken = ++prefetchWorkerToken;
752 const workerLifecycleToken = lifecycleToken;
753 const controller = createAbortController();
754 prefetchAbortController = controller;
755
756 prefetchPromise = (async () =>
757 {
758 while (true)
759 {
760 if (selectedStreamIndex === null || trackDisabled) return;
761 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
762
763 const nextTime = prefetchedThroughTimeSeconds < 0
764 ? startTime
765 : prefetchedThroughTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
766 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
767
768 const request = buildFrameRequest({
769 streamIndex: selectedStreamIndex,
770 currentTime: nextTime,
771 session,
772 });
773 if (!request || !request.url) return;
774
775 const prefetchRequestStartedAtMs = Date.now();
776 const prefetchRequestId = `prefetch-${workerToken}-${Math.round(nextTime * 1000)}`;
777 logSubtitleEvent('subtitle_png_requested', {
778 requestId: prefetchRequestId,
779 requestKind: 'prefetch',
780 requestUrl: String(request.url || ''),
781 requestedAtMs: prefetchRequestStartedAtMs,
782 requestedVideoTimeSeconds: roundLogNumber(nextTime),
783 });
784
785 let prefetchTimedOut = false;
786 const timeoutId = armRequestTimeout(controller, prefetchRequestTimeoutMs, () =>
787 {
788 prefetchTimedOut = true;
789 });
790
791 try
792 {
793 const res = await fetch(request.url, {
794 method: request.method || 'GET',
795 headers: request.headers,
796 credentials: request.credentials,
797 signal: controller ? controller.signal : undefined,
798 });
799 clearRequestTimeout(timeoutId);
800
801 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
802
803 const responseMeta = {
804 requestId: prefetchRequestId,
805 requestKind: 'prefetch',
806 status: res.status,
807 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
808 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
809 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
810 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
811 responseHeadersReceivedAtMs: Date.now(),
812 requestedVideoTimeSeconds: roundLogNumber(nextTime),
813 };
814 logSubtitleEvent('subtitle_png_sent', {
815 ...responseMeta,
816 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
817 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
818 });
819
820 setSeekMarkerTime('requested', nextTime);
821 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
822 ? responseMeta.shouldShowAtVideoTimeSeconds
823 : nextTime;
824 setSeekMarkerTime('received', receivedMarkerTime);
825 updateSeekBarMarkers();
826
827 if (res.status === 204)
828 {
829 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
830 logSubtitleEvent('subtitle_png_not_available', {
831 ...responseMeta,
832 frameStatus,
833 });
834 if (frameStatus === 'error') return;
835 prefetchedThroughTimeSeconds = nextTime;
836 if (prefetchRequestIntervalMs > 0)
837 {
838 await new Promise((resolve) => window.setTimeout(resolve, prefetchRequestIntervalMs));
839 }
840 continue;
841 }
842
843 if (!res.ok) return;
844 const payload = await res.arrayBuffer();
845 const receivedAtMs = Date.now();
846 logSubtitleEvent('subtitle_png_received', {
847 ...responseMeta,
848 receivedAtMs,
849 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
850 requestedToReceivedMs: diffMilliseconds(receivedAtMs, prefetchRequestStartedAtMs),
851 blobBytes: Number(payload && payload.byteLength || 0),
852 });
853 prefetchedThroughTimeSeconds = nextTime;
854 if (prefetchRequestIntervalMs > 0)
855 {
856 await new Promise((resolve) => window.setTimeout(resolve, prefetchRequestIntervalMs));
857 }
858 } catch (error)
859 {
860 clearRequestTimeout(timeoutId);
861 if (prefetchTimedOut)
862 {
863 logSubtitleEvent('subtitle_png_request_failed', {
864 requestId: prefetchRequestId,
865 requestKind: 'prefetch',
866 requestedAtMs: prefetchRequestStartedAtMs,
867 errorName: 'AbortError',
868 errorMessage: `Prefetch subtitle request timed out after ${Math.round(prefetchRequestTimeoutMs)}ms`,
869 });
870 return;
871 }
872 if (isAbortError(error)) return;
873 logSubtitleEvent('subtitle_png_request_failed', {
874 requestId: prefetchRequestId,
875 requestKind: 'prefetch',
876 requestedAtMs: prefetchRequestStartedAtMs,
877 errorName: error && error.name ? String(error.name) : null,
878 errorMessage: error && error.message ? String(error.message) : String(error || ''),
879 });
880 return;
881 }
882 }
883 })().finally(() =>
884 {
885 if (workerToken !== prefetchWorkerToken) return;
886 prefetchAbortController = null;
887 prefetchPromise = null;
888 });
889 };
890
891 const refreshFrame = async (force = false) =>
892 {
893 if (selectedStreamIndex === null) return;
894 if (!overlayEl || !overlayImgEl) return;
895 if (trackDisabled) return;
896
897 if (currentFramePromise && !force)
898 {
899 queuedCurrentRefresh = true;
900 return;
901 }
902
903 const currentTime = Number(player.currentTime());
904 if (!Number.isFinite(currentTime) || currentTime < 0) return;
905
906 const bucket = Math.floor(currentTime * 4);
907 if (!force && bucket === activeBucket) return;
908 activeBucket = bucket;
909
910 const refreshLifecycleToken = lifecycleToken;
911 if (force && currentFramePromise)
912 {
913 cancelCurrentFrameRequest();
914 }
915 if (currentFramePromise)
916 {
917 queuedCurrentRefresh = true;
918 queuedCurrentRefreshForce = queuedCurrentRefreshForce || !!force;
919 return;
920 }
921 cancelCurrentFrameRequest();
922 if (force) cancelPrefetchRequests({ resetProgress: true });
923
924 const token = ++currentFrameToken;
925 const requestId = `current-${token}`;
926 const requestStartedAtMs = Date.now();
927 const controller = createAbortController();
928 currentFrameAbortController = controller;
929 const request = buildFrameRequest({
930 streamIndex: selectedStreamIndex,
931 currentTime,
932 session,
933 });
934
935 if (!request || !request.url)
936 {
937 disableTrack();
938 return;
939 }
940
941 logSubtitleEvent('subtitle_png_requested', {
942 requestId,
943 requestKind: 'current',
944 requestUrl: String(request.url || ''),
945 requestedAtMs: requestStartedAtMs,
946 requestedVideoTimeSeconds: roundLogNumber(currentTime),
947 });
948
949 currentFramePromise = (async () =>
950 {
951 let currentTimedOut = false;
952 const timeoutId = armRequestTimeout(controller, currentRequestTimeoutMs, () =>
953 {
954 currentTimedOut = true;
955 });
956 try
957 {
958 const res = await fetch(request.url, {
959 method: request.method || 'GET',
960 headers: request.headers,
961 credentials: request.credentials,
962 signal: controller ? controller.signal : undefined,
963 });
964 clearRequestTimeout(timeoutId);
965
966 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
967
968 const responseMeta = {
969 requestId,
970 requestKind: 'current',
971 status: res.status,
972 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
973 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
974 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
975 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
976 responseHeadersReceivedAtMs: Date.now(),
977 requestedVideoTimeSeconds: roundLogNumber(currentTime),
978 };
979 logSubtitleEvent('subtitle_png_sent', {
980 ...responseMeta,
981 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
982 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
983 });
984
985 setSeekMarkerTime('requested', currentTime);
986 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
987 ? responseMeta.shouldShowAtVideoTimeSeconds
988 : currentTime;
989 setSeekMarkerTime('received', receivedMarkerTime);
990 updateSeekBarMarkers();
991
992 if (res.status === 204)
993 {
994 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
995 logSubtitleEvent('subtitle_png_not_available', {
996 ...responseMeta,
997 frameStatus,
998 });
999 hideOverlay();
1000 if (frameStatus === 'error') disableTrack();
1001 else queueLookaheadPrefetch(currentTime, { reset: force });
1002 return;
1003 }
1004
1005 if (!res.ok)
1006 {
1007 disableTrack();
1008 return;
1009 }
1010
1011 const blob = await res.blob();
1012 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1013
1014 const receivedAtMs = Date.now();
1015 logSubtitleEvent('subtitle_png_received', {
1016 ...responseMeta,
1017 receivedAtMs,
1018 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1019 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
1020 blobBytes: Number(blob && blob.size || 0),
1021 });
1022
1023 if (!blob || blob.size === 0)
1024 {
1025 disableTrack();
1026 return;
1027 }
1028
1029 closeObjectUrl();
1030 activeObjectUrl = URL.createObjectURL(blob);
1031 overlayImgEl.src = activeObjectUrl;
1032
1033 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
1034 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
1035 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
1036 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
1037
1038 if (frameWidth > 0 && frameHeight > 0 && canvasWidth > 0 && canvasHeight > 0)
1039 {
1040 const widthPercent = (frameWidth / canvasWidth) * 100;
1041 const heightPercent = (frameHeight / canvasHeight) * 100;
1042 overlayImgEl.style.width = `${widthPercent}%`;
1043 overlayImgEl.style.height = `${heightPercent}%`;
1044 overlayImgEl.style.maxWidth = 'none';
1045 overlayImgEl.style.maxHeight = 'none';
1046 } else
1047 {
1048 overlayImgEl.style.width = 'auto';
1049 overlayImgEl.style.height = 'auto';
1050 overlayImgEl.style.maxWidth = '100%';
1051 overlayImgEl.style.maxHeight = '100%';
1052 }
1053
1054 overlayEl.style.display = 'block';
1055 overlayImgEl.style.display = 'block';
1056
1057 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
1058 {
1059 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1060 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
1061 logSubtitleEvent('subtitle_png_shown', {
1062 ...responseMeta,
1063 receivedAtMs,
1064 shownAtMs,
1065 shownAtVideoTimeSeconds,
1066 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1067 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
1068 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
1069 });
1070 });
1071
1072 queueLookaheadPrefetch(currentTime, { reset: force });
1073 } catch (error)
1074 {
1075 clearRequestTimeout(timeoutId);
1076 if (currentTimedOut)
1077 {
1078 logSubtitleEvent('subtitle_png_request_failed', {
1079 requestId,
1080 requestKind: 'current',
1081 requestedAtMs: requestStartedAtMs,
1082 errorName: 'AbortError',
1083 errorMessage: `Current subtitle request timed out after ${Math.round(currentRequestTimeoutMs)}ms`,
1084 });
1085 return;
1086 }
1087 if (isAbortError(error)) return;
1088 logSubtitleEvent('subtitle_png_request_failed', {
1089 requestId,
1090 requestKind: 'current',
1091 requestedAtMs: requestStartedAtMs,
1092 errorName: error && error.name ? String(error.name) : null,
1093 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1094 });
1095 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
1096 }
1097 })().finally(() =>
1098 {
1099 if (token !== currentFrameToken) return;
1100 currentFrameAbortController = null;
1101 currentFramePromise = null;
1102 if (!queuedCurrentRefresh) return;
1103
1104 const queuedForce = queuedCurrentRefreshForce;
1105 queuedCurrentRefresh = false;
1106 queuedCurrentRefreshForce = false;
1107 void refreshFrame(queuedForce);
1108 });
1109
1110 return currentFramePromise;
1111 };
1112
1113 const dispose = () =>
1114 {
1115 resetRequestState();
1116 flushSubtitleLogs();
1117 closeMenu();
1118 hideOverlay();
1119 if (seekMarkerContainerEl) seekMarkerContainerEl.remove();
1120 seekMarkerContainerEl = null;
1121 seekMarkerRequestedEl = null;
1122 seekMarkerReceivedEl = null;
1123 seekMarkerCombinedEl = null;
1124 if (overlayEl) overlayEl.remove();
1125 if (menuEl) menuEl.remove();
1126 player.imageSubtitleOverlayController = null;
1127 buttonEl = null;
1128 };
1129
1130 overlayEl = document.createElement('div');
1131 overlayEl.className = 'video-subtitle-overlay';
1132 overlayEl.style.position = 'absolute';
1133 overlayEl.style.left = '0';
1134 overlayEl.style.right = '0';
1135 overlayEl.style.bottom = '3rem';
1136 overlayEl.style.display = 'none';
1137 overlayEl.style.zIndex = '3';
1138 overlayEl.style.pointerEvents = 'none';
1139 overlayEl.style.textAlign = 'center';
1140 overlayEl.style.padding = '0 0.75rem';
1141 overlayEl.style.maxHeight = '70%';
1142 overlayEl.style.overflow = 'hidden';
1143
1144 overlayImgEl = document.createElement('img');
1145 overlayImgEl.alt = 'Image subtitles';
1146 overlayImgEl.style.display = 'none';
1147 overlayImgEl.style.margin = '0 auto';
1148 overlayImgEl.style.objectFit = 'contain';
1149 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1150 overlayImgEl.style.maxWidth = '100%';
1151 overlayImgEl.style.height = 'auto';
1152 overlayEl.appendChild(overlayImgEl);
1153
1154 menuEl = document.createElement('div');
1155 menuEl.className = 'video-subtitle-overlay-menu';
1156 menuEl.style.position = 'absolute';
1157 menuEl.style.right = '0.75rem';
1158 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
1159 menuEl.style.minWidth = '14rem';
1160 menuEl.style.maxWidth = '20rem';
1161 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
1162 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
1163 menuEl.style.borderRadius = '0.5rem';
1164 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
1165 menuEl.style.padding = '0.35rem';
1166 menuEl.style.display = 'none';
1167 menuEl.style.zIndex = '4';
1168
1169 const buildMenuItem = (label, streamIndex, isSelected) =>
1170 {
1171 const itemEl = document.createElement('button');
1172 itemEl.type = 'button';
1173 itemEl.className = 'video-subtitle-overlay-menu-item';
1174 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
1175 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1176 itemEl.style.display = 'block';
1177 itemEl.style.width = '100%';
1178 itemEl.style.margin = '0';
1179 itemEl.style.padding = '0.5rem 0.75rem';
1180 itemEl.style.border = '0';
1181 itemEl.style.borderRadius = '0.35rem';
1182 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
1183 itemEl.style.color = '#fff';
1184 itemEl.style.textAlign = 'left';
1185 itemEl.style.cursor = 'pointer';
1186 itemEl.textContent = label;
1187 itemEl.addEventListener('click', () =>
1188 {
1189 setSelectedStreamIndex(streamIndex);
1190 closeMenu();
1191 });
1192 return itemEl;
1193 };
1194
1195 menuEl.appendChild(buildMenuItem('Off', null, false));
1196 for (const track of imageTracks)
1197 {
1198 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
1199 }
1200
1201 const registerButton = () =>
1202 {
1203 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
1204 if (videojs.getComponent('ImageSubtitleButton')) return;
1205
1206 const Button = videojs.getComponent('Button');
1207 class ImageSubtitleButton extends Button
1208 {
1209 buildCSSClass ()
1210 {
1211 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
1212 }
1213
1214 createEl ()
1215 {
1216 const el = super.createEl();
1217 el.type = 'button';
1218 el.setAttribute('title', 'Image subtitles');
1219 el.setAttribute('aria-label', 'Image subtitles');
1220 el.innerHTML = '<span aria-hidden="true">IM</span>';
1221 return el;
1222 }
1223
1224 handleClick ()
1225 {
1226 const controller = this.player().imageSubtitleOverlayController;
1227 if (controller) controller.toggleMenu();
1228 }
1229 }
1230
1231 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
1232 };
1233
1234 const attachUi = () =>
1235 {
1236 if (!player.el()) return;
1237 registerButton();
1238 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
1239 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
1240 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
1241 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
1242 {
1243 const button = controlBar.addChild('ImageSubtitleButton', {});
1244 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
1245 updateButtonState();
1246 }
1247 };
1248
1249 const applySavedTracks = () =>
1250 {
1251 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
1252 if (savedName)
1253 {
1254 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
1255 if (savedByName)
1256 {
1257 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
1258 return;
1259 }
1260 }
1261
1262 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
1263 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
1264 {
1265 setSelectedStreamIndex(savedIndex, { persist: false });
1266 return;
1267 }
1268
1269 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
1270 if (defaultTrack)
1271 {
1272 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
1273 return;
1274 }
1275
1276 setSelectedStreamIndex(null, { persist: false });
1277 };
1278
1279 player.imageSubtitleOverlayController = {
1280 toggleMenu,
1281 closeMenu,
1282 applySavedTracks,
1283 captureSelectedTracks: saveSelection,
1284 detach: dispose,
1285 };
1286
1287 player.on('timeupdate', () => { void refreshFrame(); });
1288 player.on('seeking', () => { void refreshFrame(true); });
1289 player.on('play', () => { void refreshFrame(true); });
1290 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
1291 player.on('dispose', dispose);
1292 player.ready(() =>
1293 {
1294 attachUi();
1295 ensureSeekBarMarkers();
1296 updateMenuState();
1297 updateButtonState();
1298 updateSeekBarMarkers();
1299 applySavedTracks();
1300 if (menuOpen) openMenu();
1301 });
1302
1303 player.on('durationchange', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1304 player.on('loadedmetadata', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1305
1306 return player.imageSubtitleOverlayController;
1307 }
1308
1309 function formatDurationForDebug (seconds)
1310 {
1311 const value = Number(seconds);
1312 if (!Number.isFinite(value) || value < 0) return 'unknown';
1313
1314 const totalSeconds = Math.floor(value);
1315 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1316 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1317 const ss = String(totalSeconds % 60).padStart(2, '0');
1318 return `${hh}:${mm}:${ss}`;
1319 }
1320
1321 function installDurationFallback (player, originalDuration, duration)
1322 {
1323 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1324
1325 player.__filemanagerDurationFallback = true;
1326 player.duration = function durationWithFallback (...args)
1327 {
1328 if (args.length) return originalDuration(...args);
1329 const current = Number(originalDuration());
1330 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1331 };
1332 }
1333
1334 function normaliseVideoDuration (player, durationSeconds)
1335 {
1336 const duration = Number(durationSeconds);
1337 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1338
1339 let originalDuration = null;
1340 let durationWasChanged = false;
1341 try
1342 {
1343 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1344 installDurationFallback(player, originalDuration, duration);
1345 if (player.__filemanagerDurationApplied) return;
1346
1347 const current = originalDuration ? Number(originalDuration()) : NaN;
1348 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1349 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1350 if (withinTolerance)
1351 {
1352 player.__filemanagerDurationApplied = true;
1353 return;
1354 }
1355
1356 if (originalDuration)
1357 {
1358 durationWasChanged = true;
1359 originalDuration(duration);
1360 }
1361 } catch
1362 {
1363 // Ignore players that do not support setting duration.
1364 }
1365
1366 try
1367 {
1368 const updated = originalDuration ? Number(originalDuration()) : NaN;
1369 if (Number.isFinite(updated) && updated >= duration * 0.95)
1370 {
1371 player.__filemanagerDurationApplied = true;
1372 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1373 return;
1374 }
1375
1376 player.__filemanagerDurationApplied = true;
1377 if (typeof player.trigger === 'function') player.trigger('durationchange');
1378 } catch
1379 {
1380 // Ignore duration fallback failures.
1381 }
1382 }
1383
1384 function ensureVideoPlaybackUi (player, durationSeconds)
1385 {
1386 if (!player || typeof player.on !== 'function') return;
1387
1388 const forceVodUi = () =>
1389 {
1390 normaliseVideoDuration(player, durationSeconds);
1391
1392 try
1393 {
1394 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1395 {
1396 player.liveTracker.stopTracking();
1397 }
1398 } catch
1399 {
1400 // Ignore live tracker availability issues.
1401 }
1402
1403 try
1404 {
1405 if (typeof player.removeClass === 'function')
1406 {
1407 player.removeClass('vjs-live');
1408 }
1409 } catch
1410 {
1411 // Ignore class update failures.
1412 }
1413
1414 try
1415 {
1416 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1417 if (display) display.style.display = 'none';
1418 } catch
1419 {
1420 // Ignore missing DOM.
1421 }
1422 };
1423
1424 player.ready(forceVodUi);
1425 player.on('loadedmetadata', forceVodUi);
1426 player.on('durationchange', forceVodUi);
1427 player.on('loadedplaylist', forceVodUi);
1428 }
1429
1430 function configureVideoJsBuffering (videojs, opts = {})
1431 {
1432 if (opts.enabled === false) return;
1433 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1434 videojs.__filemanagerBufferingConfigured = true;
1435
1436 const seconds = Number(opts.seconds);
1437 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1438
1439 try
1440 {
1441 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1442 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1443 } catch
1444 {
1445 // Ignore builds that do not expose VHS buffer configuration.
1446 }
1447 }
1448
1449 function applyDefaultTextTrackPrefs ()
1450 {
1451 try
1452 {
1453 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
1454 } catch
1455 {
1456 // Ignore localStorage failures.
1457 }
1458 }
1459
1460 window.FilemanagerSharedVideoPlayer = {
1461 applyDefaultTextTrackPrefs,
1462 bindImageSubtitleOverlay,
1463 bindTrackPrefs,
1464 configureVideoJsBuffering,
1465 ensureVideoPlaybackUi,
1466 normaliseVideoDuration,
1467 };
1468}());