BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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