BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

Add subtitle runtime logging
timfa Tim Falken · pushed by timfa · 5 months ago
b5c1f94d History
shared-video-player.js 35.0 KiB Download Raw
1'use strict';
2
3(function ()
4{
5 const VIDEO_TEXT_TRACK_SETTINGS_KEY = 'vjs-text-track-settings';
6 const VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW = JSON.stringify({
7 backgroundOpacity: '0',
8 edgeStyle: 'uniform',
9 });
10 const SUBTITLE_LOG_BATCH_MAX_ITEMS = 12;
11 const SUBTITLE_LOG_FLUSH_DELAY_MS = 500;
12 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT = 15;
13 const IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX = 30;
14 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS = 0.5;
15
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 subtitleLogSequence = 0;
286 let subtitleLogQueue = [];
287 let subtitleLogFlushTimer = null;
288
289 const flushSubtitleLogs = () =>
290 {
291 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
292 if (subtitleLogFlushTimer)
293 {
294 window.clearTimeout(subtitleLogFlushTimer);
295 subtitleLogFlushTimer = null;
296 }
297
298 const batch = subtitleLogQueue;
299 subtitleLogQueue = [];
300 Promise.resolve(sendSubtitleLogBatch(batch)).catch(() =>
301 {
302 // Keep subtitle diagnostics best-effort only.
303 });
304 };
305
306 const scheduleSubtitleLogFlush = () =>
307 {
308 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
309 if (subtitleLogQueue.length >= SUBTITLE_LOG_BATCH_MAX_ITEMS)
310 {
311 flushSubtitleLogs();
312 return;
313 }
314 if (subtitleLogFlushTimer) return;
315 subtitleLogFlushTimer = window.setTimeout(() =>
316 {
317 subtitleLogFlushTimer = null;
318 flushSubtitleLogs();
319 }, SUBTITLE_LOG_FLUSH_DELAY_MS);
320 };
321
322 const logSubtitleEvent = (eventType, details = {}) =>
323 {
324 const entry = {
325 seq: ++subtitleLogSequence,
326 loggedAtMs: Date.now(),
327 eventType,
328 sessionId: String(session.sessionId || '').trim() || null,
329 streamIndex: Number.isInteger(selectedStreamIndex) ? selectedStreamIndex : null,
330 playerTimeSeconds: roundLogNumber(player.currentTime()),
331 ...details,
332 };
333 try
334 {
335 console.log('[subtitle-log]', entry);
336 } catch
337 {
338 // Ignore console availability issues.
339 }
340
341 if (!sendSubtitleLogBatch) return;
342 subtitleLogQueue.push(entry);
343 scheduleSubtitleLogFlush();
344 };
345
346 const createAbortController = () =>
347 {
348 if (typeof AbortController !== 'function') return null;
349 return new AbortController();
350 };
351
352 const abortController = (controller) =>
353 {
354 if (!controller || typeof controller.abort !== 'function') return;
355 try
356 {
357 controller.abort();
358 } catch
359 {
360 // Ignore abort races during teardown.
361 }
362 };
363
364 const isAbortError = (error) =>
365 {
366 return !!(error && typeof error === 'object' && error.name === 'AbortError');
367 };
368
369 const cancelCurrentFrameRequest = () =>
370 {
371 currentFrameToken++;
372 abortController(currentFrameAbortController);
373 currentFrameAbortController = null;
374 };
375
376 const cancelPrefetchRequests = ({ resetProgress = false } = {}) =>
377 {
378 prefetchWorkerToken++;
379 abortController(prefetchAbortController);
380 prefetchAbortController = null;
381 prefetchPromise = null;
382 if (resetProgress)
383 {
384 prefetchTargetTimeSeconds = -1;
385 prefetchedThroughTimeSeconds = -1;
386 }
387 };
388
389 const resetRequestState = () =>
390 {
391 lifecycleToken++;
392 cancelCurrentFrameRequest();
393 cancelPrefetchRequests({ resetProgress: true });
394 };
395
396 const closeObjectUrl = () =>
397 {
398 if (activeObjectUrl)
399 {
400 URL.revokeObjectURL(activeObjectUrl);
401 activeObjectUrl = null;
402 }
403 };
404
405 const hideOverlay = () =>
406 {
407 if (overlayEl) overlayEl.style.display = 'none';
408 if (overlayImgEl) overlayImgEl.removeAttribute('src');
409 closeObjectUrl();
410 };
411
412 const updateButtonState = () =>
413 {
414 if (!buttonEl) return;
415 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
416 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
417 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
418 };
419
420 const updateMenuState = () =>
421 {
422 if (!menuEl) return;
423 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
424 for (const itemEl of items)
425 {
426 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
427 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
428 itemEl.classList.toggle('is-selected', isSelected);
429 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
430 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
431 itemEl.style.fontWeight = isSelected ? '600' : '400';
432 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
433 }
434 };
435
436 const closeMenu = () =>
437 {
438 menuOpen = false;
439 if (menuEl) menuEl.style.display = 'none';
440 };
441
442 const openMenu = () =>
443 {
444 menuOpen = true;
445 if (menuEl)
446 {
447 updateMenuState();
448 menuEl.style.display = 'block';
449 }
450 };
451
452 const toggleMenu = () =>
453 {
454 if (menuOpen) closeMenu();
455 else openMenu();
456 };
457
458 const saveSelection = () =>
459 {
460 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
461 savePrefs({
462 imageSubtitleTrackStreamIndex: selectedStreamIndex,
463 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
464 });
465 };
466
467 const disableTrack = () =>
468 {
469 trackDisabled = true;
470 selectedStreamIndex = null;
471 activeBucket = -1;
472 resetRequestState();
473 hideOverlay();
474 updateButtonState();
475 updateMenuState();
476 saveSelection();
477
478 if (!failureNotified)
479 {
480 failureNotified = true;
481 notifyError();
482 }
483 };
484
485 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
486 {
487 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
488 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
489
490 trackDisabled = false;
491 failureNotified = false;
492 selectedStreamIndex = nextStreamIndex;
493 activeBucket = -1;
494 resetRequestState();
495 hideOverlay();
496 updateButtonState();
497 updateMenuState();
498 if (persist) saveSelection();
499
500 if (selectedStreamIndex !== null)
501 {
502 void refreshFrame(true);
503 }
504 };
505
506 const queueLookaheadPrefetch = (currentTime, { reset = false } = {}) =>
507 {
508 if (selectedStreamIndex === null) return;
509 if (trackDisabled) return;
510 if (lookaheadSeconds <= 0) return;
511
512 const startTime = currentTime + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
513 const endTime = currentTime + lookaheadSeconds;
514 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
515
516 if (reset || prefetchedThroughTimeSeconds < 0 || prefetchedThroughTimeSeconds < currentTime - IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS)
517 {
518 cancelPrefetchRequests({ resetProgress: true });
519 prefetchedThroughTimeSeconds = currentTime;
520 }
521
522 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
523 if (prefetchPromise) return;
524
525 const workerToken = ++prefetchWorkerToken;
526 const workerLifecycleToken = lifecycleToken;
527 const controller = createAbortController();
528 prefetchAbortController = controller;
529
530 prefetchPromise = (async () =>
531 {
532 while (true)
533 {
534 if (selectedStreamIndex === null || trackDisabled) return;
535 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
536
537 const nextTime = prefetchedThroughTimeSeconds < 0
538 ? startTime
539 : prefetchedThroughTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
540 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
541
542 const request = buildFrameRequest({
543 streamIndex: selectedStreamIndex,
544 currentTime: nextTime,
545 session,
546 });
547 if (!request || !request.url) return;
548
549 try
550 {
551 const res = await fetch(request.url, {
552 method: request.method || 'GET',
553 headers: request.headers,
554 credentials: request.credentials,
555 signal: controller ? controller.signal : undefined,
556 });
557
558 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
559 if (res.status === 204)
560 {
561 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
562 if (frameStatus === 'error') return;
563 prefetchedThroughTimeSeconds = nextTime;
564 continue;
565 }
566
567 if (!res.ok) return;
568 await res.arrayBuffer();
569 prefetchedThroughTimeSeconds = nextTime;
570 } catch (error)
571 {
572 if (isAbortError(error)) return;
573 return;
574 }
575 }
576 })().finally(() =>
577 {
578 if (workerToken !== prefetchWorkerToken) return;
579 prefetchAbortController = null;
580 prefetchPromise = null;
581 });
582 };
583
584 const refreshFrame = async (force = false) =>
585 {
586 if (selectedStreamIndex === null) return;
587 if (!overlayEl || !overlayImgEl) return;
588 if (trackDisabled) return;
589
590 const currentTime = Number(player.currentTime());
591 if (!Number.isFinite(currentTime) || currentTime < 0) return;
592
593 const bucket = Math.floor(currentTime * 4);
594 if (!force && bucket === activeBucket) return;
595 activeBucket = bucket;
596
597 const refreshLifecycleToken = lifecycleToken;
598 cancelCurrentFrameRequest();
599 if (force) cancelPrefetchRequests({ resetProgress: true });
600
601 const token = ++currentFrameToken;
602 const requestId = `current-${token}`;
603 const requestStartedAtMs = Date.now();
604 const controller = createAbortController();
605 currentFrameAbortController = controller;
606 const request = buildFrameRequest({
607 streamIndex: selectedStreamIndex,
608 currentTime,
609 session,
610 });
611
612 if (!request || !request.url)
613 {
614 disableTrack();
615 return;
616 }
617
618 logSubtitleEvent('subtitle_png_requested', {
619 requestId,
620 requestKind: 'current',
621 requestUrl: String(request.url || ''),
622 requestedAtMs: requestStartedAtMs,
623 requestedVideoTimeSeconds: roundLogNumber(currentTime),
624 });
625
626 try
627 {
628 const res = await fetch(request.url, {
629 method: request.method || 'GET',
630 headers: request.headers,
631 credentials: request.credentials,
632 signal: controller ? controller.signal : undefined,
633 });
634
635 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
636
637 const responseMeta = {
638 requestId,
639 requestKind: 'current',
640 status: res.status,
641 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
642 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
643 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
644 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
645 responseHeadersReceivedAtMs: Date.now(),
646 };
647 logSubtitleEvent('subtitle_png_sent', {
648 ...responseMeta,
649 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
650 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
651 });
652
653 if (res.status === 204)
654 {
655 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
656 logSubtitleEvent('subtitle_png_not_available', {
657 ...responseMeta,
658 frameStatus,
659 });
660 hideOverlay();
661 if (frameStatus === 'error') disableTrack();
662 else queueLookaheadPrefetch(currentTime, { reset: force });
663 return;
664 }
665
666 if (!res.ok)
667 {
668 disableTrack();
669 return;
670 }
671
672 const blob = await res.blob();
673 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
674
675 const receivedAtMs = Date.now();
676 logSubtitleEvent('subtitle_png_received', {
677 ...responseMeta,
678 receivedAtMs,
679 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
680 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
681 blobBytes: Number(blob && blob.size || 0),
682 });
683
684 if (!blob || blob.size === 0)
685 {
686 disableTrack();
687 return;
688 }
689
690 closeObjectUrl();
691 activeObjectUrl = URL.createObjectURL(blob);
692 overlayImgEl.src = activeObjectUrl;
693
694 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
695 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
696 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
697 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
698
699 if (frameWidth > 0 && frameHeight > 0 && canvasWidth > 0 && canvasHeight > 0)
700 {
701 const widthPercent = (frameWidth / canvasWidth) * 100;
702 const heightPercent = (frameHeight / canvasHeight) * 100;
703 overlayImgEl.style.width = `${widthPercent}%`;
704 overlayImgEl.style.height = `${heightPercent}%`;
705 overlayImgEl.style.maxWidth = 'none';
706 overlayImgEl.style.maxHeight = 'none';
707 } else
708 {
709 overlayImgEl.style.width = 'auto';
710 overlayImgEl.style.height = 'auto';
711 overlayImgEl.style.maxWidth = '100%';
712 overlayImgEl.style.maxHeight = '100%';
713 }
714
715 overlayEl.style.display = 'block';
716 overlayImgEl.style.display = 'block';
717
718 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
719 {
720 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
721 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
722 logSubtitleEvent('subtitle_png_shown', {
723 ...responseMeta,
724 receivedAtMs,
725 shownAtMs,
726 shownAtVideoTimeSeconds,
727 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
728 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
729 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
730 });
731 });
732
733 queueLookaheadPrefetch(currentTime, { reset: force });
734 } catch (error)
735 {
736 if (isAbortError(error)) return;
737 logSubtitleEvent('subtitle_png_request_failed', {
738 requestId,
739 requestKind: 'current',
740 requestedAtMs: requestStartedAtMs,
741 errorName: error && error.name ? String(error.name) : null,
742 errorMessage: error && error.message ? String(error.message) : String(error || ''),
743 });
744 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
745 }
746 };
747
748 const dispose = () =>
749 {
750 resetRequestState();
751 flushSubtitleLogs();
752 closeMenu();
753 hideOverlay();
754 if (overlayEl) overlayEl.remove();
755 if (menuEl) menuEl.remove();
756 player.imageSubtitleOverlayController = null;
757 buttonEl = null;
758 };
759
760 overlayEl = document.createElement('div');
761 overlayEl.className = 'video-subtitle-overlay';
762 overlayEl.style.position = 'absolute';
763 overlayEl.style.left = '0';
764 overlayEl.style.right = '0';
765 overlayEl.style.bottom = '3rem';
766 overlayEl.style.display = 'none';
767 overlayEl.style.zIndex = '3';
768 overlayEl.style.pointerEvents = 'none';
769 overlayEl.style.textAlign = 'center';
770 overlayEl.style.padding = '0 0.75rem';
771 overlayEl.style.maxHeight = '70%';
772 overlayEl.style.overflow = 'hidden';
773
774 overlayImgEl = document.createElement('img');
775 overlayImgEl.alt = 'Image subtitles';
776 overlayImgEl.style.display = 'none';
777 overlayImgEl.style.margin = '0 auto';
778 overlayImgEl.style.objectFit = 'contain';
779 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
780 overlayImgEl.style.maxWidth = '100%';
781 overlayImgEl.style.height = 'auto';
782 overlayEl.appendChild(overlayImgEl);
783
784 menuEl = document.createElement('div');
785 menuEl.className = 'video-subtitle-overlay-menu';
786 menuEl.style.position = 'absolute';
787 menuEl.style.right = '0.75rem';
788 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
789 menuEl.style.minWidth = '14rem';
790 menuEl.style.maxWidth = '20rem';
791 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
792 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
793 menuEl.style.borderRadius = '0.5rem';
794 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
795 menuEl.style.padding = '0.35rem';
796 menuEl.style.display = 'none';
797 menuEl.style.zIndex = '4';
798
799 const buildMenuItem = (label, streamIndex, isSelected) =>
800 {
801 const itemEl = document.createElement('button');
802 itemEl.type = 'button';
803 itemEl.className = 'video-subtitle-overlay-menu-item';
804 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
805 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
806 itemEl.style.display = 'block';
807 itemEl.style.width = '100%';
808 itemEl.style.margin = '0';
809 itemEl.style.padding = '0.5rem 0.75rem';
810 itemEl.style.border = '0';
811 itemEl.style.borderRadius = '0.35rem';
812 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
813 itemEl.style.color = '#fff';
814 itemEl.style.textAlign = 'left';
815 itemEl.style.cursor = 'pointer';
816 itemEl.textContent = label;
817 itemEl.addEventListener('click', () =>
818 {
819 setSelectedStreamIndex(streamIndex);
820 closeMenu();
821 });
822 return itemEl;
823 };
824
825 menuEl.appendChild(buildMenuItem('Off', null, false));
826 for (const track of imageTracks)
827 {
828 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
829 }
830
831 const registerButton = () =>
832 {
833 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
834 if (videojs.getComponent('ImageSubtitleButton')) return;
835
836 const Button = videojs.getComponent('Button');
837 class ImageSubtitleButton extends Button
838 {
839 buildCSSClass ()
840 {
841 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
842 }
843
844 createEl ()
845 {
846 const el = super.createEl();
847 el.type = 'button';
848 el.setAttribute('title', 'Image subtitles');
849 el.setAttribute('aria-label', 'Image subtitles');
850 el.innerHTML = '<span aria-hidden="true">IM</span>';
851 return el;
852 }
853
854 handleClick ()
855 {
856 const controller = this.player().imageSubtitleOverlayController;
857 if (controller) controller.toggleMenu();
858 }
859 }
860
861 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
862 };
863
864 const attachUi = () =>
865 {
866 if (!player.el()) return;
867 registerButton();
868 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
869 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
870 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
871 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
872 {
873 const button = controlBar.addChild('ImageSubtitleButton', {});
874 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
875 updateButtonState();
876 }
877 };
878
879 const applySavedTracks = () =>
880 {
881 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
882 if (savedName)
883 {
884 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
885 if (savedByName)
886 {
887 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
888 return;
889 }
890 }
891
892 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
893 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
894 {
895 setSelectedStreamIndex(savedIndex, { persist: false });
896 return;
897 }
898
899 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
900 if (defaultTrack)
901 {
902 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
903 return;
904 }
905
906 setSelectedStreamIndex(null, { persist: false });
907 };
908
909 player.imageSubtitleOverlayController = {
910 toggleMenu,
911 closeMenu,
912 applySavedTracks,
913 captureSelectedTracks: saveSelection,
914 detach: dispose,
915 };
916
917 player.on('timeupdate', () => { void refreshFrame(); });
918 player.on('seeking', () => { void refreshFrame(true); });
919 player.on('play', () => { void refreshFrame(true); });
920 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
921 player.on('dispose', dispose);
922 player.ready(() =>
923 {
924 attachUi();
925 updateMenuState();
926 updateButtonState();
927 applySavedTracks();
928 if (menuOpen) openMenu();
929 });
930
931 return player.imageSubtitleOverlayController;
932 }
933
934 function formatDurationForDebug (seconds)
935 {
936 const value = Number(seconds);
937 if (!Number.isFinite(value) || value < 0) return 'unknown';
938
939 const totalSeconds = Math.floor(value);
940 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
941 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
942 const ss = String(totalSeconds % 60).padStart(2, '0');
943 return `${hh}:${mm}:${ss}`;
944 }
945
946 function installDurationFallback (player, originalDuration, duration)
947 {
948 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
949
950 player.__filemanagerDurationFallback = true;
951 player.duration = function durationWithFallback (...args)
952 {
953 if (args.length) return originalDuration(...args);
954 const current = Number(originalDuration());
955 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
956 };
957 }
958
959 function normaliseVideoDuration (player, durationSeconds)
960 {
961 const duration = Number(durationSeconds);
962 if (!player || !Number.isFinite(duration) || duration <= 0) return;
963
964 let originalDuration = null;
965 let durationWasChanged = false;
966 try
967 {
968 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
969 installDurationFallback(player, originalDuration, duration);
970 if (player.__filemanagerDurationApplied) return;
971
972 const current = originalDuration ? Number(originalDuration()) : NaN;
973 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
974 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
975 if (withinTolerance)
976 {
977 player.__filemanagerDurationApplied = true;
978 return;
979 }
980
981 if (originalDuration)
982 {
983 durationWasChanged = true;
984 originalDuration(duration);
985 }
986 } catch
987 {
988 // Ignore players that do not support setting duration.
989 }
990
991 try
992 {
993 const updated = originalDuration ? Number(originalDuration()) : NaN;
994 if (Number.isFinite(updated) && updated >= duration * 0.95)
995 {
996 player.__filemanagerDurationApplied = true;
997 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
998 return;
999 }
1000
1001 player.__filemanagerDurationApplied = true;
1002 if (typeof player.trigger === 'function') player.trigger('durationchange');
1003 } catch
1004 {
1005 // Ignore duration fallback failures.
1006 }
1007 }
1008
1009 function ensureVideoPlaybackUi (player, durationSeconds)
1010 {
1011 if (!player || typeof player.on !== 'function') return;
1012
1013 const forceVodUi = () =>
1014 {
1015 normaliseVideoDuration(player, durationSeconds);
1016
1017 try
1018 {
1019 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1020 {
1021 player.liveTracker.stopTracking();
1022 }
1023 } catch
1024 {
1025 // Ignore live tracker availability issues.
1026 }
1027
1028 try
1029 {
1030 if (typeof player.removeClass === 'function')
1031 {
1032 player.removeClass('vjs-live');
1033 }
1034 } catch
1035 {
1036 // Ignore class update failures.
1037 }
1038
1039 try
1040 {
1041 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1042 if (display) display.style.display = 'none';
1043 } catch
1044 {
1045 // Ignore missing DOM.
1046 }
1047 };
1048
1049 player.ready(forceVodUi);
1050 player.on('loadedmetadata', forceVodUi);
1051 player.on('durationchange', forceVodUi);
1052 player.on('loadedplaylist', forceVodUi);
1053 }
1054
1055 function configureVideoJsBuffering (videojs, opts = {})
1056 {
1057 if (opts.enabled === false) return;
1058 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1059 videojs.__filemanagerBufferingConfigured = true;
1060
1061 const seconds = Number(opts.seconds);
1062 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1063
1064 try
1065 {
1066 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1067 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1068 } catch
1069 {
1070 // Ignore builds that do not expose VHS buffer configuration.
1071 }
1072 }
1073
1074 function applyDefaultTextTrackPrefs ()
1075 {
1076 try
1077 {
1078 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
1079 } catch
1080 {
1081 // Ignore localStorage failures.
1082 }
1083 }
1084
1085 window.FilemanagerSharedVideoPlayer = {
1086 applyDefaultTextTrackPrefs,
1087 bindImageSubtitleOverlay,
1088 bindTrackPrefs,
1089 configureVideoJsBuffering,
1090 ensureVideoPlaybackUi,
1091 normaliseVideoDuration,
1092 };
1093}());