BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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