BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

0ecdfa02 History
shared-video-player.js 77.2 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, allowCurrentFetchOverride = false, preservePrefetchState = 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 && !allowCurrentFetchOverride)
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 does not reset prefetch state,
1148 // so background subtitle lead can continue growing while playing.
1149 return refreshFrame(true, true, true);
1150 }
1151 queueLookaheadPrefetch(currentTime, {
1152 reset: force,
1153 includeCurrentTime: true,
1154 });
1155 return;
1156 }
1157
1158 const refreshLifecycleToken = lifecycleToken;
1159 if (force && currentFramePromise)
1160 {
1161 cancelCurrentFrameRequest();
1162 }
1163 if (currentFramePromise)
1164 {
1165 queuedCurrentRefresh = true;
1166 queuedCurrentRefreshForce = queuedCurrentRefreshForce || !!force;
1167 return;
1168 }
1169 cancelCurrentFrameRequest();
1170 if (force && !preservePrefetchState) cancelPrefetchRequests({ resetProgress: true });
1171
1172 const token = ++currentFrameToken;
1173 const requestId = `current-${token}`;
1174 const requestStartedAtMs = Date.now();
1175 const controller = createAbortController();
1176 currentFrameAbortController = controller;
1177 const request = buildFrameRequest({
1178 streamIndex: selectedStreamIndex,
1179 currentTime,
1180 session,
1181 });
1182
1183 if (!request || !request.url)
1184 {
1185 disableTrack();
1186 return;
1187 }
1188
1189 logSubtitleEvent('subtitle_png_requested', {
1190 requestId,
1191 requestKind: 'current',
1192 requestUrl: String(request.url || ''),
1193 requestedAtMs: requestStartedAtMs,
1194 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1195 });
1196
1197 const frameRequestPromise = (async () =>
1198 {
1199 let currentTimedOut = false;
1200 const timeoutId = armRequestTimeout(controller, currentRequestTimeoutMs, () =>
1201 {
1202 currentTimedOut = true;
1203 });
1204 try
1205 {
1206 const res = await fetch(request.url, {
1207 method: request.method || 'GET',
1208 headers: request.headers,
1209 credentials: request.credentials,
1210 signal: controller ? controller.signal : undefined,
1211 });
1212 clearRequestTimeout(timeoutId);
1213
1214 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1215
1216 const responseMeta = {
1217 requestId,
1218 requestKind: 'current',
1219 status: res.status,
1220 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1221 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1222 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1223 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1224 responseHeadersReceivedAtMs: Date.now(),
1225 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1226 };
1227 logSubtitleEvent('subtitle_png_sent', {
1228 ...responseMeta,
1229 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1230 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1231 });
1232
1233 setSeekMarkerTime('requested', currentTime);
1234 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1235 ? responseMeta.shouldShowAtVideoTimeSeconds
1236 : currentTime;
1237 setSeekMarkerTime('received', receivedMarkerTime);
1238 updateSeekBarMarkers();
1239
1240 if (res.status === 204)
1241 {
1242 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1243 logSubtitleEvent('subtitle_png_not_available', {
1244 ...responseMeta,
1245 frameStatus,
1246 });
1247 hideOverlay();
1248 if (frameStatus === 'error') disableTrack();
1249 else queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1250 return;
1251 }
1252
1253 if (!res.ok)
1254 {
1255 disableTrack();
1256 return;
1257 }
1258
1259 const blob = await res.blob();
1260 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1261
1262 const receivedAtMs = Date.now();
1263 logSubtitleEvent('subtitle_png_received', {
1264 ...responseMeta,
1265 receivedAtMs,
1266 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1267 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
1268 blobBytes: Number(blob && blob.size || 0),
1269 });
1270
1271 if (!blob || blob.size === 0)
1272 {
1273 disableTrack();
1274 return;
1275 }
1276 const cachedFrameEntry = cacheSubtitleFrame({
1277 streamIndex: selectedStreamIndex,
1278 blob,
1279 metadata: parseFrameMetadata(res, currentTime),
1280 });
1281 if (cachedFrameEntry) renderSubtitleFrame(cachedFrameEntry);
1282
1283 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
1284 {
1285 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1286 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
1287 logSubtitleEvent('subtitle_png_shown', {
1288 ...responseMeta,
1289 receivedAtMs,
1290 shownAtMs,
1291 shownAtVideoTimeSeconds,
1292 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1293 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
1294 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
1295 });
1296 });
1297
1298 queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1299 } catch (error)
1300 {
1301 clearRequestTimeout(timeoutId);
1302 if (currentTimedOut)
1303 {
1304 logSubtitleEvent('subtitle_png_request_failed', {
1305 requestId,
1306 requestKind: 'current',
1307 requestedAtMs: requestStartedAtMs,
1308 errorName: 'AbortError',
1309 errorMessage: `Current subtitle request timed out after ${Math.round(currentRequestTimeoutMs)}ms`,
1310 });
1311 return;
1312 }
1313 if (isAbortError(error)) return;
1314 logSubtitleEvent('subtitle_png_request_failed', {
1315 requestId,
1316 requestKind: 'current',
1317 requestedAtMs: requestStartedAtMs,
1318 errorName: error && error.name ? String(error.name) : null,
1319 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1320 });
1321 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
1322 }
1323 })();
1324
1325 currentFramePromise = frameRequestPromise;
1326 frameRequestPromise.finally(() =>
1327 {
1328 if (currentFramePromise !== frameRequestPromise) return;
1329 currentFrameAbortController = null;
1330 currentFramePromise = null;
1331 if (!queuedCurrentRefresh) return;
1332
1333 const queuedForce = queuedCurrentRefreshForce;
1334 queuedCurrentRefresh = false;
1335 queuedCurrentRefreshForce = false;
1336 void refreshFrame(queuedForce);
1337 });
1338
1339 return currentFramePromise;
1340 };
1341
1342 const dispose = () =>
1343 {
1344 resetRequestState();
1345 flushSubtitleLogs();
1346 closeMenu();
1347 hideOverlay();
1348 if (seekMarkerContainerEl) seekMarkerContainerEl.remove();
1349 seekMarkerContainerEl = null;
1350 seekMarkerRequestedEl = null;
1351 seekMarkerReceivedEl = null;
1352 revokeCachedFrameUrls();
1353 if (overlayEl) overlayEl.remove();
1354 if (menuEl) menuEl.remove();
1355 player.imageSubtitleOverlayController = null;
1356 buttonEl = null;
1357 };
1358
1359 overlayEl = document.createElement('div');
1360 overlayEl.className = 'video-subtitle-overlay';
1361 overlayEl.style.position = 'absolute';
1362 overlayEl.style.left = '0';
1363 overlayEl.style.right = '0';
1364 overlayEl.style.bottom = '3rem';
1365 overlayEl.style.display = 'none';
1366 overlayEl.style.zIndex = '3';
1367 overlayEl.style.pointerEvents = 'none';
1368 overlayEl.style.textAlign = 'center';
1369 overlayEl.style.padding = '0 0.75rem';
1370 overlayEl.style.maxHeight = '70%';
1371 overlayEl.style.overflow = 'hidden';
1372
1373 overlayImgEl = document.createElement('img');
1374 overlayImgEl.alt = 'Image subtitles';
1375 overlayImgEl.style.display = 'none';
1376 overlayImgEl.style.margin = '0 auto';
1377 overlayImgEl.style.objectFit = 'contain';
1378 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1379 overlayImgEl.style.maxWidth = '100%';
1380 overlayImgEl.style.height = 'auto';
1381 overlayEl.appendChild(overlayImgEl);
1382
1383 menuEl = document.createElement('div');
1384 menuEl.className = 'video-subtitle-overlay-menu';
1385 menuEl.style.position = 'absolute';
1386 menuEl.style.right = '0.75rem';
1387 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
1388 menuEl.style.minWidth = '14rem';
1389 menuEl.style.maxWidth = '20rem';
1390 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
1391 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
1392 menuEl.style.borderRadius = '0.5rem';
1393 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
1394 menuEl.style.padding = '0.35rem';
1395 menuEl.style.display = 'none';
1396 menuEl.style.zIndex = '4';
1397
1398 const buildMenuItem = (label, streamIndex, isSelected) =>
1399 {
1400 const itemEl = document.createElement('button');
1401 itemEl.type = 'button';
1402 itemEl.className = 'video-subtitle-overlay-menu-item';
1403 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
1404 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1405 itemEl.style.display = 'block';
1406 itemEl.style.width = '100%';
1407 itemEl.style.margin = '0';
1408 itemEl.style.padding = '0.5rem 0.75rem';
1409 itemEl.style.border = '0';
1410 itemEl.style.borderRadius = '0.35rem';
1411 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
1412 itemEl.style.color = '#fff';
1413 itemEl.style.textAlign = 'left';
1414 itemEl.style.cursor = 'pointer';
1415 itemEl.textContent = label;
1416 itemEl.addEventListener('click', () =>
1417 {
1418 setSelectedStreamIndex(streamIndex);
1419 closeMenu();
1420 });
1421 return itemEl;
1422 };
1423
1424 menuEl.appendChild(buildMenuItem('Off', null, false));
1425 for (const track of imageTracks)
1426 {
1427 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
1428 }
1429
1430 const registerButton = () =>
1431 {
1432 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
1433 if (videojs.getComponent('ImageSubtitleButton')) return;
1434
1435 const Button = videojs.getComponent('Button');
1436 class ImageSubtitleButton extends Button
1437 {
1438 buildCSSClass ()
1439 {
1440 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
1441 }
1442
1443 createEl ()
1444 {
1445 const el = super.createEl();
1446 el.type = 'button';
1447 el.setAttribute('title', 'Image subtitles');
1448 el.setAttribute('aria-label', 'Image subtitles');
1449 el.innerHTML = '<span aria-hidden="true">IM</span>';
1450 return el;
1451 }
1452
1453 handleClick ()
1454 {
1455 const controller = this.player().imageSubtitleOverlayController;
1456 if (controller) controller.toggleMenu();
1457 }
1458 }
1459
1460 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
1461 };
1462
1463 const attachUi = () =>
1464 {
1465 if (!player.el()) return;
1466 registerButton();
1467 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
1468 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
1469 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
1470 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
1471 {
1472 const button = controlBar.addChild('ImageSubtitleButton', {});
1473 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
1474 updateButtonState();
1475 }
1476 };
1477
1478 const applySavedTracks = () =>
1479 {
1480 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
1481 if (savedName)
1482 {
1483 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
1484 if (savedByName)
1485 {
1486 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
1487 return;
1488 }
1489 }
1490
1491 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
1492 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
1493 {
1494 setSelectedStreamIndex(savedIndex, { persist: false });
1495 return;
1496 }
1497
1498 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
1499 if (defaultTrack)
1500 {
1501 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
1502 return;
1503 }
1504
1505 setSelectedStreamIndex(null, { persist: false });
1506 };
1507
1508 player.imageSubtitleOverlayController = {
1509 toggleMenu,
1510 closeMenu,
1511 applySavedTracks,
1512 captureSelectedTracks: saveSelection,
1513 detach: dispose,
1514 };
1515
1516 player.on('timeupdate', () => { void refreshFrame(); });
1517 player.on('seeking', () => { void refreshFrame(true); });
1518 player.on('play', () => { void refreshFrame(true); });
1519 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
1520 player.on('dispose', dispose);
1521 player.ready(() =>
1522 {
1523 attachUi();
1524 ensureSeekBarMarkers();
1525 updateMenuState();
1526 updateButtonState();
1527 updateSeekBarMarkers();
1528 applySavedTracks();
1529 if (menuOpen) openMenu();
1530 });
1531
1532 player.on('durationchange', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1533 player.on('loadedmetadata', () => { ensureSeekBarMarkers(); updateSeekBarMarkers(); });
1534
1535 return player.imageSubtitleOverlayController;
1536 }
1537
1538 function formatDurationForDebug (seconds)
1539 {
1540 const value = Number(seconds);
1541 if (!Number.isFinite(value) || value < 0) return 'unknown';
1542
1543 const totalSeconds = Math.floor(value);
1544 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1545 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1546 const ss = String(totalSeconds % 60).padStart(2, '0');
1547 return `${hh}:${mm}:${ss}`;
1548 }
1549
1550 function installDurationFallback (player, originalDuration, duration)
1551 {
1552 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1553
1554 player.__filemanagerDurationFallback = true;
1555 player.duration = function durationWithFallback (...args)
1556 {
1557 if (args.length) return originalDuration(...args);
1558 const current = Number(originalDuration());
1559 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1560 };
1561 }
1562
1563 function normaliseVideoDuration (player, durationSeconds)
1564 {
1565 const duration = Number(durationSeconds);
1566 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1567
1568 let originalDuration = null;
1569 let durationWasChanged = false;
1570 try
1571 {
1572 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1573 installDurationFallback(player, originalDuration, duration);
1574 if (player.__filemanagerDurationApplied) return;
1575
1576 const current = originalDuration ? Number(originalDuration()) : NaN;
1577 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1578 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1579 if (withinTolerance)
1580 {
1581 player.__filemanagerDurationApplied = true;
1582 return;
1583 }
1584
1585 if (originalDuration)
1586 {
1587 durationWasChanged = true;
1588 originalDuration(duration);
1589 }
1590 } catch
1591 {
1592 // Ignore players that do not support setting duration.
1593 }
1594
1595 try
1596 {
1597 const updated = originalDuration ? Number(originalDuration()) : NaN;
1598 if (Number.isFinite(updated) && updated >= duration * 0.95)
1599 {
1600 player.__filemanagerDurationApplied = true;
1601 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1602 return;
1603 }
1604
1605 player.__filemanagerDurationApplied = true;
1606 if (typeof player.trigger === 'function') player.trigger('durationchange');
1607 } catch
1608 {
1609 // Ignore duration fallback failures.
1610 }
1611 }
1612
1613 function ensureVideoPlaybackUi (player, durationSeconds)
1614 {
1615 if (!player || typeof player.on !== 'function') return;
1616
1617 const forceVodUi = () =>
1618 {
1619 normaliseVideoDuration(player, durationSeconds);
1620
1621 try
1622 {
1623 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1624 {
1625 player.liveTracker.stopTracking();
1626 }
1627 } catch
1628 {
1629 // Ignore live tracker availability issues.
1630 }
1631
1632 try
1633 {
1634 if (typeof player.removeClass === 'function')
1635 {
1636 player.removeClass('vjs-live');
1637 }
1638 } catch
1639 {
1640 // Ignore class update failures.
1641 }
1642
1643 try
1644 {
1645 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1646 if (display) display.style.display = 'none';
1647 } catch
1648 {
1649 // Ignore missing DOM.
1650 }
1651 };
1652
1653 player.ready(forceVodUi);
1654 player.on('loadedmetadata', forceVodUi);
1655 player.on('durationchange', forceVodUi);
1656 player.on('loadedplaylist', forceVodUi);
1657 }
1658
1659 function configureVideoJsBuffering (videojs, opts = {})
1660 {
1661 if (opts.enabled === false) return;
1662 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1663 videojs.__filemanagerBufferingConfigured = true;
1664
1665 const seconds = Number(opts.seconds);
1666 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1667
1668 try
1669 {
1670 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1671 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1672 videojs.Vhs.BUFFER_LOW_WATER_LINE = Math.max(30, Math.floor(bufferSeconds / 2));
1673 videojs.Vhs.MAX_BUFFER_LOW_WATER_LINE = bufferSeconds;
1674 } catch
1675 {
1676 // Ignore builds that do not expose VHS buffer configuration.
1677 }
1678 }
1679
1680 function enableVideoStreamClientCache ()
1681 {
1682 if (typeof navigator === 'undefined' || !navigator.serviceWorker || typeof navigator.serviceWorker.register !== 'function')
1683 {
1684 return Promise.resolve(false);
1685 }
1686
1687 if (window.__filemanagerVideoStreamCacheSwPromise)
1688 {
1689 return window.__filemanagerVideoStreamCacheSwPromise;
1690 }
1691
1692 window.__filemanagerVideoStreamCacheSwPromise = navigator.serviceWorker.register(VIDEO_STREAM_CACHE_SW_URL, {
1693 scope: '/',
1694 updateViaCache: 'none',
1695 }).then(() => true).catch(() => false);
1696
1697 return window.__filemanagerVideoStreamCacheSwPromise;
1698 }
1699
1700 function videoStreamCachePrefixFromPlaylistUrl (playlistUrl)
1701 {
1702 const raw = String(playlistUrl || '').trim();
1703 if (!raw) return null;
1704
1705 let parsed = null;
1706 try
1707 {
1708 parsed = new URL(raw, window.location.origin);
1709 } catch
1710 {
1711 return null;
1712 }
1713
1714 const pathname = String(parsed.pathname || '');
1715 if (!pathname) return null;
1716 const lastSlashIndex = pathname.lastIndexOf('/');
1717 const basePath = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '/';
1718 return `${parsed.origin}${basePath}`;
1719 }
1720
1721 function clearVideoStreamClientCache (playlistUrl)
1722 {
1723 const prefix = videoStreamCachePrefixFromPlaylistUrl(playlistUrl);
1724 if (!prefix || typeof caches === 'undefined' || typeof caches.open !== 'function')
1725 {
1726 return Promise.resolve();
1727 }
1728
1729 return caches.open(VIDEO_STREAM_CACHE_NAME).then(async (cache) =>
1730 {
1731 const requests = await cache.keys();
1732 const deletions = [];
1733 for (const request of requests)
1734 {
1735 const requestUrl = request && request.url ? String(request.url) : '';
1736 if (!requestUrl.startsWith(prefix)) continue;
1737 deletions.push(cache.delete(request));
1738 }
1739 await Promise.all(deletions);
1740 }).catch(() =>
1741 {
1742 // Keep cache cleanup best-effort only.
1743 });
1744 }
1745
1746 function parseHlsManifest (manifestText)
1747 {
1748 const lines = String(manifestText || '').split(/\r?\n/);
1749 const childPlaylists = [];
1750 const mediaAssets = [];
1751 const mediaSegmentUris = [];
1752 const mediaSegments = [];
1753 let expectPlaylistUri = false;
1754 let segmentCursorSeconds = 0;
1755 let pendingSegmentDurationSeconds = null;
1756
1757 for (const rawLine of lines)
1758 {
1759 const line = String(rawLine || '').trim();
1760 if (!line) continue;
1761
1762 if (line.startsWith('#'))
1763 {
1764 if (/^#EXT-X-STREAM-INF/i.test(line))
1765 {
1766 expectPlaylistUri = true;
1767 continue;
1768 }
1769
1770 const segmentDurationMatch = line.match(/^#EXTINF\s*:\s*([0-9]+(?:\.[0-9]+)?)/i);
1771 if (segmentDurationMatch)
1772 {
1773 const parsed = Number.parseFloat(segmentDurationMatch[1]);
1774 pendingSegmentDurationSeconds = Number.isFinite(parsed) && parsed > 0
1775 ? parsed
1776 : VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1777 continue;
1778 }
1779
1780 const mapMatch = line.match(/^#EXT-X-MAP\s*:\s*.*?URI="([^"]+)"/i);
1781 if (mapMatch && mapMatch[1]) mediaAssets.push(mapMatch[1]);
1782 continue;
1783 }
1784
1785 if (expectPlaylistUri || /\.m3u8(?:$|\?)/i.test(line))
1786 {
1787 childPlaylists.push(line);
1788 expectPlaylistUri = false;
1789 } else
1790 {
1791 mediaAssets.push(line);
1792 mediaSegmentUris.push(line);
1793 if (Number.isFinite(pendingSegmentDurationSeconds) && pendingSegmentDurationSeconds > 0)
1794 {
1795 const startTimeSeconds = segmentCursorSeconds;
1796 segmentCursorSeconds += pendingSegmentDurationSeconds;
1797 mediaSegments.push({
1798 uri: line,
1799 startTimeSeconds,
1800 endTimeSeconds: segmentCursorSeconds,
1801 });
1802 }
1803 pendingSegmentDurationSeconds = null;
1804 }
1805 }
1806
1807 return {
1808 childPlaylists,
1809 mediaAssets,
1810 mediaSegmentUris,
1811 mediaSegments,
1812 endList: /#EXT-X-ENDLIST/i.test(String(manifestText || '')),
1813 };
1814 }
1815
1816 function inferSegmentEndSecondsFromAssetUrl (assetUrl)
1817 {
1818 const value = String(assetUrl || '');
1819 if (!value) return null;
1820
1821 let pathname = value;
1822 try
1823 {
1824 pathname = new URL(value, window.location.href).pathname || value;
1825 } catch
1826 {
1827 // Ignore URL parsing failures and fall back to raw value matching.
1828 }
1829
1830 const match = pathname.match(/_segment_(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i)
1831 || pathname.match(/(?:^|[/._-])seg(?:ment)?[_-]?(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i);
1832 if (!match) return null;
1833
1834 const segmentIndex = Number.parseInt(match[1], 10);
1835 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return null;
1836 return (segmentIndex + 1) * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1837 }
1838
1839 function bindStreamAheadSeekMarker (player, streamAheadPrefetch, opts = {})
1840 {
1841 if (!player || typeof player.on !== 'function' || !streamAheadPrefetch) return null;
1842
1843 const markerChar = String(opts.markerChar || ':').slice(0, 1) || ':';
1844 const markerColor = String(opts.markerColor || '#d6d6d6');
1845 const showTimeTooltip = opts.showTimeTooltip === true;
1846 let markerEl = null;
1847 let markerContainerEl = null;
1848 let cachedThroughSeconds = null;
1849 let cachedThroughRatio = null;
1850 let detachProgressListener = null;
1851
1852 const currentDuration = () =>
1853 {
1854 const duration = Number(player.duration && player.duration());
1855 return Number.isFinite(duration) && duration > 0 ? duration : null;
1856 };
1857
1858 const updateMarker = () =>
1859 {
1860 if (!markerEl) return;
1861
1862 const duration = currentDuration();
1863 if (!duration || !Number.isFinite(cachedThroughSeconds) || cachedThroughSeconds < 0)
1864 {
1865 markerEl.style.display = 'none';
1866 return;
1867 }
1868
1869 const ratioFromSeconds = Number.isFinite(cachedThroughSeconds)
1870 ? Math.max(0, Math.min(1, cachedThroughSeconds / duration))
1871 : null;
1872 const ratioFromSections = Number.isFinite(cachedThroughRatio)
1873 ? Math.max(0, Math.min(1, cachedThroughRatio))
1874 : null;
1875 const ratio = Number.isFinite(ratioFromSeconds)
1876 ? ratioFromSeconds
1877 : ratioFromSections;
1878 if (!Number.isFinite(ratio) || ratio <= 0)
1879 {
1880 markerEl.style.display = 'none';
1881 return;
1882 }
1883
1884 markerEl.style.display = 'block';
1885 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
1886 if (showTimeTooltip)
1887 {
1888 if (Number.isFinite(cachedThroughSeconds))
1889 {
1890 markerEl.title = `Walker cached through ${formatClockTime(cachedThroughSeconds)}`;
1891 } else if (Number.isFinite(cachedThroughRatio))
1892 {
1893 markerEl.title = `Walker cached through ${Math.round(cachedThroughRatio * 100)}%`;
1894 } else
1895 {
1896 markerEl.title = 'Walker cached through';
1897 }
1898 } else
1899 {
1900 markerEl.removeAttribute('title');
1901 }
1902 };
1903
1904 const ensureMarker = () =>
1905 {
1906 if (markerContainerEl && markerContainerEl.isConnected)
1907 {
1908 updateMarker();
1909 return;
1910 }
1911
1912 const playerEl = player.el && player.el();
1913 if (!playerEl) return;
1914
1915 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
1916 || playerEl.querySelector('.vjs-progress-holder')
1917 || playerEl.querySelector('.vjs-progress-control');
1918 if (!seekBarEl) return;
1919
1920 const computedPosition = window.getComputedStyle(seekBarEl).position;
1921 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
1922
1923 markerContainerEl = document.createElement('div');
1924 markerContainerEl.className = 'vjs-stream-ahead-cache-marker-container';
1925 markerContainerEl.style.position = 'absolute';
1926 markerContainerEl.style.left = '0';
1927 markerContainerEl.style.right = '0';
1928 markerContainerEl.style.top = '50%';
1929 markerContainerEl.style.height = '10px';
1930 markerContainerEl.style.transform = 'translateY(-50%)';
1931 markerContainerEl.style.pointerEvents = 'none';
1932 markerContainerEl.style.zIndex = '4';
1933
1934 markerEl = document.createElement('span');
1935 markerEl.className = 'vjs-stream-ahead-cache-marker';
1936 markerEl.style.position = 'absolute';
1937 markerEl.style.top = '50%';
1938 markerEl.style.width = '10px';
1939 markerEl.style.height = '10px';
1940 markerEl.style.transform = 'translate(-50%, -50%)';
1941 markerEl.style.color = markerColor;
1942 markerEl.style.fontFamily = 'monospace';
1943 markerEl.style.fontSize = '12px';
1944 markerEl.style.fontWeight = '700';
1945 markerEl.style.lineHeight = '10px';
1946 markerEl.style.textAlign = 'center';
1947 markerEl.style.display = 'none';
1948 markerEl.style.textShadow = '0 0 2px rgba(0, 0, 0, 0.65)';
1949 markerEl.textContent = markerChar;
1950 markerEl.setAttribute('aria-hidden', 'true');
1951 if (showTimeTooltip)
1952 {
1953 markerEl.title = 'Walker cached through 00:00';
1954 }
1955
1956 markerContainerEl.appendChild(markerEl);
1957 seekBarEl.appendChild(markerContainerEl);
1958 updateMarker();
1959 };
1960
1961 const onDurationHint = () =>
1962 {
1963 ensureMarker();
1964 updateMarker();
1965 };
1966
1967 player.on('loadedmetadata', onDurationHint);
1968 player.on('durationchange', onDurationHint);
1969 player.on('loadedplaylist', onDurationHint);
1970 player.ready(onDurationHint);
1971
1972 if (typeof streamAheadPrefetch.subscribe === 'function')
1973 {
1974 detachProgressListener = streamAheadPrefetch.subscribe((status) =>
1975 {
1976 const nextCachedThrough = status && Number.isFinite(Number(status.cachedThroughSeconds))
1977 ? Number(status.cachedThroughSeconds)
1978 : null;
1979 cachedThroughSeconds = nextCachedThrough;
1980 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
1981 ? Number(status.cachedThroughRatio)
1982 : null;
1983 ensureMarker();
1984 updateMarker();
1985 });
1986 } else if (typeof streamAheadPrefetch.getStatus === 'function')
1987 {
1988 const status = streamAheadPrefetch.getStatus();
1989 cachedThroughSeconds = status && Number.isFinite(Number(status.cachedThroughSeconds))
1990 ? Number(status.cachedThroughSeconds)
1991 : null;
1992 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
1993 ? Number(status.cachedThroughRatio)
1994 : null;
1995 ensureMarker();
1996 updateMarker();
1997 }
1998
1999 return {
2000 detach: () =>
2001 {
2002 if (typeof detachProgressListener === 'function')
2003 {
2004 try { detachProgressListener(); } catch { /* ignore detach races */ }
2005 detachProgressListener = null;
2006 }
2007
2008 if (markerContainerEl && markerContainerEl.parentNode)
2009 {
2010 markerContainerEl.parentNode.removeChild(markerContainerEl);
2011 }
2012 markerContainerEl = null;
2013 markerEl = null;
2014 },
2015 };
2016 }
2017
2018 function bindStreamAheadPrefetch (opts = {})
2019 {
2020 const basePlaylistUrl = String(opts.playlistUrl || '').trim();
2021 if (!basePlaylistUrl) return null;
2022
2023 const pollIntervalMsRaw = Number(opts.pollIntervalMs);
2024 const pollIntervalMs = Number.isFinite(pollIntervalMsRaw) && pollIntervalMsRaw >= 0
2025 ? pollIntervalMsRaw
2026 : VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT;
2027 const headers = opts.headers;
2028 const credentials = opts.credentials;
2029
2030 const playlistStatusByUrl = new Map();
2031 const knownPlaylistUrls = new Set([basePlaylistUrl]);
2032 const fetchedAssetUrls = new Set();
2033 const segmentEndSecondsByAssetUrl = new Map();
2034 const discoveredSegmentUrls = new Set();
2035 const fetchedSegmentUrls = new Set();
2036 const progressListeners = new Set();
2037 const controller = typeof AbortController === 'function' ? new AbortController() : null;
2038 let stopped = false;
2039 let cachedThroughSeconds = null;
2040 let cachedThroughRatio = null;
2041 let fetchedTimelineAssetCount = 0;
2042
2043 const recalculateSegmentRatio = () =>
2044 {
2045 const totalSegments = discoveredSegmentUrls.size;
2046 if (totalSegments <= 0)
2047 {
2048 cachedThroughRatio = null;
2049 return;
2050 }
2051 cachedThroughRatio = Math.max(0, Math.min(1, fetchedSegmentUrls.size / totalSegments));
2052 };
2053
2054 const resolveUrl = (value, parentUrl) =>
2055 {
2056 try
2057 {
2058 return new URL(String(value || '').trim(), parentUrl || window.location.href).toString();
2059 } catch
2060 {
2061 return null;
2062 }
2063 };
2064
2065 const wait = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
2066
2067 const fetchText = async (url) =>
2068 {
2069 const res = await fetch(url, {
2070 method: 'GET',
2071 headers,
2072 credentials,
2073 cache: 'no-store',
2074 signal: controller ? controller.signal : undefined,
2075 });
2076 if (!res || !res.ok) return null;
2077 return res.text();
2078 };
2079
2080 const fetchAsset = async (url) =>
2081 {
2082 const res = await fetch(url, {
2083 method: 'GET',
2084 headers,
2085 credentials,
2086 signal: controller ? controller.signal : undefined,
2087 });
2088 if (!res || !res.ok) return false;
2089 // Ensure body fully reads so browser/service-worker caches the asset bytes.
2090 await res.arrayBuffer();
2091 return true;
2092 };
2093
2094 const getStatus = () => ({
2095 cachedThroughSeconds,
2096 cachedThroughRatio,
2097 knownPlaylistCount: knownPlaylistUrls.size,
2098 fetchedAssetCount: fetchedAssetUrls.size,
2099 fetchedTimelineAssetCount,
2100 totalSegmentCount: discoveredSegmentUrls.size,
2101 fetchedSegmentCount: fetchedSegmentUrls.size,
2102 allPlaylistsComplete: Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true),
2103 stopped,
2104 });
2105
2106 const appearsTimelineAsset = (assetUrl) =>
2107 /(?:\.ts|\.m4s|\.mp4|\.aac|\.m4a)(?:$|\?)/i.test(String(assetUrl || ''));
2108
2109 const emitProgress = () =>
2110 {
2111 const status = getStatus();
2112 for (const listener of Array.from(progressListeners))
2113 {
2114 try
2115 {
2116 listener(status);
2117 } catch
2118 {
2119 // Keep progress listeners best-effort only.
2120 }
2121 }
2122 };
2123
2124 const workerPromise = (async () =>
2125 {
2126 while (!stopped)
2127 {
2128 const nextAssetUrlSet = new Set();
2129
2130 for (const playlistUrl of Array.from(knownPlaylistUrls))
2131 {
2132 if (stopped) return;
2133 const manifestText = await fetchText(playlistUrl).catch(() => null);
2134 if (!manifestText) continue;
2135
2136 const parsed = parseHlsManifest(manifestText);
2137 playlistStatusByUrl.set(playlistUrl, !!parsed.endList);
2138
2139 for (const child of parsed.childPlaylists)
2140 {
2141 const resolved = resolveUrl(child, playlistUrl);
2142 if (!resolved) continue;
2143 knownPlaylistUrls.add(resolved);
2144 if (!playlistStatusByUrl.has(resolved)) playlistStatusByUrl.set(resolved, false);
2145 }
2146
2147 for (const asset of parsed.mediaAssets)
2148 {
2149 const resolved = resolveUrl(asset, playlistUrl);
2150 if (!resolved || fetchedAssetUrls.has(resolved)) continue;
2151 nextAssetUrlSet.add(resolved);
2152 }
2153
2154 for (const segment of parsed.mediaSegments)
2155 {
2156 if (!segment || !segment.uri) continue;
2157 const resolved = resolveUrl(segment.uri, playlistUrl);
2158 if (!resolved) continue;
2159 if (!Number.isFinite(segment.endTimeSeconds) || segment.endTimeSeconds < 0) continue;
2160 segmentEndSecondsByAssetUrl.set(resolved, Number(segment.endTimeSeconds));
2161 }
2162
2163 for (const segmentUri of parsed.mediaSegmentUris)
2164 {
2165 const resolved = resolveUrl(segmentUri, playlistUrl);
2166 if (!resolved) continue;
2167 discoveredSegmentUrls.add(resolved);
2168 }
2169 }
2170
2171 recalculateSegmentRatio();
2172 emitProgress();
2173
2174 const nextAssetUrls = Array.from(nextAssetUrlSet);
2175 for (const assetUrl of nextAssetUrls)
2176 {
2177 if (stopped) return;
2178 const fetched = await fetchAsset(assetUrl).catch(() => false);
2179 if (!fetched) continue;
2180
2181 fetchedAssetUrls.add(assetUrl);
2182 if (discoveredSegmentUrls.has(assetUrl))
2183 {
2184 fetchedSegmentUrls.add(assetUrl);
2185 }
2186 const mappedSegmentEndSeconds = segmentEndSecondsByAssetUrl.get(assetUrl);
2187 const inferredSegmentEndSeconds = inferSegmentEndSecondsFromAssetUrl(assetUrl);
2188 let fallbackSegmentEndSeconds = null;
2189 if (!Number.isFinite(mappedSegmentEndSeconds) && !Number.isFinite(inferredSegmentEndSeconds) && appearsTimelineAsset(assetUrl))
2190 {
2191 fetchedTimelineAssetCount += 1;
2192 fallbackSegmentEndSeconds = fetchedTimelineAssetCount * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2193 }
2194
2195 const segmentEndSeconds = [mappedSegmentEndSeconds, inferredSegmentEndSeconds, fallbackSegmentEndSeconds]
2196 .filter((value) => Number.isFinite(value))
2197 .reduce((maxValue, value) => (value > maxValue ? value : maxValue), -1);
2198
2199 if (Number.isFinite(segmentEndSeconds))
2200 {
2201 if (!Number.isFinite(cachedThroughSeconds) || segmentEndSeconds > cachedThroughSeconds)
2202 {
2203 cachedThroughSeconds = segmentEndSeconds;
2204 }
2205 }
2206
2207 recalculateSegmentRatio();
2208 emitProgress();
2209 }
2210
2211 const allPlaylistsComplete = Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true);
2212 if (allPlaylistsComplete && !nextAssetUrls.length)
2213 {
2214 emitProgress();
2215 return;
2216 }
2217
2218 if (pollIntervalMs > 0)
2219 {
2220 await wait(pollIntervalMs);
2221 }
2222 }
2223 })();
2224
2225 return {
2226 stop: () =>
2227 {
2228 stopped = true;
2229 if (controller && typeof controller.abort === 'function')
2230 {
2231 try { controller.abort(); } catch { /* ignore abort races */ }
2232 }
2233 emitProgress();
2234 },
2235 done: () => workerPromise,
2236 getStatus,
2237 subscribe: (listener) =>
2238 {
2239 if (typeof listener !== 'function') return () => { };
2240 progressListeners.add(listener);
2241 try { listener(getStatus()); } catch { /* ignore listener failures */ }
2242 return () =>
2243 {
2244 progressListeners.delete(listener);
2245 };
2246 },
2247 };
2248 }
2249
2250 function applyDefaultTextTrackPrefs ()
2251 {
2252 try
2253 {
2254 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
2255 } catch
2256 {
2257 // Ignore localStorage failures.
2258 }
2259 }
2260
2261 window.FilemanagerSharedVideoPlayer = {
2262 applyDefaultTextTrackPrefs,
2263 bindImageSubtitleOverlay,
2264 bindStreamAheadPrefetch,
2265 bindStreamAheadSeekMarker,
2266 bindTrackPrefs,
2267 clearVideoStreamClientCache,
2268 configureVideoJsBuffering,
2269 enableVideoStreamClientCache,
2270 ensureVideoPlaybackUi,
2271 normaliseVideoDuration,
2272 };
2273}());