BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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