BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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