BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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