BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

shared-video-player.js 77.5 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 const onDurationHints = () =>
1533 {
1534 ensureSeekBarMarkers();
1535 updateSeekBarMarkers();
1536
1537 if (selectedStreamIndex === null || trackDisabled) return;
1538 const currentTime = Number(player.currentTime());
1539 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1540
1541 queueLookaheadPrefetch(currentTime, {
1542 includeCurrentTime: true,
1543 });
1544 };
1545
1546 player.on('durationchange', onDurationHints);
1547 player.on('loadedmetadata', onDurationHints);
1548
1549 return player.imageSubtitleOverlayController;
1550 }
1551
1552 function formatDurationForDebug (seconds)
1553 {
1554 const value = Number(seconds);
1555 if (!Number.isFinite(value) || value < 0) return 'unknown';
1556
1557 const totalSeconds = Math.floor(value);
1558 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1559 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1560 const ss = String(totalSeconds % 60).padStart(2, '0');
1561 return `${hh}:${mm}:${ss}`;
1562 }
1563
1564 function installDurationFallback (player, originalDuration, duration)
1565 {
1566 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1567
1568 player.__filemanagerDurationFallback = true;
1569 player.duration = function durationWithFallback (...args)
1570 {
1571 if (args.length) return originalDuration(...args);
1572 const current = Number(originalDuration());
1573 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1574 };
1575 }
1576
1577 function normaliseVideoDuration (player, durationSeconds)
1578 {
1579 const duration = Number(durationSeconds);
1580 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1581
1582 let originalDuration = null;
1583 let durationWasChanged = false;
1584 try
1585 {
1586 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1587 installDurationFallback(player, originalDuration, duration);
1588 if (player.__filemanagerDurationApplied) return;
1589
1590 const current = originalDuration ? Number(originalDuration()) : NaN;
1591 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1592 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1593 if (withinTolerance)
1594 {
1595 player.__filemanagerDurationApplied = true;
1596 return;
1597 }
1598
1599 if (originalDuration)
1600 {
1601 durationWasChanged = true;
1602 originalDuration(duration);
1603 }
1604 } catch
1605 {
1606 // Ignore players that do not support setting duration.
1607 }
1608
1609 try
1610 {
1611 const updated = originalDuration ? Number(originalDuration()) : NaN;
1612 if (Number.isFinite(updated) && updated >= duration * 0.95)
1613 {
1614 player.__filemanagerDurationApplied = true;
1615 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1616 return;
1617 }
1618
1619 player.__filemanagerDurationApplied = true;
1620 if (typeof player.trigger === 'function') player.trigger('durationchange');
1621 } catch
1622 {
1623 // Ignore duration fallback failures.
1624 }
1625 }
1626
1627 function ensureVideoPlaybackUi (player, durationSeconds)
1628 {
1629 if (!player || typeof player.on !== 'function') return;
1630
1631 const forceVodUi = () =>
1632 {
1633 normaliseVideoDuration(player, durationSeconds);
1634
1635 try
1636 {
1637 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1638 {
1639 player.liveTracker.stopTracking();
1640 }
1641 } catch
1642 {
1643 // Ignore live tracker availability issues.
1644 }
1645
1646 try
1647 {
1648 if (typeof player.removeClass === 'function')
1649 {
1650 player.removeClass('vjs-live');
1651 }
1652 } catch
1653 {
1654 // Ignore class update failures.
1655 }
1656
1657 try
1658 {
1659 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
1660 if (display) display.style.display = 'none';
1661 } catch
1662 {
1663 // Ignore missing DOM.
1664 }
1665 };
1666
1667 player.ready(forceVodUi);
1668 player.on('loadedmetadata', forceVodUi);
1669 player.on('durationchange', forceVodUi);
1670 player.on('loadedplaylist', forceVodUi);
1671 }
1672
1673 function configureVideoJsBuffering (videojs, opts = {})
1674 {
1675 if (opts.enabled === false) return;
1676 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
1677 videojs.__filemanagerBufferingConfigured = true;
1678
1679 const seconds = Number(opts.seconds);
1680 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
1681
1682 try
1683 {
1684 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
1685 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
1686 videojs.Vhs.BUFFER_LOW_WATER_LINE = Math.max(30, Math.floor(bufferSeconds / 2));
1687 videojs.Vhs.MAX_BUFFER_LOW_WATER_LINE = bufferSeconds;
1688 } catch
1689 {
1690 // Ignore builds that do not expose VHS buffer configuration.
1691 }
1692 }
1693
1694 function enableVideoStreamClientCache ()
1695 {
1696 if (typeof navigator === 'undefined' || !navigator.serviceWorker || typeof navigator.serviceWorker.register !== 'function')
1697 {
1698 return Promise.resolve(false);
1699 }
1700
1701 if (window.__filemanagerVideoStreamCacheSwPromise)
1702 {
1703 return window.__filemanagerVideoStreamCacheSwPromise;
1704 }
1705
1706 window.__filemanagerVideoStreamCacheSwPromise = navigator.serviceWorker.register(VIDEO_STREAM_CACHE_SW_URL, {
1707 scope: '/',
1708 updateViaCache: 'none',
1709 }).then(() => true).catch(() => false);
1710
1711 return window.__filemanagerVideoStreamCacheSwPromise;
1712 }
1713
1714 function videoStreamCachePrefixFromPlaylistUrl (playlistUrl)
1715 {
1716 const raw = String(playlistUrl || '').trim();
1717 if (!raw) return null;
1718
1719 let parsed = null;
1720 try
1721 {
1722 parsed = new URL(raw, window.location.origin);
1723 } catch
1724 {
1725 return null;
1726 }
1727
1728 const pathname = String(parsed.pathname || '');
1729 if (!pathname) return null;
1730 const lastSlashIndex = pathname.lastIndexOf('/');
1731 const basePath = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '/';
1732 return `${parsed.origin}${basePath}`;
1733 }
1734
1735 function clearVideoStreamClientCache (playlistUrl)
1736 {
1737 const prefix = videoStreamCachePrefixFromPlaylistUrl(playlistUrl);
1738 if (!prefix || typeof caches === 'undefined' || typeof caches.open !== 'function')
1739 {
1740 return Promise.resolve();
1741 }
1742
1743 return caches.open(VIDEO_STREAM_CACHE_NAME).then(async (cache) =>
1744 {
1745 const requests = await cache.keys();
1746 const deletions = [];
1747 for (const request of requests)
1748 {
1749 const requestUrl = request && request.url ? String(request.url) : '';
1750 if (!requestUrl.startsWith(prefix)) continue;
1751 deletions.push(cache.delete(request));
1752 }
1753 await Promise.all(deletions);
1754 }).catch(() =>
1755 {
1756 // Keep cache cleanup best-effort only.
1757 });
1758 }
1759
1760 function parseHlsManifest (manifestText)
1761 {
1762 const lines = String(manifestText || '').split(/\r?\n/);
1763 const childPlaylists = [];
1764 const mediaAssets = [];
1765 const mediaSegmentUris = [];
1766 const mediaSegments = [];
1767 let expectPlaylistUri = false;
1768 let segmentCursorSeconds = 0;
1769 let pendingSegmentDurationSeconds = null;
1770
1771 for (const rawLine of lines)
1772 {
1773 const line = String(rawLine || '').trim();
1774 if (!line) continue;
1775
1776 if (line.startsWith('#'))
1777 {
1778 if (/^#EXT-X-STREAM-INF/i.test(line))
1779 {
1780 expectPlaylistUri = true;
1781 continue;
1782 }
1783
1784 const segmentDurationMatch = line.match(/^#EXTINF\s*:\s*([0-9]+(?:\.[0-9]+)?)/i);
1785 if (segmentDurationMatch)
1786 {
1787 const parsed = Number.parseFloat(segmentDurationMatch[1]);
1788 pendingSegmentDurationSeconds = Number.isFinite(parsed) && parsed > 0
1789 ? parsed
1790 : VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1791 continue;
1792 }
1793
1794 const mapMatch = line.match(/^#EXT-X-MAP\s*:\s*.*?URI="([^"]+)"/i);
1795 if (mapMatch && mapMatch[1]) mediaAssets.push(mapMatch[1]);
1796 continue;
1797 }
1798
1799 if (expectPlaylistUri || /\.m3u8(?:$|\?)/i.test(line))
1800 {
1801 childPlaylists.push(line);
1802 expectPlaylistUri = false;
1803 } else
1804 {
1805 mediaAssets.push(line);
1806 mediaSegmentUris.push(line);
1807 if (Number.isFinite(pendingSegmentDurationSeconds) && pendingSegmentDurationSeconds > 0)
1808 {
1809 const startTimeSeconds = segmentCursorSeconds;
1810 segmentCursorSeconds += pendingSegmentDurationSeconds;
1811 mediaSegments.push({
1812 uri: line,
1813 startTimeSeconds,
1814 endTimeSeconds: segmentCursorSeconds,
1815 });
1816 }
1817 pendingSegmentDurationSeconds = null;
1818 }
1819 }
1820
1821 return {
1822 childPlaylists,
1823 mediaAssets,
1824 mediaSegmentUris,
1825 mediaSegments,
1826 endList: /#EXT-X-ENDLIST/i.test(String(manifestText || '')),
1827 };
1828 }
1829
1830 function inferSegmentEndSecondsFromAssetUrl (assetUrl)
1831 {
1832 const value = String(assetUrl || '');
1833 if (!value) return null;
1834
1835 let pathname = value;
1836 try
1837 {
1838 pathname = new URL(value, window.location.href).pathname || value;
1839 } catch
1840 {
1841 // Ignore URL parsing failures and fall back to raw value matching.
1842 }
1843
1844 const match = pathname.match(/_segment_(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i)
1845 || pathname.match(/(?:^|[/._-])seg(?:ment)?[_-]?(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i);
1846 if (!match) return null;
1847
1848 const segmentIndex = Number.parseInt(match[1], 10);
1849 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return null;
1850 return (segmentIndex + 1) * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
1851 }
1852
1853 function bindStreamAheadSeekMarker (player, streamAheadPrefetch, opts = {})
1854 {
1855 if (!player || typeof player.on !== 'function' || !streamAheadPrefetch) return null;
1856
1857 const markerChar = String(opts.markerChar || ':').slice(0, 1) || ':';
1858 const markerColor = String(opts.markerColor || '#d6d6d6');
1859 const showTimeTooltip = opts.showTimeTooltip === true;
1860 let markerEl = null;
1861 let markerContainerEl = null;
1862 let cachedThroughSeconds = null;
1863 let cachedThroughRatio = null;
1864 let detachProgressListener = null;
1865
1866 const currentDuration = () =>
1867 {
1868 const duration = Number(player.duration && player.duration());
1869 return Number.isFinite(duration) && duration > 0 ? duration : null;
1870 };
1871
1872 const updateMarker = () =>
1873 {
1874 if (!markerEl) return;
1875
1876 const duration = currentDuration();
1877 if (!duration || !Number.isFinite(cachedThroughSeconds) || cachedThroughSeconds < 0)
1878 {
1879 markerEl.style.display = 'none';
1880 return;
1881 }
1882
1883 const ratioFromSeconds = Number.isFinite(cachedThroughSeconds)
1884 ? Math.max(0, Math.min(1, cachedThroughSeconds / duration))
1885 : null;
1886 const ratioFromSections = Number.isFinite(cachedThroughRatio)
1887 ? Math.max(0, Math.min(1, cachedThroughRatio))
1888 : null;
1889 const ratio = Number.isFinite(ratioFromSeconds)
1890 ? ratioFromSeconds
1891 : ratioFromSections;
1892 if (!Number.isFinite(ratio) || ratio <= 0)
1893 {
1894 markerEl.style.display = 'none';
1895 return;
1896 }
1897
1898 markerEl.style.display = 'block';
1899 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
1900 if (showTimeTooltip)
1901 {
1902 if (Number.isFinite(cachedThroughSeconds))
1903 {
1904 markerEl.title = `Walker cached through ${formatClockTime(cachedThroughSeconds)}`;
1905 } else if (Number.isFinite(cachedThroughRatio))
1906 {
1907 markerEl.title = `Walker cached through ${Math.round(cachedThroughRatio * 100)}%`;
1908 } else
1909 {
1910 markerEl.title = 'Walker cached through';
1911 }
1912 } else
1913 {
1914 markerEl.removeAttribute('title');
1915 }
1916 };
1917
1918 const ensureMarker = () =>
1919 {
1920 if (markerContainerEl && markerContainerEl.isConnected)
1921 {
1922 updateMarker();
1923 return;
1924 }
1925
1926 const playerEl = player.el && player.el();
1927 if (!playerEl) return;
1928
1929 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
1930 || playerEl.querySelector('.vjs-progress-holder')
1931 || playerEl.querySelector('.vjs-progress-control');
1932 if (!seekBarEl) return;
1933
1934 const computedPosition = window.getComputedStyle(seekBarEl).position;
1935 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
1936
1937 markerContainerEl = document.createElement('div');
1938 markerContainerEl.className = 'vjs-stream-ahead-cache-marker-container';
1939 markerContainerEl.style.position = 'absolute';
1940 markerContainerEl.style.left = '0';
1941 markerContainerEl.style.right = '0';
1942 markerContainerEl.style.top = '50%';
1943 markerContainerEl.style.height = '10px';
1944 markerContainerEl.style.transform = 'translateY(-50%)';
1945 markerContainerEl.style.pointerEvents = 'none';
1946 markerContainerEl.style.zIndex = '4';
1947
1948 markerEl = document.createElement('span');
1949 markerEl.className = 'vjs-stream-ahead-cache-marker';
1950 markerEl.style.position = 'absolute';
1951 markerEl.style.top = '50%';
1952 markerEl.style.width = '10px';
1953 markerEl.style.height = '10px';
1954 markerEl.style.transform = 'translate(-50%, -50%)';
1955 markerEl.style.color = markerColor;
1956 markerEl.style.fontFamily = 'monospace';
1957 markerEl.style.fontSize = '12px';
1958 markerEl.style.fontWeight = '700';
1959 markerEl.style.lineHeight = '10px';
1960 markerEl.style.textAlign = 'center';
1961 markerEl.style.display = 'none';
1962 markerEl.style.textShadow = '0 0 2px rgba(0, 0, 0, 0.65)';
1963 markerEl.textContent = markerChar;
1964 markerEl.setAttribute('aria-hidden', 'true');
1965 if (showTimeTooltip)
1966 {
1967 markerEl.title = 'Walker cached through 00:00';
1968 }
1969
1970 markerContainerEl.appendChild(markerEl);
1971 seekBarEl.appendChild(markerContainerEl);
1972 updateMarker();
1973 };
1974
1975 const onDurationHint = () =>
1976 {
1977 ensureMarker();
1978 updateMarker();
1979 };
1980
1981 player.on('loadedmetadata', onDurationHint);
1982 player.on('durationchange', onDurationHint);
1983 player.on('loadedplaylist', onDurationHint);
1984 player.ready(onDurationHint);
1985
1986 if (typeof streamAheadPrefetch.subscribe === 'function')
1987 {
1988 detachProgressListener = streamAheadPrefetch.subscribe((status) =>
1989 {
1990 const nextCachedThrough = status && Number.isFinite(Number(status.cachedThroughSeconds))
1991 ? Number(status.cachedThroughSeconds)
1992 : null;
1993 cachedThroughSeconds = nextCachedThrough;
1994 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
1995 ? Number(status.cachedThroughRatio)
1996 : null;
1997 ensureMarker();
1998 updateMarker();
1999 });
2000 } else if (typeof streamAheadPrefetch.getStatus === 'function')
2001 {
2002 const status = streamAheadPrefetch.getStatus();
2003 cachedThroughSeconds = status && Number.isFinite(Number(status.cachedThroughSeconds))
2004 ? Number(status.cachedThroughSeconds)
2005 : null;
2006 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
2007 ? Number(status.cachedThroughRatio)
2008 : null;
2009 ensureMarker();
2010 updateMarker();
2011 }
2012
2013 return {
2014 detach: () =>
2015 {
2016 if (typeof detachProgressListener === 'function')
2017 {
2018 try { detachProgressListener(); } catch { /* ignore detach races */ }
2019 detachProgressListener = null;
2020 }
2021
2022 if (markerContainerEl && markerContainerEl.parentNode)
2023 {
2024 markerContainerEl.parentNode.removeChild(markerContainerEl);
2025 }
2026 markerContainerEl = null;
2027 markerEl = null;
2028 },
2029 };
2030 }
2031
2032 function bindStreamAheadPrefetch (opts = {})
2033 {
2034 const basePlaylistUrl = String(opts.playlistUrl || '').trim();
2035 if (!basePlaylistUrl) return null;
2036
2037 const pollIntervalMsRaw = Number(opts.pollIntervalMs);
2038 const pollIntervalMs = Number.isFinite(pollIntervalMsRaw) && pollIntervalMsRaw >= 0
2039 ? pollIntervalMsRaw
2040 : VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT;
2041 const headers = opts.headers;
2042 const credentials = opts.credentials;
2043
2044 const playlistStatusByUrl = new Map();
2045 const knownPlaylistUrls = new Set([basePlaylistUrl]);
2046 const fetchedAssetUrls = new Set();
2047 const segmentEndSecondsByAssetUrl = new Map();
2048 const discoveredSegmentUrls = new Set();
2049 const fetchedSegmentUrls = new Set();
2050 const progressListeners = new Set();
2051 const controller = typeof AbortController === 'function' ? new AbortController() : null;
2052 let stopped = false;
2053 let cachedThroughSeconds = null;
2054 let cachedThroughRatio = null;
2055 let fetchedTimelineAssetCount = 0;
2056
2057 const recalculateSegmentRatio = () =>
2058 {
2059 const totalSegments = discoveredSegmentUrls.size;
2060 if (totalSegments <= 0)
2061 {
2062 cachedThroughRatio = null;
2063 return;
2064 }
2065 cachedThroughRatio = Math.max(0, Math.min(1, fetchedSegmentUrls.size / totalSegments));
2066 };
2067
2068 const resolveUrl = (value, parentUrl) =>
2069 {
2070 try
2071 {
2072 return new URL(String(value || '').trim(), parentUrl || window.location.href).toString();
2073 } catch
2074 {
2075 return null;
2076 }
2077 };
2078
2079 const wait = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
2080
2081 const fetchText = async (url) =>
2082 {
2083 const res = await fetch(url, {
2084 method: 'GET',
2085 headers,
2086 credentials,
2087 cache: 'no-store',
2088 signal: controller ? controller.signal : undefined,
2089 });
2090 if (!res || !res.ok) return null;
2091 return res.text();
2092 };
2093
2094 const fetchAsset = async (url) =>
2095 {
2096 const res = await fetch(url, {
2097 method: 'GET',
2098 headers,
2099 credentials,
2100 signal: controller ? controller.signal : undefined,
2101 });
2102 if (!res || !res.ok) return false;
2103 // Ensure body fully reads so browser/service-worker caches the asset bytes.
2104 await res.arrayBuffer();
2105 return true;
2106 };
2107
2108 const getStatus = () => ({
2109 cachedThroughSeconds,
2110 cachedThroughRatio,
2111 knownPlaylistCount: knownPlaylistUrls.size,
2112 fetchedAssetCount: fetchedAssetUrls.size,
2113 fetchedTimelineAssetCount,
2114 totalSegmentCount: discoveredSegmentUrls.size,
2115 fetchedSegmentCount: fetchedSegmentUrls.size,
2116 allPlaylistsComplete: Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true),
2117 stopped,
2118 });
2119
2120 const appearsTimelineAsset = (assetUrl) =>
2121 /(?:\.ts|\.m4s|\.mp4|\.aac|\.m4a)(?:$|\?)/i.test(String(assetUrl || ''));
2122
2123 const emitProgress = () =>
2124 {
2125 const status = getStatus();
2126 for (const listener of Array.from(progressListeners))
2127 {
2128 try
2129 {
2130 listener(status);
2131 } catch
2132 {
2133 // Keep progress listeners best-effort only.
2134 }
2135 }
2136 };
2137
2138 const workerPromise = (async () =>
2139 {
2140 while (!stopped)
2141 {
2142 const nextAssetUrlSet = new Set();
2143
2144 for (const playlistUrl of Array.from(knownPlaylistUrls))
2145 {
2146 if (stopped) return;
2147 const manifestText = await fetchText(playlistUrl).catch(() => null);
2148 if (!manifestText) continue;
2149
2150 const parsed = parseHlsManifest(manifestText);
2151 playlistStatusByUrl.set(playlistUrl, !!parsed.endList);
2152
2153 for (const child of parsed.childPlaylists)
2154 {
2155 const resolved = resolveUrl(child, playlistUrl);
2156 if (!resolved) continue;
2157 knownPlaylistUrls.add(resolved);
2158 if (!playlistStatusByUrl.has(resolved)) playlistStatusByUrl.set(resolved, false);
2159 }
2160
2161 for (const asset of parsed.mediaAssets)
2162 {
2163 const resolved = resolveUrl(asset, playlistUrl);
2164 if (!resolved || fetchedAssetUrls.has(resolved)) continue;
2165 nextAssetUrlSet.add(resolved);
2166 }
2167
2168 for (const segment of parsed.mediaSegments)
2169 {
2170 if (!segment || !segment.uri) continue;
2171 const resolved = resolveUrl(segment.uri, playlistUrl);
2172 if (!resolved) continue;
2173 if (!Number.isFinite(segment.endTimeSeconds) || segment.endTimeSeconds < 0) continue;
2174 segmentEndSecondsByAssetUrl.set(resolved, Number(segment.endTimeSeconds));
2175 }
2176
2177 for (const segmentUri of parsed.mediaSegmentUris)
2178 {
2179 const resolved = resolveUrl(segmentUri, playlistUrl);
2180 if (!resolved) continue;
2181 discoveredSegmentUrls.add(resolved);
2182 }
2183 }
2184
2185 recalculateSegmentRatio();
2186 emitProgress();
2187
2188 const nextAssetUrls = Array.from(nextAssetUrlSet);
2189 for (const assetUrl of nextAssetUrls)
2190 {
2191 if (stopped) return;
2192 const fetched = await fetchAsset(assetUrl).catch(() => false);
2193 if (!fetched) continue;
2194
2195 fetchedAssetUrls.add(assetUrl);
2196 if (discoveredSegmentUrls.has(assetUrl))
2197 {
2198 fetchedSegmentUrls.add(assetUrl);
2199 }
2200 const mappedSegmentEndSeconds = segmentEndSecondsByAssetUrl.get(assetUrl);
2201 const inferredSegmentEndSeconds = inferSegmentEndSecondsFromAssetUrl(assetUrl);
2202 let fallbackSegmentEndSeconds = null;
2203 if (!Number.isFinite(mappedSegmentEndSeconds) && !Number.isFinite(inferredSegmentEndSeconds) && appearsTimelineAsset(assetUrl))
2204 {
2205 fetchedTimelineAssetCount += 1;
2206 fallbackSegmentEndSeconds = fetchedTimelineAssetCount * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2207 }
2208
2209 const segmentEndSeconds = [mappedSegmentEndSeconds, inferredSegmentEndSeconds, fallbackSegmentEndSeconds]
2210 .filter((value) => Number.isFinite(value))
2211 .reduce((maxValue, value) => (value > maxValue ? value : maxValue), -1);
2212
2213 if (Number.isFinite(segmentEndSeconds))
2214 {
2215 if (!Number.isFinite(cachedThroughSeconds) || segmentEndSeconds > cachedThroughSeconds)
2216 {
2217 cachedThroughSeconds = segmentEndSeconds;
2218 }
2219 }
2220
2221 recalculateSegmentRatio();
2222 emitProgress();
2223 }
2224
2225 const allPlaylistsComplete = Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true);
2226 if (allPlaylistsComplete && !nextAssetUrls.length)
2227 {
2228 emitProgress();
2229 return;
2230 }
2231
2232 if (pollIntervalMs > 0)
2233 {
2234 await wait(pollIntervalMs);
2235 }
2236 }
2237 })();
2238
2239 return {
2240 stop: () =>
2241 {
2242 stopped = true;
2243 if (controller && typeof controller.abort === 'function')
2244 {
2245 try { controller.abort(); } catch { /* ignore abort races */ }
2246 }
2247 emitProgress();
2248 },
2249 done: () => workerPromise,
2250 getStatus,
2251 subscribe: (listener) =>
2252 {
2253 if (typeof listener !== 'function') return () => { };
2254 progressListeners.add(listener);
2255 try { listener(getStatus()); } catch { /* ignore listener failures */ }
2256 return () =>
2257 {
2258 progressListeners.delete(listener);
2259 };
2260 },
2261 };
2262 }
2263
2264 function applyDefaultTextTrackPrefs ()
2265 {
2266 try
2267 {
2268 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
2269 } catch
2270 {
2271 // Ignore localStorage failures.
2272 }
2273 }
2274
2275 window.FilemanagerSharedVideoPlayer = {
2276 applyDefaultTextTrackPrefs,
2277 bindImageSubtitleOverlay,
2278 bindStreamAheadPrefetch,
2279 bindStreamAheadSeekMarker,
2280 bindTrackPrefs,
2281 clearVideoStreamClientCache,
2282 configureVideoJsBuffering,
2283 enableVideoStreamClientCache,
2284 ensureVideoPlaybackUi,
2285 normaliseVideoDuration,
2286 };
2287}());