BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

Fix image subtitle prefetching
timfa Tim Falken · pushed by timfa · 5 months ago
30b12890 History
shared-video-player.js 28.3 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 IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT = 15;
11 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX = 30;
12 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS = 0.5;
13
14 function normaliseTrackName (name)
15 {
16 return String(name || '').trim().toLowerCase();
17 }
18
19 function getTrackName (track)
20 {
21 if (!track || typeof track !== 'object') return '';
22 const label = String(track.label || '').trim();
23 if (label) return label;
24 const name = String(track.name || '').trim();
25 if (name) return name;
26 const language = String(track.language || '').trim();
27 if (language) return language;
28 const id = String(track.id || '').trim();
29 if (id) return id;
30 return '';
31 }
32
33 function trackListToArray (trackList)
34 {
35 if (!trackList || typeof trackList.length !== 'number') return [];
36 const out = [];
37 for (let i = 0; i < trackList.length; i++)
38 {
39 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
40 if (track) out.push(track);
41 }
42 return out;
43 }
44
45 function subtitleTracksFromPlayer (player)
46 {
47 if (!player || typeof player.textTracks !== 'function') return [];
48 return trackListToArray(player.textTracks()).filter((track) =>
49 {
50 const kind = String(track.kind || '').toLowerCase();
51 return kind === 'subtitles' || kind === 'captions';
52 });
53 }
54
55 function audioTracksFromPlayer (player)
56 {
57 if (!player || typeof player.audioTracks !== 'function') return [];
58 return trackListToArray(player.audioTracks());
59 }
60
61 function applySavedSubtitleTrack (player, savedName)
62 {
63 if (typeof savedName !== 'string') return;
64 const tracks = subtitleTracksFromPlayer(player);
65 if (!tracks.length) return;
66
67 const wanted = normaliseTrackName(savedName);
68 if (!wanted)
69 {
70 for (const track of tracks) track.mode = 'disabled';
71 return;
72 }
73
74 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
75 if (!match) return;
76
77 for (const track of tracks)
78 {
79 track.mode = track === match ? 'showing' : 'disabled';
80 }
81 }
82
83 function applySavedAudioTrack (player, savedName)
84 {
85 if (typeof savedName !== 'string') return;
86 const tracks = audioTracksFromPlayer(player);
87 if (!tracks.length) return;
88
89 const wanted = normaliseTrackName(savedName);
90 if (!wanted) return;
91
92 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
93 if (!match) return;
94
95 for (const track of tracks)
96 {
97 track.enabled = track === match;
98 }
99 }
100
101 function getSelectedSubtitleTrackName (player)
102 {
103 const tracks = subtitleTracksFromPlayer(player);
104 if (!tracks.length) return null;
105 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
106 return active ? getTrackName(active) : '';
107 }
108
109 function getSelectedAudioTrackName (player)
110 {
111 const tracks = audioTracksFromPlayer(player);
112 if (!tracks.length) return null;
113 const active = tracks.find((track) => !!track.enabled);
114 return active ? getTrackName(active) : '';
115 }
116
117 function bindTrackPrefs (player, prefs, savePrefs)
118 {
119 const save = typeof savePrefs === 'function' ? savePrefs : (() => {});
120 const applySavedTracks = () =>
121 {
122 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
123 applySavedAudioTrack(player, prefs.audioTrackName);
124 };
125
126 const captureSelectedTracks = () =>
127 {
128 const subtitleTrackName = getSelectedSubtitleTrackName(player);
129 const audioTrackName = getSelectedAudioTrackName(player);
130 const patch = {};
131
132 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
133 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
134
135 if (Object.keys(patch).length) save(patch);
136 };
137
138 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
139 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
140 const onTrackListChange = () => captureSelectedTracks();
141
142 if (textTrackList && typeof textTrackList.addEventListener === 'function')
143 {
144 textTrackList.addEventListener('change', onTrackListChange);
145 }
146
147 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
148 {
149 audioTrackList.addEventListener('change', onTrackListChange);
150 }
151
152 return {
153 applySavedTracks,
154 captureSelectedTracks,
155 detach: () =>
156 {
157 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
158 {
159 textTrackList.removeEventListener('change', onTrackListChange);
160 }
161 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
162 {
163 audioTrackList.removeEventListener('change', onTrackListChange);
164 }
165 },
166 };
167 }
168
169 function bindImageSubtitleOverlay (player, videojs, prefs, session, opts = {})
170 {
171 const imageTracks = Array.isArray(session.imageSubtitleTracks)
172 ? session.imageSubtitleTracks.map((track) => ({
173 label: String(track.label || '').trim() || `Subtitle ${Number(track.streamIndex || 0) + 1}`,
174 language: String(track.language || '').trim(),
175 isDefault: !!track.default,
176 streamIndex: Number(track.streamIndex),
177 })).filter((track) => Number.isInteger(track.streamIndex) && track.streamIndex >= 0)
178 : [];
179
180 if (!imageTracks.length) return null;
181
182 const savePrefs = typeof opts.savePrefs === 'function' ? opts.savePrefs : (() => {});
183 const buildFrameRequest = typeof opts.buildFrameRequest === 'function' ? opts.buildFrameRequest : null;
184 const notifyError = typeof opts.onError === 'function' ? opts.onError : (() => {});
185 const requestedLookaheadSeconds = Number(opts.lookaheadSeconds);
186 const lookaheadSeconds = Number.isFinite(requestedLookaheadSeconds)
187 ? Math.max(0, Math.min(IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX, requestedLookaheadSeconds))
188 : IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT;
189 if (!buildFrameRequest) return null;
190
191 const trackByStreamIndex = new Map(imageTracks.map((track) => [track.streamIndex, track]));
192 let selectedStreamIndex = null;
193 let menuOpen = false;
194 let activeBucket = -1;
195 let activeObjectUrl = null;
196 let overlayEl = null;
197 let overlayImgEl = null;
198 let menuEl = null;
199 let buttonEl = null;
200 let trackDisabled = false;
201 let failureNotified = false;
202 let lifecycleToken = 0;
203 let currentFrameToken = 0;
204 let currentFrameAbortController = null;
205 let prefetchWorkerToken = 0;
206 let prefetchAbortController = null;
207 let prefetchPromise = null;
208 let prefetchTargetTimeSeconds = -1;
209 let prefetchedThroughTimeSeconds = -1;
210
211 const createAbortController = () =>
212 {
213 if (typeof AbortController !== 'function') return null;
214 return new AbortController();
215 };
216
217 const abortController = (controller) =>
218 {
219 if (!controller || typeof controller.abort !== 'function') return;
220 try
221 {
222 controller.abort();
223 } catch
224 {
225 // Ignore abort races during teardown.
226 }
227 };
228
229 const isAbortError = (error) =>
230 {
231 return !!(error && typeof error === 'object' && error.name === 'AbortError');
232 };
233
234 const cancelCurrentFrameRequest = () =>
235 {
236 currentFrameToken++;
237 abortController(currentFrameAbortController);
238 currentFrameAbortController = null;
239 };
240
241 const cancelPrefetchRequests = ({ resetProgress = false } = {}) =>
242 {
243 prefetchWorkerToken++;
244 abortController(prefetchAbortController);
245 prefetchAbortController = null;
246 prefetchPromise = null;
247 if (resetProgress)
248 {
249 prefetchTargetTimeSeconds = -1;
250 prefetchedThroughTimeSeconds = -1;
251 }
252 };
253
254 const resetRequestState = () =>
255 {
256 lifecycleToken++;
257 cancelCurrentFrameRequest();
258 cancelPrefetchRequests({ resetProgress: true });
259 };
260
261 const closeObjectUrl = () =>
262 {
263 if (activeObjectUrl)
264 {
265 URL.revokeObjectURL(activeObjectUrl);
266 activeObjectUrl = null;
267 }
268 };
269
270 const hideOverlay = () =>
271 {
272 if (overlayEl) overlayEl.style.display = 'none';
273 if (overlayImgEl) overlayImgEl.removeAttribute('src');
274 closeObjectUrl();
275 };
276
277 const updateButtonState = () =>
278 {
279 if (!buttonEl) return;
280 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
281 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
282 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
283 };
284
285 const updateMenuState = () =>
286 {
287 if (!menuEl) return;
288 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
289 for (const itemEl of items)
290 {
291 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
292 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
293 itemEl.classList.toggle('is-selected', isSelected);
294 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
295 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
296 itemEl.style.fontWeight = isSelected ? '600' : '400';
297 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
298 }
299 };
300
301 const closeMenu = () =>
302 {
303 menuOpen = false;
304 if (menuEl) menuEl.style.display = 'none';
305 };
306
307 const openMenu = () =>
308 {
309 menuOpen = true;
310 if (menuEl)
311 {
312 updateMenuState();
313 menuEl.style.display = 'block';
314 }
315 };
316
317 const toggleMenu = () =>
318 {
319 if (menuOpen) closeMenu();
320 else openMenu();
321 };
322
323 const saveSelection = () =>
324 {
325 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
326 savePrefs({
327 imageSubtitleTrackStreamIndex: selectedStreamIndex,
328 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
329 });
330 };
331
332 const disableTrack = () =>
333 {
334 trackDisabled = true;
335 selectedStreamIndex = null;
336 activeBucket = -1;
337 resetRequestState();
338 hideOverlay();
339 updateButtonState();
340 updateMenuState();
341 saveSelection();
342
343 if (!failureNotified)
344 {
345 failureNotified = true;
346 notifyError();
347 }
348 };
349
350 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
351 {
352 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
353 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
354
355 trackDisabled = false;
356 failureNotified = false;
357 selectedStreamIndex = nextStreamIndex;
358 activeBucket = -1;
359 resetRequestState();
360 hideOverlay();
361 updateButtonState();
362 updateMenuState();
363 if (persist) saveSelection();
364
365 if (selectedStreamIndex !== null)
366 {
367 void refreshFrame(true);
368 }
369 };
370
371 const queueLookaheadPrefetch = (currentTime, { reset = false } = {}) =>
372 {
373 if (selectedStreamIndex === null) return;
374 if (trackDisabled) return;
375 if (lookaheadSeconds <= 0) return;
376
377 const startTime = currentTime + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
378 const endTime = currentTime + lookaheadSeconds;
379 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
380
381 if (reset || prefetchedThroughTimeSeconds < 0 || prefetchedThroughTimeSeconds < currentTime - IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS)
382 {
383 cancelPrefetchRequests({ resetProgress: true });
384 prefetchedThroughTimeSeconds = currentTime;
385 }
386
387 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
388 if (prefetchPromise) return;
389
390 const workerToken = ++prefetchWorkerToken;
391 const workerLifecycleToken = lifecycleToken;
392 const controller = createAbortController();
393 prefetchAbortController = controller;
394
395 prefetchPromise = (async () =>
396 {
397 while (true)
398 {
399 if (selectedStreamIndex === null || trackDisabled) return;
400 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
401
402 const nextTime = prefetchedThroughTimeSeconds < 0
403 ? startTime
404 : prefetchedThroughTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
405 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
406
407 const request = buildFrameRequest({
408 streamIndex: selectedStreamIndex,
409 currentTime: nextTime,
410 session,
411 });
412 if (!request || !request.url) return;
413
414 try
415 {
416 const res = await fetch(request.url, {
417 method: request.method || 'GET',
418 headers: request.headers,
419 credentials: request.credentials,
420 signal: controller ? controller.signal : undefined,
421 });
422
423 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
424 if (res.status === 204)
425 {
426 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
427 if (frameStatus === 'error') return;
428 prefetchedThroughTimeSeconds = nextTime;
429 continue;
430 }
431
432 if (!res.ok) return;
433 await res.arrayBuffer();
434 prefetchedThroughTimeSeconds = nextTime;
435 } catch (error)
436 {
437 if (isAbortError(error)) return;
438 return;
439 }
440 }
441 })().finally(() =>
442 {
443 if (workerToken !== prefetchWorkerToken) return;
444 prefetchAbortController = null;
445 prefetchPromise = null;
446 });
447 };
448
449 const refreshFrame = async (force = false) =>
450 {
451 if (selectedStreamIndex === null) return;
452 if (!overlayEl || !overlayImgEl) return;
453 if (trackDisabled) return;
454
455 const currentTime = Number(player.currentTime());
456 if (!Number.isFinite(currentTime) || currentTime < 0) return;
457
458 const bucket = Math.floor(currentTime * 4);
459 if (!force && bucket === activeBucket) return;
460 activeBucket = bucket;
461
462 const refreshLifecycleToken = lifecycleToken;
463 cancelCurrentFrameRequest();
464 if (force) cancelPrefetchRequests({ resetProgress: true });
465
466 const token = ++currentFrameToken;
467 const controller = createAbortController();
468 currentFrameAbortController = controller;
469 const request = buildFrameRequest({
470 streamIndex: selectedStreamIndex,
471 currentTime,
472 session,
473 });
474
475 if (!request || !request.url)
476 {
477 disableTrack();
478 return;
479 }
480
481 try
482 {
483 const res = await fetch(request.url, {
484 method: request.method || 'GET',
485 headers: request.headers,
486 credentials: request.credentials,
487 signal: controller ? controller.signal : undefined,
488 });
489
490 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
491
492 if (res.status === 204)
493 {
494 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
495 hideOverlay();
496 if (frameStatus === 'error') disableTrack();
497 else queueLookaheadPrefetch(currentTime, { reset: force });
498 return;
499 }
500
501 if (!res.ok)
502 {
503 disableTrack();
504 return;
505 }
506
507 const blob = await res.blob();
508 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
509
510 if (!blob || blob.size === 0)
511 {
512 disableTrack();
513 return;
514 }
515
516 closeObjectUrl();
517 activeObjectUrl = URL.createObjectURL(blob);
518 overlayImgEl.src = activeObjectUrl;
519
520 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
521 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
522 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
523 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
524
525 if (frameWidth > 0 && frameHeight > 0 && canvasWidth > 0 && canvasHeight > 0)
526 {
527 const widthPercent = (frameWidth / canvasWidth) * 100;
528 const heightPercent = (frameHeight / canvasHeight) * 100;
529 overlayImgEl.style.width = `${widthPercent}%`;
530 overlayImgEl.style.height = `${heightPercent}%`;
531 overlayImgEl.style.maxWidth = 'none';
532 overlayImgEl.style.maxHeight = 'none';
533 } else
534 {
535 overlayImgEl.style.width = 'auto';
536 overlayImgEl.style.height = 'auto';
537 overlayImgEl.style.maxWidth = '100%';
538 overlayImgEl.style.maxHeight = '100%';
539 }
540
541 overlayEl.style.display = 'block';
542 overlayImgEl.style.display = 'block';
543
544 queueLookaheadPrefetch(currentTime, { reset: force });
545 } catch (error)
546 {
547 if (isAbortError(error)) return;
548 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
549 }
550 };
551
552 const dispose = () =>
553 {
554 resetRequestState();
555 closeMenu();
556 hideOverlay();
557 if (overlayEl) overlayEl.remove();
558 if (menuEl) menuEl.remove();
559 player.imageSubtitleOverlayController = null;
560 buttonEl = null;
561 };
562
563 overlayEl = document.createElement('div');
564 overlayEl.className = 'video-subtitle-overlay';
565 overlayEl.style.position = 'absolute';
566 overlayEl.style.left = '0';
567 overlayEl.style.right = '0';
568 overlayEl.style.bottom = '3rem';
569 overlayEl.style.display = 'none';
570 overlayEl.style.zIndex = '3';
571 overlayEl.style.pointerEvents = 'none';
572 overlayEl.style.textAlign = 'center';
573 overlayEl.style.padding = '0 0.75rem';
574 overlayEl.style.maxHeight = '70%';
575 overlayEl.style.overflow = 'hidden';
576
577 overlayImgEl = document.createElement('img');
578 overlayImgEl.alt = 'Image subtitles';
579 overlayImgEl.style.display = 'none';
580 overlayImgEl.style.margin = '0 auto';
581 overlayImgEl.style.objectFit = 'contain';
582 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
583 overlayImgEl.style.maxWidth = '100%';
584 overlayImgEl.style.height = 'auto';
585 overlayEl.appendChild(overlayImgEl);
586
587 menuEl = document.createElement('div');
588 menuEl.className = 'video-subtitle-overlay-menu';
589 menuEl.style.position = 'absolute';
590 menuEl.style.right = '0.75rem';
591 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
592 menuEl.style.minWidth = '14rem';
593 menuEl.style.maxWidth = '20rem';
594 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
595 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
596 menuEl.style.borderRadius = '0.5rem';
597 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
598 menuEl.style.padding = '0.35rem';
599 menuEl.style.display = 'none';
600 menuEl.style.zIndex = '4';
601
602 const buildMenuItem = (label, streamIndex, isSelected) =>
603 {
604 const itemEl = document.createElement('button');
605 itemEl.type = 'button';
606 itemEl.className = 'video-subtitle-overlay-menu-item';
607 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
608 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
609 itemEl.style.display = 'block';
610 itemEl.style.width = '100%';
611 itemEl.style.margin = '0';
612 itemEl.style.padding = '0.5rem 0.75rem';
613 itemEl.style.border = '0';
614 itemEl.style.borderRadius = '0.35rem';
615 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
616 itemEl.style.color = '#fff';
617 itemEl.style.textAlign = 'left';
618 itemEl.style.cursor = 'pointer';
619 itemEl.textContent = label;
620 itemEl.addEventListener('click', () =>
621 {
622 setSelectedStreamIndex(streamIndex);
623 closeMenu();
624 });
625 return itemEl;
626 };
627
628 menuEl.appendChild(buildMenuItem('Off', null, false));
629 for (const track of imageTracks)
630 {
631 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
632 }
633
634 const registerButton = () =>
635 {
636 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
637 if (videojs.getComponent('ImageSubtitleButton')) return;
638
639 const Button = videojs.getComponent('Button');
640 class ImageSubtitleButton extends Button
641 {
642 buildCSSClass ()
643 {
644 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
645 }
646
647 createEl ()
648 {
649 const el = super.createEl();
650 el.type = 'button';
651 el.setAttribute('title', 'Image subtitles');
652 el.setAttribute('aria-label', 'Image subtitles');
653 el.innerHTML = '<span aria-hidden="true">IM</span>';
654 return el;
655 }
656
657 handleClick ()
658 {
659 const controller = this.player().imageSubtitleOverlayController;
660 if (controller) controller.toggleMenu();
661 }
662 }
663
664 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
665 };
666
667 const attachUi = () =>
668 {
669 if (!player.el()) return;
670 registerButton();
671 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
672 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
673 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
674 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
675 {
676 const button = controlBar.addChild('ImageSubtitleButton', {});
677 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
678 updateButtonState();
679 }
680 };
681
682 const applySavedTracks = () =>
683 {
684 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
685 if (savedName)
686 {
687 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
688 if (savedByName)
689 {
690 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
691 return;
692 }
693 }
694
695 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
696 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
697 {
698 setSelectedStreamIndex(savedIndex, { persist: false });
699 return;
700 }
701
702 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
703 if (defaultTrack)
704 {
705 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
706 return;
707 }
708
709 setSelectedStreamIndex(null, { persist: false });
710 };
711
712 player.imageSubtitleOverlayController = {
713 toggleMenu,
714 closeMenu,
715 applySavedTracks,
716 captureSelectedTracks: saveSelection,
717 detach: dispose,
718 };
719
720 player.on('timeupdate', () => { void refreshFrame(); });
721 player.on('seeking', () => { void refreshFrame(true); });
722 player.on('play', () => { void refreshFrame(true); });
723 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
724 player.on('dispose', dispose);
725 player.ready(() =>
726 {
727 attachUi();
728 updateMenuState();
729 updateButtonState();
730 applySavedTracks();
731 if (menuOpen) openMenu();
732 });
733
734 return player.imageSubtitleOverlayController;
735 }
736
737 function formatDurationForDebug (seconds)
738 {
739 const value = Number(seconds);
740 if (!Number.isFinite(value) || value < 0) return 'unknown';
741
742 const totalSeconds = Math.floor(value);
743 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
744 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
745 const ss = String(totalSeconds % 60).padStart(2, '0');
746 return `${hh}:${mm}:${ss}`;
747 }
748
749 function installDurationFallback (player, originalDuration, duration)
750 {
751 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
752
753 player.__filemanagerDurationFallback = true;
754 player.duration = function durationWithFallback (...args)
755 {
756 if (args.length) return originalDuration(...args);
757 const current = Number(originalDuration());
758 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
759 };
760 }
761
762 function normaliseVideoDuration (player, durationSeconds)
763 {
764 const duration = Number(durationSeconds);
765 if (!player || !Number.isFinite(duration) || duration <= 0) return;
766
767 let originalDuration = null;
768 let durationWasChanged = false;
769 try
770 {
771 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
772 installDurationFallback(player, originalDuration, duration);
773 if (player.__filemanagerDurationApplied) return;
774
775 const current = originalDuration ? Number(originalDuration()) : NaN;
776 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
777 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
778 if (withinTolerance)
779 {
780 player.__filemanagerDurationApplied = true;
781 return;
782 }
783
784 if (originalDuration)
785 {
786 durationWasChanged = true;
787 originalDuration(duration);
788 }
789 } catch
790 {
791 // Ignore players that do not support setting duration.
792 }
793
794 try
795 {
796 const updated = originalDuration ? Number(originalDuration()) : NaN;
797 if (Number.isFinite(updated) && updated >= duration * 0.95)
798 {
799 player.__filemanagerDurationApplied = true;
800 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
801 return;
802 }
803
804 player.__filemanagerDurationApplied = true;
805 if (typeof player.trigger === 'function') player.trigger('durationchange');
806 } catch
807 {
808 // Ignore duration fallback failures.
809 }
810 }
811
812 function ensureVideoPlaybackUi (player, durationSeconds)
813 {
814 if (!player || typeof player.on !== 'function') return;
815
816 const forceVodUi = () =>
817 {
818 normaliseVideoDuration(player, durationSeconds);
819
820 try
821 {
822 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
823 {
824 player.liveTracker.stopTracking();
825 }
826 } catch
827 {
828 // Ignore live tracker availability issues.
829 }
830
831 try
832 {
833 if (typeof player.removeClass === 'function')
834 {
835 player.removeClass('vjs-live');
836 }
837 } catch
838 {
839 // Ignore class update failures.
840 }
841
842 try
843 {
844 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
845 if (display) display.style.display = 'none';
846 } catch
847 {
848 // Ignore missing DOM.
849 }
850 };
851
852 player.ready(forceVodUi);
853 player.on('loadedmetadata', forceVodUi);
854 player.on('durationchange', forceVodUi);
855 player.on('loadedplaylist', forceVodUi);
856 }
857
858 function configureVideoJsBuffering (videojs, opts = {})
859 {
860 if (opts.enabled === false) return;
861 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
862 videojs.__filemanagerBufferingConfigured = true;
863
864 const seconds = Number(opts.seconds);
865 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
866
867 try
868 {
869 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
870 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
871 } catch
872 {
873 // Ignore builds that do not expose VHS buffer configuration.
874 }
875 }
876
877 function applyDefaultTextTrackPrefs ()
878 {
879 try
880 {
881 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
882 } catch
883 {
884 // Ignore localStorage failures.
885 }
886 }
887
888 window.FilemanagerSharedVideoPlayer = {
889 applyDefaultTextTrackPrefs,
890 bindImageSubtitleOverlay,
891 bindTrackPrefs,
892 configureVideoJsBuffering,
893 ensureVideoPlaybackUi,
894 normaliseVideoDuration,
895 };
896}());