BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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