BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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