BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

c88ad7de History
shared-video-player.js 74.7 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_INITIAL_PREFETCH_SECONDS_DEFAULT = 60;
15 const IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_MAX = 120;
16 const IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS = 0.5;
17 const IMAGE_SUBTITLE_CURRENT_REQUEST_TIMEOUT_MS_DEFAULT = 4000;
18 const IMAGE_SUBTITLE_PREFETCH_REQUEST_TIMEOUT_MS_DEFAULT = 4000;
19 const IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS_DEFAULT = 0;
20 const VIDEO_STREAM_CACHE_SW_URL = '/stream-cache-sw.js';
21 const VIDEO_STREAM_CACHE_NAME = 'filemanager-stream-cache-v1';
22 const VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT = 750;
23 const VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS = 4;
24
25 function formatClockTime (value)
26 {
27 const seconds = Number(value);
28 if (!Number.isFinite(seconds) || seconds < 0) return '00:00';
29
30 const total = Math.floor(seconds);
31 const hours = Math.floor(total / 3600);
32 const minutes = Math.floor((total % 3600) / 60);
33 const remainingSeconds = total % 60;
34
35 if (hours > 0)
36 {
37 return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
38 }
39 return `${String(minutes).padStart(2, '0')}:${String(remainingSeconds).padStart(2, '0')}`;
40 }
41
42 function roundLogNumber (value, digits = 3)
43 {
44 const numeric = Number(value);
45 if (!Number.isFinite(numeric)) return null;
46 return Number(numeric.toFixed(digits));
47 }
48
49 function parseHeaderInt (res, name)
50 {
51 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
52 const value = Number.parseInt(String(res.headers.get(name) || ''), 10);
53 return Number.isFinite(value) ? value : null;
54 }
55
56 function parseHeaderFloat (res, name)
57 {
58 if (!res || !res.headers || typeof res.headers.get !== 'function') return null;
59 const value = Number.parseFloat(String(res.headers.get(name) || ''));
60 return Number.isFinite(value) ? value : null;
61 }
62
63 function diffMilliseconds (later, earlier)
64 {
65 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
66 return Math.round(later - earlier);
67 }
68
69 function diffSeconds (later, earlier)
70 {
71 if (!Number.isFinite(later) || !Number.isFinite(earlier)) return null;
72 return roundLogNumber(later - earlier, 3);
73 }
74
75 function waitForImagePresentation (windowRef, imageEl)
76 {
77 return new Promise((resolve) =>
78 {
79 let settled = false;
80 let fallbackTimer = null;
81 const raf = typeof windowRef.requestAnimationFrame === 'function'
82 ? windowRef.requestAnimationFrame.bind(windowRef)
83 : (fn) => windowRef.setTimeout(fn, 0);
84
85 const cleanup = () =>
86 {
87 imageEl.removeEventListener('load', onLoad);
88 imageEl.removeEventListener('error', onError);
89 if (fallbackTimer !== null) windowRef.clearTimeout(fallbackTimer);
90 };
91
92 const finish = () =>
93 {
94 if (settled) return;
95 settled = true;
96 cleanup();
97 raf(() => resolve(Date.now()));
98 };
99
100 const onLoad = () => finish();
101 const onError = () => finish();
102
103 imageEl.addEventListener('load', onLoad);
104 imageEl.addEventListener('error', onError);
105 fallbackTimer = windowRef.setTimeout(finish, 250);
106
107 if (imageEl.complete && imageEl.currentSrc)
108 {
109 finish();
110 }
111 });
112 }
113
114 function normaliseTrackName (name)
115 {
116 return String(name || '').trim().toLowerCase();
117 }
118
119 function getTrackName (track)
120 {
121 if (!track || typeof track !== 'object') return '';
122 const label = String(track.label || '').trim();
123 if (label) return label;
124 const name = String(track.name || '').trim();
125 if (name) return name;
126 const language = String(track.language || '').trim();
127 if (language) return language;
128 const id = String(track.id || '').trim();
129 if (id) return id;
130 return '';
131 }
132
133 function trackListToArray (trackList)
134 {
135 if (!trackList || typeof trackList.length !== 'number') return [];
136 const out = [];
137 for (let i = 0; i < trackList.length; i++)
138 {
139 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
140 if (track) out.push(track);
141 }
142 return out;
143 }
144
145 function subtitleTracksFromPlayer (player)
146 {
147 if (!player || typeof player.textTracks !== 'function') return [];
148 return trackListToArray(player.textTracks()).filter((track) =>
149 {
150 const kind = String(track.kind || '').toLowerCase();
151 return kind === 'subtitles' || kind === 'captions';
152 });
153 }
154
155 function audioTracksFromPlayer (player)
156 {
157 if (!player || typeof player.audioTracks !== 'function') return [];
158 return trackListToArray(player.audioTracks());
159 }
160
161 function applySavedSubtitleTrack (player, savedName)
162 {
163 if (typeof savedName !== 'string') return;
164 const tracks = subtitleTracksFromPlayer(player);
165 if (!tracks.length) return;
166
167 const wanted = normaliseTrackName(savedName);
168 if (!wanted)
169 {
170 for (const track of tracks) track.mode = 'disabled';
171 return;
172 }
173
174 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
175 if (!match) return;
176
177 for (const track of tracks)
178 {
179 track.mode = track === match ? 'showing' : 'disabled';
180 }
181 }
182
183 function applySavedAudioTrack (player, savedName)
184 {
185 if (typeof savedName !== 'string') return;
186 const tracks = audioTracksFromPlayer(player);
187 if (!tracks.length) return;
188
189 const wanted = normaliseTrackName(savedName);
190 if (!wanted) return;
191
192 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
193 if (!match) return;
194
195 for (const track of tracks)
196 {
197 track.enabled = track === match;
198 }
199 }
200
201 function getSelectedSubtitleTrackName (player)
202 {
203 const tracks = subtitleTracksFromPlayer(player);
204 if (!tracks.length) return null;
205 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
206 return active ? getTrackName(active) : '';
207 }
208
209 function getSelectedAudioTrackName (player)
210 {
211 const tracks = audioTracksFromPlayer(player);
212 if (!tracks.length) return null;
213 const active = tracks.find((track) => !!track.enabled);
214 return active ? getTrackName(active) : '';
215 }
216
217 function bindTrackPrefs (player, prefs, savePrefs)
218 {
219 const save = typeof savePrefs === 'function' ? savePrefs : (() => { });
220 const applySavedTracks = () =>
221 {
222 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
223 applySavedAudioTrack(player, prefs.audioTrackName);
224 };
225
226 const captureSelectedTracks = () =>
227 {
228 const subtitleTrackName = getSelectedSubtitleTrackName(player);
229 const audioTrackName = getSelectedAudioTrackName(player);
230 const patch = {};
231
232 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
233 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
234
235 if (Object.keys(patch).length) save(patch);
236 };
237
238 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
239 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
240 const onTrackListChange = () => captureSelectedTracks();
241
242 if (textTrackList && typeof textTrackList.addEventListener === 'function')
243 {
244 textTrackList.addEventListener('change', onTrackListChange);
245 }
246
247 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
248 {
249 audioTrackList.addEventListener('change', onTrackListChange);
250 }
251
252 return {
253 applySavedTracks,
254 captureSelectedTracks,
255 detach: () =>
256 {
257 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
258 {
259 textTrackList.removeEventListener('change', onTrackListChange);
260 }
261 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
262 {
263 audioTrackList.removeEventListener('change', onTrackListChange);
264 }
265 },
266 };
267 }
268
269 function bindImageSubtitleOverlay (player, videojs, prefs, session, opts = {})
270 {
271 const imageTracks = Array.isArray(session.imageSubtitleTracks)
272 ? session.imageSubtitleTracks.map((track) => ({
273 label: String(track.label || '').trim() || `Subtitle ${Number(track.streamIndex || 0) + 1}`,
274 language: String(track.language || '').trim(),
275 isDefault: !!track.default,
276 streamIndex: Number(track.streamIndex),
277 })).filter((track) => Number.isInteger(track.streamIndex) && track.streamIndex >= 0)
278 : [];
279
280 if (!imageTracks.length) return null;
281
282 const savePrefs = typeof opts.savePrefs === 'function' ? opts.savePrefs : (() => { });
283 const buildFrameRequest = typeof opts.buildFrameRequest === 'function' ? opts.buildFrameRequest : null;
284 const notifyError = typeof opts.onError === 'function' ? opts.onError : (() => { });
285 const sendSubtitleLogBatch = typeof opts.sendSubtitleLogBatch === 'function' ? opts.sendSubtitleLogBatch : null;
286 const requestedLookaheadSeconds = Number(opts.lookaheadSeconds);
287 const lookaheadSeconds = Number.isFinite(requestedLookaheadSeconds)
288 ? Math.max(0, Math.min(IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_MAX, requestedLookaheadSeconds))
289 : IMAGE_SUBTITLE_LOOKAHEAD_SECONDS_DEFAULT;
290 const requestedCurrentRequestTimeoutMs = Number(opts.currentRequestTimeoutMs);
291 const currentRequestTimeoutMs = Number.isFinite(requestedCurrentRequestTimeoutMs)
292 ? Math.max(250, requestedCurrentRequestTimeoutMs)
293 : IMAGE_SUBTITLE_CURRENT_REQUEST_TIMEOUT_MS_DEFAULT;
294 const requestedInitialPrefetchSeconds = Number(opts.initialPrefetchSeconds);
295 const initialPrefetchSeconds = Number.isFinite(requestedInitialPrefetchSeconds)
296 ? Math.max(0, Math.min(IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_MAX, requestedInitialPrefetchSeconds))
297 : IMAGE_SUBTITLE_INITIAL_PREFETCH_SECONDS_DEFAULT;
298 const requestedPrefetchRequestTimeoutMs = Number(opts.prefetchRequestTimeoutMs);
299 const prefetchRequestTimeoutMs = Number.isFinite(requestedPrefetchRequestTimeoutMs)
300 ? Math.max(250, requestedPrefetchRequestTimeoutMs)
301 : IMAGE_SUBTITLE_PREFETCH_REQUEST_TIMEOUT_MS_DEFAULT;
302 const requestedPrefetchRequestIntervalMs = Number(opts.prefetchRequestIntervalMs);
303 const prefetchRequestIntervalMs = Number.isFinite(requestedPrefetchRequestIntervalMs)
304 ? Math.max(0, requestedPrefetchRequestIntervalMs)
305 : IMAGE_SUBTITLE_PREFETCH_REQUEST_INTERVAL_MS_DEFAULT;
306 const currentFetchEnabled = opts.currentFetchEnabled !== false;
307 const logToConsole = opts.logToConsole !== false;
308 if (!buildFrameRequest) return null;
309
310 const trackByStreamIndex = new Map(imageTracks.map((track) => [track.streamIndex, track]));
311 let selectedStreamIndex = null;
312 let menuOpen = false;
313 let activeBucket = -1;
314 let activeObjectUrl = null;
315 let overlayEl = null;
316 let overlayImgEl = null;
317 let menuEl = null;
318 let buttonEl = null;
319 let trackDisabled = false;
320 let failureNotified = false;
321 let lifecycleToken = 0;
322 let currentFrameToken = 0;
323 let currentFrameAbortController = null;
324 let prefetchWorkerToken = 0;
325 let prefetchAbortController = null;
326 let prefetchPromise = null;
327 let prefetchTargetTimeSeconds = -1;
328 let prefetchedThroughTimeSeconds = -1;
329 let queuedCurrentRefresh = false;
330 let queuedCurrentRefreshForce = false;
331 let currentFramePromise = null;
332 let seekMarkerContainerEl = null;
333 let seekMarkerRequestedEl = null;
334 let seekMarkerReceivedEl = null;
335 let lastRequestedCaptionStartTimeSeconds = null;
336 let lastReceivedCaptionStartTimeSeconds = null;
337 let subtitleLogSequence = 0;
338 let subtitleLogQueue = [];
339 let subtitleLogFlushTimer = null;
340 const cachedSubtitleFrames = new Map();
341
342 const flushSubtitleLogs = () =>
343 {
344 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
345 if (subtitleLogFlushTimer)
346 {
347 window.clearTimeout(subtitleLogFlushTimer);
348 subtitleLogFlushTimer = null;
349 }
350
351 const batch = subtitleLogQueue;
352 subtitleLogQueue = [];
353 Promise.resolve(sendSubtitleLogBatch(batch)).catch(() =>
354 {
355 // Keep subtitle diagnostics best-effort only.
356 });
357 };
358
359 const scheduleSubtitleLogFlush = () =>
360 {
361 if (!sendSubtitleLogBatch || !subtitleLogQueue.length) return;
362 if (subtitleLogQueue.length >= SUBTITLE_LOG_BATCH_MAX_ITEMS)
363 {
364 flushSubtitleLogs();
365 return;
366 }
367 if (subtitleLogFlushTimer) return;
368 subtitleLogFlushTimer = window.setTimeout(() =>
369 {
370 subtitleLogFlushTimer = null;
371 flushSubtitleLogs();
372 }, SUBTITLE_LOG_FLUSH_DELAY_MS);
373 };
374
375 const logSubtitleEvent = (eventType, details = {}) =>
376 {
377 const entry = {
378 seq: ++subtitleLogSequence,
379 loggedAtMs: Date.now(),
380 eventType,
381 sessionId: String(session.sessionId || '').trim() || null,
382 streamIndex: Number.isInteger(selectedStreamIndex) ? selectedStreamIndex : null,
383 playerTimeSeconds: roundLogNumber(player.currentTime()),
384 ...details,
385 };
386 if (logToConsole)
387 {
388 try
389 {
390 console.log('[subtitle-log]', entry);
391 } catch
392 {
393 // Ignore console availability issues.
394 }
395 }
396
397 if (!sendSubtitleLogBatch) return;
398 subtitleLogQueue.push(entry);
399 scheduleSubtitleLogFlush();
400 };
401
402 const createAbortController = () =>
403 {
404 if (typeof AbortController !== 'function') return null;
405 return new AbortController();
406 };
407
408 const abortController = (controller) =>
409 {
410 if (!controller || typeof controller.abort !== 'function') return;
411 try
412 {
413 controller.abort();
414 } catch
415 {
416 // Ignore abort races during teardown.
417 }
418 };
419
420 const isAbortError = (error) =>
421 {
422 return !!(error && typeof error === 'object' && error.name === 'AbortError');
423 };
424
425 const armRequestTimeout = (controller, timeoutMs, onTimeout) =>
426 {
427 if (!controller || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return null;
428 return window.setTimeout(() =>
429 {
430 if (typeof onTimeout === 'function') onTimeout();
431 abortController(controller);
432 }, timeoutMs);
433 };
434
435 const clearRequestTimeout = (timeoutId) =>
436 {
437 if (timeoutId === null || timeoutId === undefined) return;
438 window.clearTimeout(timeoutId);
439 };
440
441 const cancelCurrentFrameRequest = () =>
442 {
443 currentFrameToken++;
444 abortController(currentFrameAbortController);
445 currentFrameAbortController = null;
446 };
447
448 const cancelPrefetchRequests = ({ resetProgress = false } = {}) =>
449 {
450 prefetchWorkerToken++;
451 abortController(prefetchAbortController);
452 prefetchAbortController = null;
453 prefetchPromise = null;
454 if (resetProgress)
455 {
456 prefetchTargetTimeSeconds = -1;
457 prefetchedThroughTimeSeconds = -1;
458 }
459 };
460
461 const resetRequestState = () =>
462 {
463 lifecycleToken++;
464 cancelCurrentFrameRequest();
465 cancelPrefetchRequests({ resetProgress: true });
466 };
467
468 const closeObjectUrl = () =>
469 {
470 activeObjectUrl = null;
471 };
472
473 const hideOverlay = () =>
474 {
475 if (overlayEl) overlayEl.style.display = 'none';
476 if (overlayImgEl) overlayImgEl.removeAttribute('src');
477 closeObjectUrl();
478 };
479
480 const revokeCachedFrameUrls = () =>
481 {
482 for (const frame of cachedSubtitleFrames.values())
483 {
484 if (!frame || !frame.objectUrl) continue;
485 try
486 {
487 URL.revokeObjectURL(frame.objectUrl);
488 } catch
489 {
490 // Ignore object URL cleanup races.
491 }
492 }
493 cachedSubtitleFrames.clear();
494 };
495
496 const parseFrameMetadata = (res, fallbackStartTimeSeconds) =>
497 {
498 const rawStart = parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time');
499 const startTimeSeconds = Number.isFinite(rawStart) && rawStart >= 0
500 ? rawStart
501 : (Number.isFinite(fallbackStartTimeSeconds) && fallbackStartTimeSeconds >= 0 ? fallbackStartTimeSeconds : null);
502
503 const rawEnd = parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time');
504 const endTimeSeconds = Number.isFinite(rawEnd)
505 ? rawEnd
506 : (Number.isFinite(startTimeSeconds) ? startTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS : null);
507
508 const frameWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Width') || ''), 10);
509 const frameHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Height') || ''), 10);
510 const canvasWidth = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Width') || ''), 10);
511 const canvasHeight = Number.parseInt(String(res.headers.get('X-Subtitle-Frame-Canvas-Height') || ''), 10);
512
513 return {
514 startTimeSeconds,
515 endTimeSeconds,
516 frameWidth,
517 frameHeight,
518 canvasWidth,
519 canvasHeight,
520 };
521 };
522
523 const cacheFrameKey = (streamIndex, startTimeSeconds, endTimeSeconds) =>
524 {
525 const startPart = Number.isFinite(startTimeSeconds) ? startTimeSeconds.toFixed(6) : 'none';
526 const endPart = Number.isFinite(endTimeSeconds) ? endTimeSeconds.toFixed(6) : 'none';
527 return `${streamIndex}|${startPart}|${endPart}`;
528 };
529
530 const cacheSubtitleFrame = ({ streamIndex, blob, metadata }) =>
531 {
532 if (!Number.isInteger(streamIndex) || streamIndex < 0) return null;
533 if (!blob || typeof blob.size !== 'number' || blob.size <= 0) return null;
534
535 const startTimeSeconds = Number.isFinite(metadata && metadata.startTimeSeconds) ? metadata.startTimeSeconds : null;
536 const endTimeSeconds = Number.isFinite(metadata && metadata.endTimeSeconds)
537 ? metadata.endTimeSeconds
538 : (Number.isFinite(startTimeSeconds) ? startTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS : null);
539 if (!Number.isFinite(startTimeSeconds) || !Number.isFinite(endTimeSeconds) || endTimeSeconds <= startTimeSeconds)
540 {
541 return null;
542 }
543
544 const key = cacheFrameKey(streamIndex, startTimeSeconds, endTimeSeconds);
545 const objectUrl = URL.createObjectURL(blob);
546 const previous = cachedSubtitleFrames.get(key);
547 if (previous && previous.objectUrl)
548 {
549 try
550 {
551 URL.revokeObjectURL(previous.objectUrl);
552 } catch
553 {
554 // Ignore object URL cleanup races.
555 }
556 }
557
558 const entry = {
559 key,
560 streamIndex,
561 startTimeSeconds,
562 endTimeSeconds,
563 objectUrl,
564 frameWidth: Number(metadata && metadata.frameWidth),
565 frameHeight: Number(metadata && metadata.frameHeight),
566 canvasWidth: Number(metadata && metadata.canvasWidth),
567 canvasHeight: Number(metadata && metadata.canvasHeight),
568 };
569 cachedSubtitleFrames.set(key, entry);
570 return entry;
571 };
572
573 const findCachedFrameForTime = (streamIndex, currentTime) =>
574 {
575 if (!Number.isInteger(streamIndex) || streamIndex < 0) return null;
576 if (!Number.isFinite(currentTime) || currentTime < 0) return null;
577
578 let best = null;
579 for (const frame of cachedSubtitleFrames.values())
580 {
581 if (!frame || frame.streamIndex !== streamIndex) continue;
582 if (!Number.isFinite(frame.startTimeSeconds) || !Number.isFinite(frame.endTimeSeconds)) continue;
583 if (currentTime < frame.startTimeSeconds || currentTime >= frame.endTimeSeconds) continue;
584 if (!best || frame.startTimeSeconds > best.startTimeSeconds) best = frame;
585 }
586 return best;
587 };
588
589 const renderSubtitleFrame = (frame) =>
590 {
591 if (!overlayEl || !overlayImgEl || !frame || !frame.objectUrl) return;
592
593 activeObjectUrl = frame.objectUrl;
594 overlayImgEl.src = frame.objectUrl;
595
596 if (frame.frameWidth > 0 && frame.frameHeight > 0 && frame.canvasWidth > 0 && frame.canvasHeight > 0)
597 {
598 const widthPercent = (frame.frameWidth / frame.canvasWidth) * 100;
599 const heightPercent = (frame.frameHeight / frame.canvasHeight) * 100;
600 overlayImgEl.style.width = `${widthPercent}%`;
601 overlayImgEl.style.height = `${heightPercent}%`;
602 overlayImgEl.style.maxWidth = 'none';
603 overlayImgEl.style.maxHeight = 'none';
604 } else
605 {
606 overlayImgEl.style.width = 'auto';
607 overlayImgEl.style.height = 'auto';
608 overlayImgEl.style.maxWidth = '100%';
609 overlayImgEl.style.maxHeight = '100%';
610 }
611
612 overlayEl.style.display = 'block';
613 overlayImgEl.style.display = 'block';
614 };
615
616 const setSeekMarkerTime = (kind, timeSeconds) =>
617 {
618 const numericTime = Number(timeSeconds);
619 const nextTime = Number.isFinite(numericTime) && numericTime >= 0 ? numericTime : null;
620
621 if (kind === 'requested')
622 {
623 if (nextTime === null)
624 {
625 lastRequestedCaptionStartTimeSeconds = null;
626 } else if (!Number.isFinite(lastRequestedCaptionStartTimeSeconds) || nextTime >= lastRequestedCaptionStartTimeSeconds)
627 {
628 lastRequestedCaptionStartTimeSeconds = nextTime;
629 }
630 } else if (kind === 'received')
631 {
632 if (nextTime === null)
633 {
634 lastReceivedCaptionStartTimeSeconds = null;
635 } else if (!Number.isFinite(lastReceivedCaptionStartTimeSeconds) || nextTime >= lastReceivedCaptionStartTimeSeconds)
636 {
637 lastReceivedCaptionStartTimeSeconds = nextTime;
638 }
639 }
640 };
641
642 const updateSeekBarMarkers = () =>
643 {
644 if (!seekMarkerRequestedEl || !seekMarkerReceivedEl) return;
645
646 const duration = Number(player.duration && player.duration());
647 if (!Number.isFinite(duration) || duration <= 0)
648 {
649 seekMarkerRequestedEl.style.display = 'none';
650 seekMarkerReceivedEl.style.display = 'none';
651 return;
652 }
653
654 const getMarkerRatio = (markerTimeSeconds) =>
655 {
656 if (!Number.isFinite(markerTimeSeconds) || markerTimeSeconds < 0)
657 {
658 return null;
659 }
660
661 return Math.max(0, Math.min(1, markerTimeSeconds / duration));
662 };
663
664 const applyMarker = (markerEl, ratio) =>
665 {
666 if (!Number.isFinite(ratio))
667 {
668 markerEl.style.display = 'none';
669 return;
670 }
671
672 markerEl.style.display = 'block';
673 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
674 };
675
676 const requestedRatio = getMarkerRatio(lastRequestedCaptionStartTimeSeconds);
677 const receivedRatio = getMarkerRatio(lastReceivedCaptionStartTimeSeconds);
678 applyMarker(seekMarkerRequestedEl, requestedRatio);
679 applyMarker(seekMarkerReceivedEl, receivedRatio);
680 };
681
682 const ensureSeekBarMarkers = () =>
683 {
684 if (seekMarkerContainerEl && seekMarkerContainerEl.isConnected)
685 {
686 updateSeekBarMarkers();
687 return;
688 }
689
690 const playerEl = player.el && player.el();
691 if (!playerEl) return;
692
693 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
694 || playerEl.querySelector('.vjs-progress-holder')
695 || playerEl.querySelector('.vjs-progress-control');
696 if (!seekBarEl) return;
697
698 const computedPosition = window.getComputedStyle(seekBarEl).position;
699 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
700
701 seekMarkerContainerEl = document.createElement('div');
702 seekMarkerContainerEl.className = 'vjs-image-subtitle-seek-markers';
703 seekMarkerContainerEl.style.position = 'absolute';
704 seekMarkerContainerEl.style.left = '0';
705 seekMarkerContainerEl.style.right = '0';
706 seekMarkerContainerEl.style.top = '50%';
707 seekMarkerContainerEl.style.height = '10px';
708 seekMarkerContainerEl.style.transform = 'translateY(-50%)';
709 seekMarkerContainerEl.style.pointerEvents = 'none';
710 seekMarkerContainerEl.style.zIndex = '5';
711
712 const buildBracketMarker = (direction) =>
713 {
714 const markerEl = document.createElement('span');
715 markerEl.className = `vjs-image-subtitle-seek-marker vjs-image-subtitle-seek-marker-${direction}`;
716 markerEl.style.position = 'absolute';
717 markerEl.style.top = '50%';
718 markerEl.style.width = '10px';
719 markerEl.style.height = '10px';
720 markerEl.style.transform = 'translate(-50%, -50%)';
721 markerEl.style.color = '#fff';
722 markerEl.style.fontFamily = 'monospace';
723 markerEl.style.fontSize = '12px';
724 markerEl.style.fontWeight = '700';
725 markerEl.style.lineHeight = '10px';
726 markerEl.style.textAlign = 'center';
727 markerEl.style.display = 'none';
728 markerEl.textContent = direction === 'left' ? '[' : ']';
729 markerEl.setAttribute('aria-hidden', 'true');
730 return markerEl;
731 };
732
733 seekMarkerReceivedEl = buildBracketMarker('left');
734 seekMarkerRequestedEl = buildBracketMarker('right');
735 seekMarkerContainerEl.appendChild(seekMarkerReceivedEl);
736 seekMarkerContainerEl.appendChild(seekMarkerRequestedEl);
737
738 seekBarEl.appendChild(seekMarkerContainerEl);
739 updateSeekBarMarkers();
740 };
741
742 const updateButtonState = () =>
743 {
744 if (!buttonEl) return;
745 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
746 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
747 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
748 };
749
750 const updateMenuState = () =>
751 {
752 if (!menuEl) return;
753 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
754 for (const itemEl of items)
755 {
756 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
757 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
758 itemEl.classList.toggle('is-selected', isSelected);
759 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
760 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
761 itemEl.style.fontWeight = isSelected ? '600' : '400';
762 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
763 }
764 };
765
766 const closeMenu = () =>
767 {
768 menuOpen = false;
769 if (menuEl) menuEl.style.display = 'none';
770 };
771
772 const openMenu = () =>
773 {
774 menuOpen = true;
775 if (menuEl)
776 {
777 updateMenuState();
778 menuEl.style.display = 'block';
779 }
780 };
781
782 const toggleMenu = () =>
783 {
784 if (menuOpen) closeMenu();
785 else openMenu();
786 };
787
788 const saveSelection = () =>
789 {
790 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
791 savePrefs({
792 imageSubtitleTrackStreamIndex: selectedStreamIndex,
793 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
794 });
795 };
796
797 const disableTrack = () =>
798 {
799 trackDisabled = true;
800 selectedStreamIndex = null;
801 activeBucket = -1;
802 setSeekMarkerTime('requested', null);
803 setSeekMarkerTime('received', null);
804 updateSeekBarMarkers();
805 resetRequestState();
806 hideOverlay();
807 updateButtonState();
808 updateMenuState();
809 saveSelection();
810
811 if (!failureNotified)
812 {
813 failureNotified = true;
814 notifyError();
815 }
816 };
817
818 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
819 {
820 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
821 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
822
823 trackDisabled = false;
824 failureNotified = false;
825 selectedStreamIndex = nextStreamIndex;
826 activeBucket = -1;
827 setSeekMarkerTime('requested', null);
828 setSeekMarkerTime('received', null);
829 updateSeekBarMarkers();
830 resetRequestState();
831 hideOverlay();
832 updateButtonState();
833 updateMenuState();
834 if (persist) saveSelection();
835
836 if (selectedStreamIndex !== null)
837 {
838 if (initialPrefetchSeconds > 0)
839 {
840 queueLookaheadPrefetch(0, {
841 reset: true,
842 includeCurrentTime: true,
843 maxTargetTimeSeconds: initialPrefetchSeconds,
844 });
845 }
846 void refreshFrame();
847 }
848 };
849
850 const queueLookaheadPrefetch = (currentTime, {
851 reset = false,
852 includeCurrentTime = false,
853 maxTargetTimeSeconds = null,
854 } = {}) =>
855 {
856 if (selectedStreamIndex === null) return;
857 if (trackDisabled) return;
858
859 const durationSeconds = Number(player.duration && player.duration());
860 const knownVideoEndSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0
861 ? durationSeconds
862 : null;
863
864 const bufferedVideoEndSeconds = (() =>
865 {
866 const candidates = [];
867
868 const fromPlayer = Number(player.bufferedEnd && player.bufferedEnd());
869 if (Number.isFinite(fromPlayer) && fromPlayer >= 0) candidates.push(fromPlayer);
870
871 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
872 const mediaEl = tech && typeof tech.el === 'function'
873 ? tech.el()
874 : (player.el && player.el() ? player.el().querySelector('video') : null);
875
876 const ranges = mediaEl && mediaEl.buffered;
877 if (ranges && typeof ranges.length === 'number' && ranges.length > 0 && typeof ranges.end === 'function')
878 {
879 try
880 {
881 const endTime = Number(ranges.end(ranges.length - 1));
882 if (Number.isFinite(endTime) && endTime >= 0) candidates.push(endTime);
883 } catch
884 {
885 // Ignore buffered range read races.
886 }
887 }
888
889 if (!candidates.length) return null;
890 return Math.max(...candidates);
891 })();
892
893 const startTime = includeCurrentTime
894 ? currentTime
895 : currentTime + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
896 const uncappedEndTime = Math.max(
897 currentTime + lookaheadSeconds,
898 Number.isFinite(bufferedVideoEndSeconds) ? bufferedVideoEndSeconds : -1,
899 Number.isFinite(knownVideoEndSeconds) ? knownVideoEndSeconds : -1,
900 );
901 const capEndTime = Number.isFinite(maxTargetTimeSeconds) && maxTargetTimeSeconds >= 0
902 ? maxTargetTimeSeconds
903 : null;
904 const endTime = Number.isFinite(capEndTime)
905 ? Math.min(uncappedEndTime, capEndTime)
906 : uncappedEndTime;
907 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
908
909 if (reset || prefetchedThroughTimeSeconds < 0)
910 {
911 cancelPrefetchRequests({ resetProgress: true });
912 prefetchedThroughTimeSeconds = includeCurrentTime
913 ? currentTime - IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS
914 : currentTime;
915 } else if (prefetchedThroughTimeSeconds < currentTime)
916 {
917 // Keep the prefetch frontier at or ahead of current playback so
918 // prefetch catches buffered-ahead range instead of replaying stale lag.
919 prefetchedThroughTimeSeconds = currentTime;
920 }
921
922 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
923 if (prefetchPromise) return;
924
925 const workerToken = ++prefetchWorkerToken;
926 const workerLifecycleToken = lifecycleToken;
927 const controller = createAbortController();
928 prefetchAbortController = controller;
929
930 prefetchPromise = (async () =>
931 {
932 while (true)
933 {
934 if (selectedStreamIndex === null || trackDisabled) return;
935 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
936
937 const nextTime = prefetchedThroughTimeSeconds < 0
938 ? startTime
939 : prefetchedThroughTimeSeconds + IMAGE_SUBTITLE_PREFETCH_STEP_SECONDS;
940 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
941
942 const request = buildFrameRequest({
943 streamIndex: selectedStreamIndex,
944 currentTime: nextTime,
945 session,
946 });
947 if (!request || !request.url) return;
948
949 const prefetchRequestStartedAtMs = Date.now();
950 const prefetchRequestId = `prefetch-${workerToken}-${Math.round(nextTime * 1000)}`;
951 logSubtitleEvent('subtitle_png_requested', {
952 requestId: prefetchRequestId,
953 requestKind: 'prefetch',
954 requestUrl: String(request.url || ''),
955 requestedAtMs: prefetchRequestStartedAtMs,
956 requestedVideoTimeSeconds: roundLogNumber(nextTime),
957 });
958
959 let prefetchTimedOut = false;
960 const timeoutId = armRequestTimeout(controller, prefetchRequestTimeoutMs, () =>
961 {
962 prefetchTimedOut = true;
963 });
964
965 try
966 {
967 const res = await fetch(request.url, {
968 method: request.method || 'GET',
969 headers: request.headers,
970 credentials: request.credentials,
971 signal: controller ? controller.signal : undefined,
972 });
973 clearRequestTimeout(timeoutId);
974
975 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
976
977 const responseMeta = {
978 requestId: prefetchRequestId,
979 requestKind: 'prefetch',
980 status: res.status,
981 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
982 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
983 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
984 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
985 responseHeadersReceivedAtMs: Date.now(),
986 requestedVideoTimeSeconds: roundLogNumber(nextTime),
987 };
988 logSubtitleEvent('subtitle_png_sent', {
989 ...responseMeta,
990 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
991 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
992 });
993
994 setSeekMarkerTime('requested', nextTime);
995 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
996 ? responseMeta.shouldShowAtVideoTimeSeconds
997 : nextTime;
998 setSeekMarkerTime('received', receivedMarkerTime);
999 updateSeekBarMarkers();
1000
1001 if (res.status === 204)
1002 {
1003 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1004 logSubtitleEvent('subtitle_png_not_available', {
1005 ...responseMeta,
1006 frameStatus,
1007 });
1008 if (frameStatus === 'error') return;
1009 prefetchedThroughTimeSeconds = nextTime;
1010 if (prefetchRequestIntervalMs > 0)
1011 {
1012 await new Promise((resolve) => window.setTimeout(resolve, prefetchRequestIntervalMs));
1013 }
1014 continue;
1015 }
1016
1017 if (!res.ok) return;
1018 const payload = await res.arrayBuffer();
1019 const receivedAtMs = Date.now();
1020 const metadata = parseFrameMetadata(res, nextTime);
1021 const blob = new Blob([payload], {
1022 type: String(res.headers.get('Content-Type') || '').trim() || 'image/png',
1023 });
1024 cacheSubtitleFrame({
1025 streamIndex: selectedStreamIndex,
1026 blob,
1027 metadata,
1028 });
1029 logSubtitleEvent('subtitle_png_received', {
1030 ...responseMeta,
1031 receivedAtMs,
1032 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1033 requestedToReceivedMs: diffMilliseconds(receivedAtMs, prefetchRequestStartedAtMs),
1034 blobBytes: Number(payload && payload.byteLength || 0),
1035 });
1036 prefetchedThroughTimeSeconds = nextTime;
1037 if (prefetchRequestIntervalMs > 0)
1038 {
1039 await new Promise((resolve) => window.setTimeout(resolve, prefetchRequestIntervalMs));
1040 }
1041 } catch (error)
1042 {
1043 clearRequestTimeout(timeoutId);
1044 if (prefetchTimedOut)
1045 {
1046 logSubtitleEvent('subtitle_png_request_failed', {
1047 requestId: prefetchRequestId,
1048 requestKind: 'prefetch',
1049 requestedAtMs: prefetchRequestStartedAtMs,
1050 errorName: 'AbortError',
1051 errorMessage: `Prefetch subtitle request timed out after ${Math.round(prefetchRequestTimeoutMs)}ms`,
1052 });
1053 return;
1054 }
1055 if (isAbortError(error)) return;
1056 logSubtitleEvent('subtitle_png_request_failed', {
1057 requestId: prefetchRequestId,
1058 requestKind: 'prefetch',
1059 requestedAtMs: prefetchRequestStartedAtMs,
1060 errorName: error && error.name ? String(error.name) : null,
1061 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1062 });
1063 return;
1064 }
1065 }
1066 })().finally(() =>
1067 {
1068 if (workerToken !== prefetchWorkerToken) return;
1069 prefetchAbortController = null;
1070 prefetchPromise = null;
1071 });
1072 };
1073
1074 const refreshFrame = async (force = false) =>
1075 {
1076 if (selectedStreamIndex === null) return;
1077 if (!overlayEl || !overlayImgEl) return;
1078 if (trackDisabled) return;
1079
1080 if (currentFramePromise && !force)
1081 {
1082 queuedCurrentRefresh = true;
1083 return;
1084 }
1085
1086 const currentTime = Number(player.currentTime());
1087 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1088
1089 const bucket = Math.floor(currentTime * 4);
1090 if (!force && bucket === activeBucket) return;
1091 activeBucket = bucket;
1092
1093 const cachedFrame = findCachedFrameForTime(selectedStreamIndex, currentTime);
1094 if (cachedFrame)
1095 {
1096 setSeekMarkerTime('requested', currentTime);
1097 setSeekMarkerTime('received', cachedFrame.startTimeSeconds);
1098 updateSeekBarMarkers();
1099 renderSubtitleFrame(cachedFrame);
1100 queueLookaheadPrefetch(currentTime, { reset: force });
1101 return;
1102 }
1103
1104 if (!currentFetchEnabled)
1105 {
1106 hideOverlay();
1107 queueLookaheadPrefetch(currentTime, {
1108 reset: force,
1109 includeCurrentTime: true,
1110 });
1111 return;
1112 }
1113
1114 const refreshLifecycleToken = lifecycleToken;
1115 if (force && currentFramePromise)
1116 {
1117 cancelCurrentFrameRequest();
1118 }
1119 if (currentFramePromise)
1120 {
1121 queuedCurrentRefresh = true;
1122 queuedCurrentRefreshForce = queuedCurrentRefreshForce || !!force;
1123 return;
1124 }
1125 cancelCurrentFrameRequest();
1126 if (force) cancelPrefetchRequests({ resetProgress: true });
1127
1128 const token = ++currentFrameToken;
1129 const requestId = `current-${token}`;
1130 const requestStartedAtMs = Date.now();
1131 const controller = createAbortController();
1132 currentFrameAbortController = controller;
1133 const request = buildFrameRequest({
1134 streamIndex: selectedStreamIndex,
1135 currentTime,
1136 session,
1137 });
1138
1139 if (!request || !request.url)
1140 {
1141 disableTrack();
1142 return;
1143 }
1144
1145 logSubtitleEvent('subtitle_png_requested', {
1146 requestId,
1147 requestKind: 'current',
1148 requestUrl: String(request.url || ''),
1149 requestedAtMs: requestStartedAtMs,
1150 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1151 });
1152
1153 const frameRequestPromise = (async () =>
1154 {
1155 let currentTimedOut = false;
1156 const timeoutId = armRequestTimeout(controller, currentRequestTimeoutMs, () =>
1157 {
1158 currentTimedOut = true;
1159 });
1160 try
1161 {
1162 const res = await fetch(request.url, {
1163 method: request.method || 'GET',
1164 headers: request.headers,
1165 credentials: request.credentials,
1166 signal: controller ? controller.signal : undefined,
1167 });
1168 clearRequestTimeout(timeoutId);
1169
1170 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1171
1172 const responseMeta = {
1173 requestId,
1174 requestKind: 'current',
1175 status: res.status,
1176 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1177 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1178 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1179 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1180 responseHeadersReceivedAtMs: Date.now(),
1181 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1182 };
1183 logSubtitleEvent('subtitle_png_sent', {
1184 ...responseMeta,
1185 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1186 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1187 });
1188
1189 setSeekMarkerTime('requested', currentTime);
1190 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1191 ? responseMeta.shouldShowAtVideoTimeSeconds
1192 : currentTime;
1193 setSeekMarkerTime('received', receivedMarkerTime);
1194 updateSeekBarMarkers();
1195
1196 if (res.status === 204)
1197 {
1198 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1199 logSubtitleEvent('subtitle_png_not_available', {
1200 ...responseMeta,
1201 frameStatus,
1202 });
1203 hideOverlay();
1204 if (frameStatus === 'error') disableTrack();
1205 else queueLookaheadPrefetch(currentTime, { reset: force });
1206 return;
1207 }
1208
1209 if (!res.ok)
1210 {
1211 disableTrack();
1212 return;
1213 }
1214
1215 const blob = await res.blob();
1216 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1217
1218 const receivedAtMs = Date.now();
1219 logSubtitleEvent('subtitle_png_received', {
1220 ...responseMeta,
1221 receivedAtMs,
1222 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1223 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
1224 blobBytes: Number(blob && blob.size || 0),
1225 });
1226
1227 if (!blob || blob.size === 0)
1228 {
1229 disableTrack();
1230 return;
1231 }
1232 const cachedFrameEntry = cacheSubtitleFrame({
1233 streamIndex: selectedStreamIndex,
1234 blob,
1235 metadata: parseFrameMetadata(res, currentTime),
1236 });
1237 if (cachedFrameEntry) renderSubtitleFrame(cachedFrameEntry);
1238
1239 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
1240 {
1241 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1242 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
1243 logSubtitleEvent('subtitle_png_shown', {
1244 ...responseMeta,
1245 receivedAtMs,
1246 shownAtMs,
1247 shownAtVideoTimeSeconds,
1248 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1249 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
1250 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
1251 });
1252 });
1253
1254 queueLookaheadPrefetch(currentTime, { reset: force });
1255 } catch (error)
1256 {
1257 clearRequestTimeout(timeoutId);
1258 if (currentTimedOut)
1259 {
1260 logSubtitleEvent('subtitle_png_request_failed', {
1261 requestId,
1262 requestKind: 'current',
1263 requestedAtMs: requestStartedAtMs,
1264 errorName: 'AbortError',
1265 errorMessage: `Current subtitle request timed out after ${Math.round(currentRequestTimeoutMs)}ms`,
1266 });
1267 return;
1268 }
1269 if (isAbortError(error)) return;
1270 logSubtitleEvent('subtitle_png_request_failed', {
1271 requestId,
1272 requestKind: 'current',
1273 requestedAtMs: requestStartedAtMs,
1274 errorName: error && error.name ? String(error.name) : null,
1275 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1276 });
1277 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
1278 }
1279 })();
1280
1281 currentFramePromise = frameRequestPromise;
1282 frameRequestPromise.finally(() =>
1283 {
1284 if (currentFramePromise !== frameRequestPromise) return;
1285 currentFrameAbortController = null;
1286 currentFramePromise = null;
1287 if (!queuedCurrentRefresh) return;
1288
1289 const queuedForce = queuedCurrentRefreshForce;
1290 queuedCurrentRefresh = false;
1291 queuedCurrentRefreshForce = false;
1292 void refreshFrame(queuedForce);
1293 });
1294
1295 return currentFramePromise;
1296 };
1297
1298 const dispose = () =>
1299 {
1300 resetRequestState();
1301 flushSubtitleLogs();
1302 closeMenu();
1303 hideOverlay();
1304 if (seekMarkerContainerEl) seekMarkerContainerEl.remove();
1305 seekMarkerContainerEl = null;
1306 seekMarkerRequestedEl = null;
1307 seekMarkerReceivedEl = null;
1308 revokeCachedFrameUrls();
1309 if (overlayEl) overlayEl.remove();
1310 if (menuEl) menuEl.remove();
1311 player.imageSubtitleOverlayController = null;
1312 buttonEl = null;
1313 };
1314
1315 overlayEl = document.createElement('div');
1316 overlayEl.className = 'video-subtitle-overlay';
1317 overlayEl.style.position = 'absolute';
1318 overlayEl.style.left = '0';
1319 overlayEl.style.right = '0';
1320 overlayEl.style.bottom = '3rem';
1321 overlayEl.style.display = 'none';
1322 overlayEl.style.zIndex = '3';
1323 overlayEl.style.pointerEvents = 'none';
1324 overlayEl.style.textAlign = 'center';
1325 overlayEl.style.padding = '0 0.75rem';
1326 overlayEl.style.maxHeight = '70%';
1327 overlayEl.style.overflow = 'hidden';
1328
1329 overlayImgEl = document.createElement('img');
1330 overlayImgEl.alt = 'Image subtitles';
1331 overlayImgEl.style.display = 'none';
1332 overlayImgEl.style.margin = '0 auto';
1333 overlayImgEl.style.objectFit = 'contain';
1334 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1335 overlayImgEl.style.maxWidth = '100%';
1336 overlayImgEl.style.height = 'auto';
1337 overlayEl.appendChild(overlayImgEl);
1338
1339 menuEl = document.createElement('div');
1340 menuEl.className = 'video-subtitle-overlay-menu';
1341 menuEl.style.position = 'absolute';
1342 menuEl.style.right = '0.75rem';
1343 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
1344 menuEl.style.minWidth = '14rem';
1345 menuEl.style.maxWidth = '20rem';
1346 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
1347 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
1348 menuEl.style.borderRadius = '0.5rem';
1349 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
1350 menuEl.style.padding = '0.35rem';
1351 menuEl.style.display = 'none';
1352 menuEl.style.zIndex = '4';
1353
1354 const buildMenuItem = (label, streamIndex, isSelected) =>
1355 {
1356 const itemEl = document.createElement('button');
1357 itemEl.type = 'button';
1358 itemEl.className = 'video-subtitle-overlay-menu-item';
1359 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
1360 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1361 itemEl.style.display = 'block';
1362 itemEl.style.width = '100%';
1363 itemEl.style.margin = '0';
1364 itemEl.style.padding = '0.5rem 0.75rem';
1365 itemEl.style.border = '0';
1366 itemEl.style.borderRadius = '0.35rem';
1367 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
1368 itemEl.style.color = '#fff';
1369 itemEl.style.textAlign = 'left';
1370 itemEl.style.cursor = 'pointer';
1371 itemEl.textContent = label;
1372 itemEl.addEventListener('click', () =>
1373 {
1374 setSelectedStreamIndex(streamIndex);
1375 closeMenu();
1376 });
1377 return itemEl;
1378 };
1379
1380 menuEl.appendChild(buildMenuItem('Off', null, false));
1381 for (const track of imageTracks)
1382 {
1383 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
1384 }
1385
1386 const registerButton = () =>
1387 {
1388 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
1389 if (videojs.getComponent('ImageSubtitleButton')) return;
1390
1391 const Button = videojs.getComponent('Button');
1392 class ImageSubtitleButton extends Button
1393 {
1394 buildCSSClass ()
1395 {
1396 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
1397 }
1398
1399 createEl ()
1400 {
1401 const el = super.createEl();
1402 el.type = 'button';
1403 el.setAttribute('title', 'Image subtitles');
1404 el.setAttribute('aria-label', 'Image subtitles');
1405 el.innerHTML = '<span aria-hidden="true">IM</span>';
1406 return el;
1407 }
1408
1409 handleClick ()
1410 {
1411 const controller = this.player().imageSubtitleOverlayController;
1412 if (controller) controller.toggleMenu();
1413 }
1414 }
1415
1416 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
1417 };
1418
1419 const attachUi = () =>
1420 {
1421 if (!player.el()) return;
1422 registerButton();
1423 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
1424 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
1425 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
1426 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
1427 {
1428 const button = controlBar.addChild('ImageSubtitleButton', {});
1429 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
1430 updateButtonState();
1431 }
1432 };
1433
1434 const applySavedTracks = () =>
1435 {
1436 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
1437 if (savedName)
1438 {
1439 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
1440 if (savedByName)
1441 {
1442 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
1443 return;
1444 }
1445 }
1446
1447 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
1448 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
1449 {
1450 setSelectedStreamIndex(savedIndex, { persist: false });
1451 return;
1452 }
1453
1454 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
1455 if (defaultTrack)
1456 {
1457 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
1458 return;
1459 }
1460
1461 setSelectedStreamIndex(null, { persist: false });
1462 };
1463
1464 player.imageSubtitleOverlayController = {
1465 toggleMenu,
1466 closeMenu,
1467 applySavedTracks,
1468 captureSelectedTracks: saveSelection,
1469 detach: dispose,
1470 };
1471
1472 player.on('timeupdate', () => { void refreshFrame(); });
1473 player.on('seeking', () => { void refreshFrame(true); });
1474 player.on('play', () => { void refreshFrame(true); });
1475 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
1476 player.on('dispose', dispose);
1477 player.ready(() =>
1478 {
1479 attachUi();
1480 ensureSeekBarMarkers();
1481 updateMenuState();
1482 updateButtonState();
1483 updateSeekBarMarkers();
1484 applySavedTracks();
1485 if (menuOpen) openMenu();
1486 });
1487
1488 player.on('durationchange', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1489 player.on('loadedmetadata', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1490
1491 return player.imageSubtitleOverlayController;
1492 }
1493
1494 function formatDurationForDebug (seconds)
1495 {
1496 const value = Number(seconds);
1497 if (!Number.isFinite(value) || value < 0) return 'unknown';
1498
1499 const totalSeconds = Math.floor(value);
1500 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1501 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1502 const ss = String(totalSeconds % 60).padStart(2, '0');
1503 return `${hh}:${mm}:${ss}`;
1504 }
1505
1506 function installDurationFallback (player, originalDuration, duration)
1507 {
1508 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1509
1510 player.__filemanagerDurationFallback = true;
1511 player.duration = function durationWithFallback (...args)
1512 {
1513 if (args.length) return originalDuration(...args);
1514 const current = Number(originalDuration());
1515 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1516 };
1517 }
1518
1519 function normaliseVideoDuration (player, durationSeconds)
1520 {
1521 const duration = Number(durationSeconds);
1522 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1523
1524 let originalDuration = null;
1525 let durationWasChanged = false;
1526 try
1527 {
1528 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1529 installDurationFallback(player, originalDuration, duration);
1530 if (player.__filemanagerDurationApplied) return;
1531
1532 const current = originalDuration ? Number(originalDuration()) : NaN;
1533 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1534 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1535 if (withinTolerance)
1536 {
1537 player.__filemanagerDurationApplied = true;
1538 return;
1539 }
1540
1541 if (originalDuration)
1542 {
1543 durationWasChanged = true;
1544 originalDuration(duration);
1545 }
1546 } catch
1547 {
1548 // Ignore players that do not support setting duration.
1549 }
1550
1551 try
1552 {
1553 const updated = originalDuration ? Number(originalDuration()) : NaN;
1554 if (Number.isFinite(updated) && updated >= duration * 0.95)
1555 {
1556 player.__filemanagerDurationApplied = true;
1557 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1558 return;
1559 }
1560
1561 player.__filemanagerDurationApplied = true;
1562 if (typeof player.trigger === 'function') player.trigger('durationchange');
1563 } catch
1564 {
1565 // Ignore duration fallback failures.
1566 }
1567 }
1568
1569 function ensureVideoPlaybackUi (player, durationSeconds)
1570 {
1571 if (!player || typeof player.on !== 'function') return;
1572
1573 const forceVodUi = () =>
1574 {
1575 normaliseVideoDuration(player, durationSeconds);
1576
1577 try
1578 {
1579 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1580 {
1581 player.liveTracker.stopTracking();
1582 }
1583 } catch
1584 {
1585 // Ignore live tracker availability issues.
1586 }
1587
1588 try
1589 {
1590 if (typeof player.removeClass === 'function')
1591 {
1592 player.removeClass('vjs-live');
1593 }
1594 } catch
1595 {
1596 // Ignore class update failures.
1597 }
1598
1599 try
1600 {
1601 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1602 if (display) display.style.display = 'none';
1603 } catch
1604 {
1605 // Ignore missing DOM.
1606 }
1607 };
1608
1609 player.ready(forceVodUi);
1610 player.on('loadedmetadata', forceVodUi);
1611 player.on('durationchange', forceVodUi);
1612 player.on('loadedplaylist', forceVodUi);
1613 }
1614
1615 function configureVideoJsBuffering (videojs, opts = {})
1616 {
1617 if (opts.enabled === false) return;
1618 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1619 videojs.__filemanagerBufferingConfigured = true;
1620
1621 const seconds = Number(opts.seconds);
1622 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1623
1624 try
1625 {
1626 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1627 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1628 videojs.Vhs.BUFFER_LOW_WATER_LINE = Math.max(30, Math.floor(bufferSeconds / 2));
1629 videojs.Vhs.MAX_BUFFER_LOW_WATER_LINE = bufferSeconds;
1630 } catch
1631 {
1632 // Ignore builds that do not expose VHS buffer configuration.
1633 }
1634 }
1635
1636 function enableVideoStreamClientCache ()
1637 {
1638 if (typeof navigator === 'undefined' || !navigator.serviceWorker || typeof navigator.serviceWorker.register !== 'function')
1639 {
1640 return Promise.resolve(false);
1641 }
1642
1643 if (window.__filemanagerVideoStreamCacheSwPromise)
1644 {
1645 return window.__filemanagerVideoStreamCacheSwPromise;
1646 }
1647
1648 window.__filemanagerVideoStreamCacheSwPromise = navigator.serviceWorker.register(VIDEO_STREAM_CACHE_SW_URL, {
1649 scope: '/',
1650 updateViaCache: 'none',
1651 }).then(() => true).catch(() => false);
1652
1653 return window.__filemanagerVideoStreamCacheSwPromise;
1654 }
1655
1656 function videoStreamCachePrefixFromPlaylistUrl (playlistUrl)
1657 {
1658 const raw = String(playlistUrl || '').trim();
1659 if (!raw) return null;
1660
1661 let parsed = null;
1662 try
1663 {
1664 parsed = new URL(raw, window.location.origin);
1665 } catch
1666 {
1667 return null;
1668 }
1669
1670 const pathname = String(parsed.pathname || '');
1671 if (!pathname) return null;
1672 const lastSlashIndex = pathname.lastIndexOf('/');
1673 const basePath = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '/';
1674 return `${parsed.origin}${basePath}`;
1675 }
1676
1677 function clearVideoStreamClientCache (playlistUrl)
1678 {
1679 const prefix = videoStreamCachePrefixFromPlaylistUrl(playlistUrl);
1680 if (!prefix || typeof caches === 'undefined' || typeof caches.open !== 'function')
1681 {
1682 return Promise.resolve();
1683 }
1684
1685 return caches.open(VIDEO_STREAM_CACHE_NAME).then(async (cache) =>
1686 {
1687 const requests = await cache.keys();
1688 const deletions = [];
1689 for (const request of requests)
1690 {
1691 const requestUrl = request && request.url ? String(request.url) : '';
1692 if (!requestUrl.startsWith(prefix)) continue;
1693 deletions.push(cache.delete(request));
1694 }
1695 await Promise.all(deletions);
1696 }).catch(() =>
1697 {
1698 // Keep cache cleanup best-effort only.
1699 });
1700 }
1701
1702 function parseHlsManifest (manifestText)
1703 {
1704 const lines = String(manifestText || '').split(/\r?\n/);
1705 const childPlaylists = [];
1706 const mediaAssets = [];
1707 const mediaSegmentUris = [];
1708 const mediaSegments = [];
1709 let expectPlaylistUri = false;
1710 let segmentCursorSeconds = 0;
1711 let pendingSegmentDurationSeconds = null;
1712
1713 for (const rawLine of lines)
1714 {
1715 const line = String(rawLine || '').trim();
1716 if (!line) continue;
1717
1718 if (line.startsWith('#'))
1719 {
1720 if (/^#EXT-X-STREAM-INF/i.test(line))
1721 {
1722 expectPlaylistUri = true;
1723 continue;
1724 }
1725
1726 const segmentDurationMatch = line.match(/^#EXTINF\s*:\s*([0-9]+(?:\.[0-9]+)?)/i);
1727 if (segmentDurationMatch)
1728 {
1729 const parsed = Number.parseFloat(segmentDurationMatch[1]);
1730 pendingSegmentDurationSeconds = Number.isFinite(parsed) && parsed > 0
1731 ? parsed
1732 : VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1733 continue;
1734 }
1735
1736 const mapMatch = line.match(/^#EXT-X-MAP\s*:\s*.*?URI="([^"]+)"/i);
1737 if (mapMatch && mapMatch[1]) mediaAssets.push(mapMatch[1]);
1738 continue;
1739 }
1740
1741 if (expectPlaylistUri || /\.m3u8(?:$|\?)/i.test(line))
1742 {
1743 childPlaylists.push(line);
1744 expectPlaylistUri = false;
1745 } else
1746 {
1747 mediaAssets.push(line);
1748 mediaSegmentUris.push(line);
1749 if (Number.isFinite(pendingSegmentDurationSeconds) && pendingSegmentDurationSeconds > 0)
1750 {
1751 const startTimeSeconds = segmentCursorSeconds;
1752 segmentCursorSeconds += pendingSegmentDurationSeconds;
1753 mediaSegments.push({
1754 uri: line,
1755 startTimeSeconds,
1756 endTimeSeconds: segmentCursorSeconds,
1757 });
1758 }
1759 pendingSegmentDurationSeconds = null;
1760 }
1761 }
1762
1763 return {
1764 childPlaylists,
1765 mediaAssets,
1766 mediaSegmentUris,
1767 mediaSegments,
1768 endList: /#EXT-X-ENDLIST/i.test(String(manifestText || '')),
1769 };
1770 }
1771
1772 function inferSegmentEndSecondsFromAssetUrl (assetUrl)
1773 {
1774 const value = String(assetUrl || '');
1775 if (!value) return null;
1776
1777 let pathname = value;
1778 try
1779 {
1780 pathname = new URL(value, window.location.href).pathname || value;
1781 } catch
1782 {
1783 // Ignore URL parsing failures and fall back to raw value matching.
1784 }
1785
1786 const match = pathname.match(/_segment_(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i)
1787 || pathname.match(/(?:^|[/._-])seg(?:ment)?[_-]?(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i);
1788 if (!match) return null;
1789
1790 const segmentIndex = Number.parseInt(match[1], 10);
1791 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return null;
1792 return (segmentIndex + 1) * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1793 }
1794
1795 function bindStreamAheadSeekMarker (player, streamAheadPrefetch, opts = {})
1796 {
1797 if (!player || typeof player.on !== 'function' || !streamAheadPrefetch) return null;
1798
1799 const markerChar = String(opts.markerChar || ':').slice(0, 1) || ':';
1800 const markerColor = String(opts.markerColor || '#d6d6d6');
1801 const showTimeTooltip = opts.showTimeTooltip === true;
1802 let markerEl = null;
1803 let markerContainerEl = null;
1804 let cachedThroughSeconds = null;
1805 let cachedThroughRatio = null;
1806 let detachProgressListener = null;
1807
1808 const currentDuration = () =>
1809 {
1810 const duration = Number(player.duration && player.duration());
1811 return Number.isFinite(duration) && duration > 0 ? duration : null;
1812 };
1813
1814 const updateMarker = () =>
1815 {
1816 if (!markerEl) return;
1817
1818 const duration = currentDuration();
1819 if (!duration || !Number.isFinite(cachedThroughSeconds) || cachedThroughSeconds < 0)
1820 {
1821 markerEl.style.display = 'none';
1822 return;
1823 }
1824
1825 const ratioFromSeconds = Number.isFinite(cachedThroughSeconds)
1826 ? Math.max(0, Math.min(1, cachedThroughSeconds / duration))
1827 : null;
1828 const ratioFromSections = Number.isFinite(cachedThroughRatio)
1829 ? Math.max(0, Math.min(1, cachedThroughRatio))
1830 : null;
1831 const ratio = Number.isFinite(ratioFromSeconds)
1832 ? ratioFromSeconds
1833 : ratioFromSections;
1834 if (!Number.isFinite(ratio) || ratio <= 0)
1835 {
1836 markerEl.style.display = 'none';
1837 return;
1838 }
1839
1840 markerEl.style.display = 'block';
1841 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
1842 if (showTimeTooltip)
1843 {
1844 if (Number.isFinite(cachedThroughSeconds))
1845 {
1846 markerEl.title = `Walker cached through ${formatClockTime(cachedThroughSeconds)}`;
1847 } else if (Number.isFinite(cachedThroughRatio))
1848 {
1849 markerEl.title = `Walker cached through ${Math.round(cachedThroughRatio * 100)}%`;
1850 } else
1851 {
1852 markerEl.title = 'Walker cached through';
1853 }
1854 } else
1855 {
1856 markerEl.removeAttribute('title');
1857 }
1858 };
1859
1860 const ensureMarker = () =>
1861 {
1862 if (markerContainerEl && markerContainerEl.isConnected)
1863 {
1864 updateMarker();
1865 return;
1866 }
1867
1868 const playerEl = player.el && player.el();
1869 if (!playerEl) return;
1870
1871 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
1872 || playerEl.querySelector('.vjs-progress-holder')
1873 || playerEl.querySelector('.vjs-progress-control');
1874 if (!seekBarEl) return;
1875
1876 const computedPosition = window.getComputedStyle(seekBarEl).position;
1877 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
1878
1879 markerContainerEl = document.createElement('div');
1880 markerContainerEl.className = 'vjs-stream-ahead-cache-marker-container';
1881 markerContainerEl.style.position = 'absolute';
1882 markerContainerEl.style.left = '0';
1883 markerContainerEl.style.right = '0';
1884 markerContainerEl.style.top = '50%';
1885 markerContainerEl.style.height = '10px';
1886 markerContainerEl.style.transform = 'translateY(-50%)';
1887 markerContainerEl.style.pointerEvents = 'none';
1888 markerContainerEl.style.zIndex = '4';
1889
1890 markerEl = document.createElement('span');
1891 markerEl.className = 'vjs-stream-ahead-cache-marker';
1892 markerEl.style.position = 'absolute';
1893 markerEl.style.top = '50%';
1894 markerEl.style.width = '10px';
1895 markerEl.style.height = '10px';
1896 markerEl.style.transform = 'translate(-50%, -50%)';
1897 markerEl.style.color = markerColor;
1898 markerEl.style.fontFamily = 'monospace';
1899 markerEl.style.fontSize = '12px';
1900 markerEl.style.fontWeight = '700';
1901 markerEl.style.lineHeight = '10px';
1902 markerEl.style.textAlign = 'center';
1903 markerEl.style.display = 'none';
1904 markerEl.style.textShadow = '0 0 2px rgba(0, 0, 0, 0.65)';
1905 markerEl.textContent = markerChar;
1906 markerEl.setAttribute('aria-hidden', 'true');
1907 if (showTimeTooltip)
1908 {
1909 markerEl.title = 'Walker cached through 00:00';
1910 }
1911
1912 markerContainerEl.appendChild(markerEl);
1913 seekBarEl.appendChild(markerContainerEl);
1914 updateMarker();
1915 };
1916
1917 const onDurationHint = () =>
1918 {
1919 ensureMarker();
1920 updateMarker();
1921 };
1922
1923 player.on('loadedmetadata', onDurationHint);
1924 player.on('durationchange', onDurationHint);
1925 player.on('loadedplaylist', onDurationHint);
1926 player.ready(onDurationHint);
1927
1928 if (typeof streamAheadPrefetch.subscribe === 'function')
1929 {
1930 detachProgressListener = streamAheadPrefetch.subscribe((status) =>
1931 {
1932 const nextCachedThrough = status && Number.isFinite(Number(status.cachedThroughSeconds))
1933 ? Number(status.cachedThroughSeconds)
1934 : null;
1935 cachedThroughSeconds = nextCachedThrough;
1936 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
1937 ? Number(status.cachedThroughRatio)
1938 : null;
1939 ensureMarker();
1940 updateMarker();
1941 });
1942 } else if (typeof streamAheadPrefetch.getStatus === 'function')
1943 {
1944 const status = streamAheadPrefetch.getStatus();
1945 cachedThroughSeconds = status && Number.isFinite(Number(status.cachedThroughSeconds))
1946 ? Number(status.cachedThroughSeconds)
1947 : null;
1948 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
1949 ? Number(status.cachedThroughRatio)
1950 : null;
1951 ensureMarker();
1952 updateMarker();
1953 }
1954
1955 return {
1956 detach: () =>
1957 {
1958 if (typeof detachProgressListener === 'function')
1959 {
1960 try { detachProgressListener(); } catch { /* ignore detach races */ }
1961 detachProgressListener = null;
1962 }
1963
1964 if (markerContainerEl && markerContainerEl.parentNode)
1965 {
1966 markerContainerEl.parentNode.removeChild(markerContainerEl);
1967 }
1968 markerContainerEl = null;
1969 markerEl = null;
1970 },
1971 };
1972 }
1973
1974 function bindStreamAheadPrefetch (opts = {})
1975 {
1976 const basePlaylistUrl = String(opts.playlistUrl || '').trim();
1977 if (!basePlaylistUrl) return null;
1978
1979 const pollIntervalMsRaw = Number(opts.pollIntervalMs);
1980 const pollIntervalMs = Number.isFinite(pollIntervalMsRaw) && pollIntervalMsRaw >= 0
1981 ? pollIntervalMsRaw
1982 : VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT;
1983 const headers = opts.headers;
1984 const credentials = opts.credentials;
1985
1986 const playlistStatusByUrl = new Map();
1987 const knownPlaylistUrls = new Set([basePlaylistUrl]);
1988 const fetchedAssetUrls = new Set();
1989 const segmentEndSecondsByAssetUrl = new Map();
1990 const discoveredSegmentUrls = new Set();
1991 const fetchedSegmentUrls = new Set();
1992 const progressListeners = new Set();
1993 const controller = typeof AbortController === 'function' ? new AbortController() : null;
1994 let stopped = false;
1995 let cachedThroughSeconds = null;
1996 let cachedThroughRatio = null;
1997 let fetchedTimelineAssetCount = 0;
1998
1999 const recalculateSegmentRatio = () =>
2000 {
2001 const totalSegments = discoveredSegmentUrls.size;
2002 if (totalSegments <= 0)
2003 {
2004 cachedThroughRatio = null;
2005 return;
2006 }
2007 cachedThroughRatio = Math.max(0, Math.min(1, fetchedSegmentUrls.size / totalSegments));
2008 };
2009
2010 const resolveUrl = (value, parentUrl) =>
2011 {
2012 try
2013 {
2014 return new URL(String(value || '').trim(), parentUrl || window.location.href).toString();
2015 } catch
2016 {
2017 return null;
2018 }
2019 };
2020
2021 const wait = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
2022
2023 const fetchText = async (url) =>
2024 {
2025 const res = await fetch(url, {
2026 method: 'GET',
2027 headers,
2028 credentials,
2029 cache: 'no-store',
2030 signal: controller ? controller.signal : undefined,
2031 });
2032 if (!res || !res.ok) return null;
2033 return res.text();
2034 };
2035
2036 const fetchAsset = async (url) =>
2037 {
2038 const res = await fetch(url, {
2039 method: 'GET',
2040 headers,
2041 credentials,
2042 signal: controller ? controller.signal : undefined,
2043 });
2044 if (!res || !res.ok) return false;
2045 // Ensure body fully reads so browser/service-worker caches the asset bytes.
2046 await res.arrayBuffer();
2047 return true;
2048 };
2049
2050 const getStatus = () => ({
2051 cachedThroughSeconds,
2052 cachedThroughRatio,
2053 knownPlaylistCount: knownPlaylistUrls.size,
2054 fetchedAssetCount: fetchedAssetUrls.size,
2055 fetchedTimelineAssetCount,
2056 totalSegmentCount: discoveredSegmentUrls.size,
2057 fetchedSegmentCount: fetchedSegmentUrls.size,
2058 allPlaylistsComplete: Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true),
2059 stopped,
2060 });
2061
2062 const appearsTimelineAsset = (assetUrl) =>
2063 /(?:\.ts|\.m4s|\.mp4|\.aac|\.m4a)(?:$|\?)/i.test(String(assetUrl || ''));
2064
2065 const emitProgress = () =>
2066 {
2067 const status = getStatus();
2068 for (const listener of Array.from(progressListeners))
2069 {
2070 try
2071 {
2072 listener(status);
2073 } catch
2074 {
2075 // Keep progress listeners best-effort only.
2076 }
2077 }
2078 };
2079
2080 const workerPromise = (async () =>
2081 {
2082 while (!stopped)
2083 {
2084 const nextAssetUrlSet = new Set();
2085
2086 for (const playlistUrl of Array.from(knownPlaylistUrls))
2087 {
2088 if (stopped) return;
2089 const manifestText = await fetchText(playlistUrl).catch(() => null);
2090 if (!manifestText) continue;
2091
2092 const parsed = parseHlsManifest(manifestText);
2093 playlistStatusByUrl.set(playlistUrl, !!parsed.endList);
2094
2095 for (const child of parsed.childPlaylists)
2096 {
2097 const resolved = resolveUrl(child, playlistUrl);
2098 if (!resolved) continue;
2099 knownPlaylistUrls.add(resolved);
2100 if (!playlistStatusByUrl.has(resolved)) playlistStatusByUrl.set(resolved, false);
2101 }
2102
2103 for (const asset of parsed.mediaAssets)
2104 {
2105 const resolved = resolveUrl(asset, playlistUrl);
2106 if (!resolved || fetchedAssetUrls.has(resolved)) continue;
2107 nextAssetUrlSet.add(resolved);
2108 }
2109
2110 for (const segment of parsed.mediaSegments)
2111 {
2112 if (!segment || !segment.uri) continue;
2113 const resolved = resolveUrl(segment.uri, playlistUrl);
2114 if (!resolved) continue;
2115 if (!Number.isFinite(segment.endTimeSeconds) || segment.endTimeSeconds < 0) continue;
2116 segmentEndSecondsByAssetUrl.set(resolved, Number(segment.endTimeSeconds));
2117 }
2118
2119 for (const segmentUri of parsed.mediaSegmentUris)
2120 {
2121 const resolved = resolveUrl(segmentUri, playlistUrl);
2122 if (!resolved) continue;
2123 discoveredSegmentUrls.add(resolved);
2124 }
2125 }
2126
2127 recalculateSegmentRatio();
2128 emitProgress();
2129
2130 const nextAssetUrls = Array.from(nextAssetUrlSet);
2131 for (const assetUrl of nextAssetUrls)
2132 {
2133 if (stopped) return;
2134 const fetched = await fetchAsset(assetUrl).catch(() => false);
2135 if (!fetched) continue;
2136
2137 fetchedAssetUrls.add(assetUrl);
2138 if (discoveredSegmentUrls.has(assetUrl))
2139 {
2140 fetchedSegmentUrls.add(assetUrl);
2141 }
2142 const mappedSegmentEndSeconds = segmentEndSecondsByAssetUrl.get(assetUrl);
2143 const inferredSegmentEndSeconds = inferSegmentEndSecondsFromAssetUrl(assetUrl);
2144 let fallbackSegmentEndSeconds = null;
2145 if (!Number.isFinite(mappedSegmentEndSeconds) && !Number.isFinite(inferredSegmentEndSeconds) && appearsTimelineAsset(assetUrl))
2146 {
2147 fetchedTimelineAssetCount += 1;
2148 fallbackSegmentEndSeconds = fetchedTimelineAssetCount * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2149 }
2150
2151 const segmentEndSeconds = [mappedSegmentEndSeconds, inferredSegmentEndSeconds, fallbackSegmentEndSeconds]
2152 .filter((value) => Number.isFinite(value))
2153 .reduce((maxValue, value) => (value > maxValue ? value : maxValue), -1);
2154
2155 if (Number.isFinite(segmentEndSeconds))
2156 {
2157 if (!Number.isFinite(cachedThroughSeconds) || segmentEndSeconds > cachedThroughSeconds)
2158 {
2159 cachedThroughSeconds = segmentEndSeconds;
2160 }
2161 }
2162
2163 recalculateSegmentRatio();
2164 emitProgress();
2165 }
2166
2167 const allPlaylistsComplete = Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true);
2168 if (allPlaylistsComplete && !nextAssetUrls.length)
2169 {
2170 emitProgress();
2171 return;
2172 }
2173
2174 if (pollIntervalMs > 0)
2175 {
2176 await wait(pollIntervalMs);
2177 }
2178 }
2179 })();
2180
2181 return {
2182 stop: () =>
2183 {
2184 stopped = true;
2185 if (controller && typeof controller.abort === 'function')
2186 {
2187 try { controller.abort(); } catch { /* ignore abort races */ }
2188 }
2189 emitProgress();
2190 },
2191 done: () => workerPromise,
2192 getStatus,
2193 subscribe: (listener) =>
2194 {
2195 if (typeof listener !== 'function') return () => { };
2196 progressListeners.add(listener);
2197 try { listener(getStatus()); } catch { /* ignore listener failures */ }
2198 return () =>
2199 {
2200 progressListeners.delete(listener);
2201 };
2202 },
2203 };
2204 }
2205
2206 function applyDefaultTextTrackPrefs ()
2207 {
2208 try
2209 {
2210 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
2211 } catch
2212 {
2213 // Ignore localStorage failures.
2214 }
2215 }
2216
2217 window.FilemanagerSharedVideoPlayer = {
2218 applyDefaultTextTrackPrefs,
2219 bindImageSubtitleOverlay,
2220 bindStreamAheadPrefetch,
2221 bindStreamAheadSeekMarker,
2222 bindTrackPrefs,
2223 clearVideoStreamClientCache,
2224 configureVideoJsBuffering,
2225 enableVideoStreamClientCache,
2226 ensureVideoPlaybackUi,
2227 normaliseVideoDuration,
2228 };
2229}());