BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

shared-video-player.js 91.3 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.005;
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 nextFrame = findNextCachedFrameAfterTime(streamIndex, currentTime);
823 if (!nextFrame || nextFrame.key === currentFrame.key || nextFrame.key === secondaryKey) return;
824
825 renderSubtitleFrameOnBuffer(nextFrame, secondaryIdx);
826 };
827
828 const syncOverlayToPlaybackClock = (frameMetadata) =>
829 {
830 if (selectedStreamIndex === null || trackDisabled)
831 {
832 stopPlaybackClockSync();
833 return;
834 }
835
836 const metadataTime = Number(frameMetadata && frameMetadata.mediaTime);
837 const currentTime = Number.isFinite(metadataTime) && metadataTime >= 0
838 ? metadataTime
839 : Number(player.currentTime());
840 if (Number.isFinite(currentTime) && currentTime >= 0)
841 {
842 const cachedFrame = findCachedFrameForTime(selectedStreamIndex, currentTime);
843
844 if (cachedFrame)
845 {
846 // Check if frame changed
847 const currentFrameKey = primaryBufferIndex === 0 ? primaryFrameKey : secondaryFrameKey;
848 if (cachedFrame.key !== currentFrameKey)
849 {
850 // Frame transition: check if it's pre-loaded on secondary buffer
851 const secondaryKey = primaryBufferIndex === 0 ? secondaryFrameKey : primaryFrameKey;
852 if (cachedFrame.key === secondaryKey)
853 {
854 // Swap to show pre-loaded secondary frame
855 swapBuffers();
856 showPrimaryBuffer();
857 activeObjectUrl = cachedFrame.objectUrl;
858 } else
859 {
860 // Not pre-loaded; render directly on secondary and swap
861 const secondaryIdx = primaryBufferIndex === 0 ? 1 : 0;
862 renderSubtitleFrameOnBuffer(cachedFrame, secondaryIdx);
863 swapBuffers();
864 showPrimaryBuffer();
865 activeObjectUrl = cachedFrame.objectUrl;
866 }
867 }
868
869 prewarmSecondaryBuffer(selectedStreamIndex, currentTime, cachedFrame);
870 } else
871 {
872 hideOverlay();
873 }
874 }
875
876 playbackClockSyncHandle = requestFrame(syncOverlayToPlaybackClock);
877 };
878
879 const ensurePlaybackClockSync = () =>
880 {
881 if (selectedStreamIndex === null || trackDisabled) return;
882 if (playbackClockSyncHandle) return;
883 playbackClockSyncHandle = requestFrame(syncOverlayToPlaybackClock);
884 };
885
886 const setSeekMarkerTime = (kind, timeSeconds) =>
887 {
888 const numericTime = Number(timeSeconds);
889 const nextTime = Number.isFinite(numericTime) && numericTime >= 0 ? numericTime : null;
890
891 if (kind === 'requested')
892 {
893 if (nextTime === null)
894 {
895 lastRequestedCaptionStartTimeSeconds = null;
896 } else if (!Number.isFinite(lastRequestedCaptionStartTimeSeconds) || nextTime >= lastRequestedCaptionStartTimeSeconds)
897 {
898 lastRequestedCaptionStartTimeSeconds = nextTime;
899 }
900 } else if (kind === 'received')
901 {
902 if (nextTime === null)
903 {
904 lastReceivedCaptionStartTimeSeconds = null;
905 } else if (!Number.isFinite(lastReceivedCaptionStartTimeSeconds) || nextTime >= lastReceivedCaptionStartTimeSeconds)
906 {
907 lastReceivedCaptionStartTimeSeconds = nextTime;
908 }
909 }
910 };
911
912 const updateSeekBarMarkers = () =>
913 {
914 if (!seekMarkerRequestedEl || !seekMarkerReceivedEl) return;
915
916 const duration = Number(player.duration && player.duration());
917 if (!Number.isFinite(duration) || duration <= 0)
918 {
919 seekMarkerRequestedEl.style.display = 'none';
920 seekMarkerReceivedEl.style.display = 'none';
921 return;
922 }
923
924 const getMarkerRatio = (markerTimeSeconds) =>
925 {
926 if (!Number.isFinite(markerTimeSeconds) || markerTimeSeconds < 0)
927 {
928 return null;
929 }
930
931 return Math.max(0, Math.min(1, markerTimeSeconds / duration));
932 };
933
934 const applyMarker = (markerEl, ratio) =>
935 {
936 if (!Number.isFinite(ratio))
937 {
938 markerEl.style.display = 'none';
939 return;
940 }
941
942 markerEl.style.display = 'block';
943 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
944 };
945
946 const requestedRatio = getMarkerRatio(lastRequestedCaptionStartTimeSeconds);
947 const receivedRatio = getMarkerRatio(lastReceivedCaptionStartTimeSeconds);
948 applyMarker(seekMarkerRequestedEl, requestedRatio);
949 applyMarker(seekMarkerReceivedEl, receivedRatio);
950 };
951
952 const ensureSeekBarMarkers = () =>
953 {
954 if (seekMarkerContainerEl && seekMarkerContainerEl.isConnected)
955 {
956 updateSeekBarMarkers();
957 return;
958 }
959
960 const playerEl = player.el && player.el();
961 if (!playerEl) return;
962
963 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
964 || playerEl.querySelector('.vjs-progress-holder')
965 || playerEl.querySelector('.vjs-progress-control');
966 if (!seekBarEl) return;
967
968 const computedPosition = window.getComputedStyle(seekBarEl).position;
969 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
970
971 seekMarkerContainerEl = document.createElement('div');
972 seekMarkerContainerEl.className = 'vjs-image-subtitle-seek-markers';
973 seekMarkerContainerEl.style.position = 'absolute';
974 seekMarkerContainerEl.style.left = '0';
975 seekMarkerContainerEl.style.right = '0';
976 seekMarkerContainerEl.style.top = '50%';
977 seekMarkerContainerEl.style.height = '10px';
978 seekMarkerContainerEl.style.transform = 'translateY(-50%)';
979 seekMarkerContainerEl.style.pointerEvents = 'none';
980 seekMarkerContainerEl.style.zIndex = '5';
981
982 const buildBracketMarker = (direction) =>
983 {
984 const markerEl = document.createElement('span');
985 markerEl.className = `vjs-image-subtitle-seek-marker vjs-image-subtitle-seek-marker-${direction}`;
986 markerEl.style.position = 'absolute';
987 markerEl.style.top = '50%';
988 markerEl.style.width = '10px';
989 markerEl.style.height = '10px';
990 markerEl.style.transform = 'translate(-50%, -50%)';
991 markerEl.style.color = '#fff';
992 markerEl.style.fontFamily = 'monospace';
993 markerEl.style.fontSize = '12px';
994 markerEl.style.fontWeight = '700';
995 markerEl.style.lineHeight = '10px';
996 markerEl.style.textAlign = 'center';
997 markerEl.style.display = 'none';
998 markerEl.textContent = direction === 'left' ? '[' : ']';
999 markerEl.setAttribute('aria-hidden', 'true');
1000 return markerEl;
1001 };
1002
1003 seekMarkerReceivedEl = buildBracketMarker('left');
1004 seekMarkerRequestedEl = buildBracketMarker('right');
1005 seekMarkerContainerEl.appendChild(seekMarkerReceivedEl);
1006 seekMarkerContainerEl.appendChild(seekMarkerRequestedEl);
1007
1008 seekBarEl.appendChild(seekMarkerContainerEl);
1009 updateSeekBarMarkers();
1010 };
1011
1012 const updateButtonState = () =>
1013 {
1014 if (!buttonEl) return;
1015 const track = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
1016 buttonEl.setAttribute('title', track ? `Image subtitles: ${track.label}` : 'Image subtitles');
1017 buttonEl.setAttribute('aria-pressed', selectedStreamIndex === null ? 'false' : 'true');
1018 };
1019
1020 const updateMenuState = () =>
1021 {
1022 if (!menuEl) return;
1023 const items = menuEl.querySelectorAll('[data-image-subtitle-stream-index]');
1024 for (const itemEl of items)
1025 {
1026 const value = itemEl.getAttribute('data-image-subtitle-stream-index');
1027 const isSelected = value === (selectedStreamIndex === null ? 'off' : String(selectedStreamIndex));
1028 itemEl.classList.toggle('is-selected', isSelected);
1029 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1030 itemEl.style.background = isSelected ? 'rgba(90, 196, 255, 0.28)' : 'transparent';
1031 itemEl.style.fontWeight = isSelected ? '600' : '400';
1032 itemEl.style.boxShadow = isSelected ? 'inset 0 0 0 1px rgba(90, 196, 255, 0.55)' : 'none';
1033 }
1034 };
1035
1036 const closeMenu = () =>
1037 {
1038 menuOpen = false;
1039 if (menuEl) menuEl.style.display = 'none';
1040 };
1041
1042 const openMenu = () =>
1043 {
1044 menuOpen = true;
1045 if (menuEl)
1046 {
1047 updateMenuState();
1048 menuEl.style.display = 'block';
1049 }
1050 };
1051
1052 const toggleMenu = () =>
1053 {
1054 if (menuOpen) closeMenu();
1055 else openMenu();
1056 };
1057
1058 const saveSelection = () =>
1059 {
1060 const selectedTrack = selectedStreamIndex === null ? null : trackByStreamIndex.get(selectedStreamIndex) || null;
1061 savePrefs({
1062 imageSubtitleTrackStreamIndex: selectedStreamIndex,
1063 imageSubtitleTrackName: selectedTrack ? selectedTrack.label : null,
1064 });
1065 };
1066
1067 const disableTrack = () =>
1068 {
1069 trackDisabled = true;
1070 selectedStreamIndex = null;
1071 activeBucket = -1;
1072 stopPlaybackClockSync();
1073 setSeekMarkerTime('requested', null);
1074 setSeekMarkerTime('received', null);
1075 updateSeekBarMarkers();
1076 resetRequestState();
1077 hideOverlay();
1078 updateButtonState();
1079 updateMenuState();
1080 saveSelection();
1081
1082 if (!failureNotified)
1083 {
1084 failureNotified = true;
1085 notifyError();
1086 }
1087 };
1088
1089 const setSelectedStreamIndex = (streamIndex, { persist = true } = {}) =>
1090 {
1091 const nextStreamIndex = Number.isInteger(streamIndex) ? streamIndex : null;
1092 if (nextStreamIndex !== null && !trackByStreamIndex.has(nextStreamIndex)) return;
1093
1094 trackDisabled = false;
1095 failureNotified = false;
1096 selectedStreamIndex = nextStreamIndex;
1097 activeBucket = -1;
1098 setSeekMarkerTime('requested', null);
1099 setSeekMarkerTime('received', null);
1100 updateSeekBarMarkers();
1101 resetRequestState();
1102 hideOverlay();
1103 updateButtonState();
1104 updateMenuState();
1105 if (persist) saveSelection();
1106
1107 if (selectedStreamIndex !== null)
1108 {
1109 ensurePlaybackClockSync();
1110 if (initialPrefetchSeconds > 0)
1111 {
1112 queueLookaheadPrefetch(0, {
1113 reset: true,
1114 includeCurrentTime: true,
1115 maxTargetTimeSeconds: initialPrefetchSeconds,
1116 });
1117 }
1118 void refreshFrame();
1119 }
1120 else
1121 {
1122 stopPlaybackClockSync();
1123 }
1124 };
1125
1126 const queueLookaheadPrefetch = (currentTime, {
1127 reset = false,
1128 includeCurrentTime = false,
1129 maxTargetTimeSeconds = null,
1130 } = {}) =>
1131 {
1132 if (selectedStreamIndex === null) return;
1133 if (trackDisabled) return;
1134
1135 const durationSeconds = Number(player.duration && player.duration());
1136 const knownVideoEndSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0
1137 ? durationSeconds
1138 : null;
1139
1140 const bufferedVideoEndSeconds = (() =>
1141 {
1142 const candidates = [];
1143
1144 const fromPlayer = Number(player.bufferedEnd && player.bufferedEnd());
1145 if (Number.isFinite(fromPlayer) && fromPlayer >= 0) candidates.push(fromPlayer);
1146
1147 const tech = typeof player.tech === 'function' ? player.tech(true) : null;
1148 const mediaEl = tech && typeof tech.el === 'function'
1149 ? tech.el()
1150 : (player.el && player.el() ? player.el().querySelector('video') : null);
1151
1152 const ranges = mediaEl && mediaEl.buffered;
1153 if (ranges && typeof ranges.length === 'number' && ranges.length > 0 && typeof ranges.end === 'function')
1154 {
1155 try
1156 {
1157 const endTime = Number(ranges.end(ranges.length - 1));
1158 if (Number.isFinite(endTime) && endTime >= 0) candidates.push(endTime);
1159 } catch
1160 {
1161 // Ignore buffered range read races.
1162 }
1163 }
1164
1165 if (!candidates.length) return null;
1166 return Math.max(...candidates);
1167 })();
1168
1169 const startTime = includeCurrentTime
1170 ? currentTime
1171 : currentTime + prefetchStepSecondsMin;
1172 const uncappedEndTime = Math.max(
1173 currentTime + lookaheadSeconds,
1174 Number.isFinite(bufferedVideoEndSeconds) ? bufferedVideoEndSeconds : -1,
1175 Number.isFinite(knownVideoEndSeconds) ? knownVideoEndSeconds : -1,
1176 );
1177 const capEndTime = Number.isFinite(maxTargetTimeSeconds) && maxTargetTimeSeconds >= 0
1178 ? maxTargetTimeSeconds
1179 : null;
1180 let endTime = Number.isFinite(capEndTime)
1181 ? Math.min(uncappedEndTime, capEndTime)
1182 : uncappedEndTime;
1183 if (Number.isFinite(knownVideoEndSeconds))
1184 {
1185 endTime = Math.min(endTime, knownVideoEndSeconds);
1186 }
1187 if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || endTime <= startTime) return;
1188
1189 if (reset || prefetchedThroughTimeSeconds < 0)
1190 {
1191 cancelPrefetchRequests({ resetProgress: true });
1192 prefetchedThroughTimeSeconds = includeCurrentTime
1193 ? currentTime - prefetchStepSecondsMin
1194 : currentTime;
1195 } else if (prefetchedThroughTimeSeconds < currentTime)
1196 {
1197 // Keep the prefetch frontier at or ahead of current playback so
1198 // prefetch catches buffered-ahead range instead of replaying stale lag.
1199 prefetchedThroughTimeSeconds = currentTime;
1200 }
1201
1202 prefetchTargetTimeSeconds = Math.max(prefetchTargetTimeSeconds, endTime);
1203 if (prefetchPromise) return;
1204
1205 const workerToken = ++prefetchWorkerToken;
1206 const workerLifecycleToken = lifecycleToken;
1207 const controller = createAbortController();
1208 prefetchAbortController = controller;
1209
1210 prefetchPromise = (async () =>
1211 {
1212 while (true)
1213 {
1214 if (selectedStreamIndex === null || trackDisabled) return;
1215 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
1216
1217 const stepSeconds = getAdaptivePrefetchStepSeconds(Number(player.currentTime()));
1218
1219 const nextTime = prefetchedThroughTimeSeconds < 0
1220 ? startTime
1221 : prefetchedThroughTimeSeconds + stepSeconds;
1222 if (!Number.isFinite(nextTime) || nextTime > prefetchTargetTimeSeconds + 1e-6) return;
1223 const requestedRangeEndTimeSeconds = Math.min(prefetchTargetTimeSeconds, nextTime + stepSeconds);
1224 const prefetchProgressTimeSeconds = prefetchUsesRangeRequests
1225 ? requestedRangeEndTimeSeconds
1226 : nextTime;
1227
1228 const request = buildPrefetchRequest({
1229 streamIndex: selectedStreamIndex,
1230 currentTime: nextTime,
1231 endTime: requestedRangeEndTimeSeconds,
1232 session,
1233 });
1234 if (!request || !request.url) return;
1235
1236 const prefetchRequestStartedAtMs = Date.now();
1237 const prefetchRequestId = `prefetch-${workerToken}-${Math.round(nextTime * 1000)}`;
1238 logSubtitleEvent('subtitle_png_requested', {
1239 requestId: prefetchRequestId,
1240 requestKind: 'prefetch',
1241 requestUrl: String(request.url || ''),
1242 requestedAtMs: prefetchRequestStartedAtMs,
1243 requestedVideoTimeSeconds: roundLogNumber(nextTime),
1244 requestedRangeEndTimeSeconds: roundLogNumber(requestedRangeEndTimeSeconds),
1245 });
1246
1247 let prefetchTimedOut = false;
1248 const timeoutId = armRequestTimeout(controller, prefetchRequestTimeoutMs, () =>
1249 {
1250 prefetchTimedOut = true;
1251 });
1252
1253 try
1254 {
1255 const res = await fetch(request.url, {
1256 method: request.method || 'GET',
1257 headers: request.headers,
1258 credentials: request.credentials,
1259 signal: controller ? controller.signal : undefined,
1260 });
1261 clearRequestTimeout(timeoutId);
1262
1263 if (workerToken !== prefetchWorkerToken || workerLifecycleToken !== lifecycleToken) return;
1264
1265 const responseMeta = {
1266 requestId: prefetchRequestId,
1267 requestKind: 'prefetch',
1268 status: res.status,
1269 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1270 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1271 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1272 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1273 responseHeadersReceivedAtMs: Date.now(),
1274 requestedVideoTimeSeconds: roundLogNumber(nextTime),
1275 requestedRangeEndTimeSeconds: roundLogNumber(requestedRangeEndTimeSeconds),
1276 };
1277 logSubtitleEvent('subtitle_png_sent', {
1278 ...responseMeta,
1279 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1280 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1281 });
1282
1283 setSeekMarkerTime('requested', prefetchProgressTimeSeconds);
1284 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1285 ? responseMeta.shouldShowAtVideoTimeSeconds
1286 : prefetchProgressTimeSeconds;
1287 setSeekMarkerTime('received', receivedMarkerTime);
1288 updateSeekBarMarkers();
1289
1290 if (res.status === 204)
1291 {
1292 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1293 logSubtitleEvent('subtitle_png_not_available', {
1294 ...responseMeta,
1295 frameStatus,
1296 });
1297 if (frameStatus === 'error') return;
1298 prefetchedThroughTimeSeconds = prefetchProgressTimeSeconds;
1299 if (prefetchUsesRangeRequests)
1300 {
1301 setSeekMarkerTime('requested', prefetchedThroughTimeSeconds);
1302 setSeekMarkerTime('received', prefetchedThroughTimeSeconds);
1303 updateSeekBarMarkers();
1304 }
1305 const waitMs = getPrefetchDelayMs(Number(player.currentTime()));
1306 if (waitMs > 0)
1307 {
1308 await new Promise((resolve) => window.setTimeout(resolve, waitMs));
1309 }
1310 continue;
1311 }
1312
1313 if (!res.ok) return;
1314 const receivedAtMs = Date.now();
1315 let cachedFrameEntry = null;
1316 let receivedBlobBytes = 0;
1317
1318 if (/application\/json/i.test(String(res.headers.get('Content-Type') || '')))
1319 {
1320 const body = await res.json().catch(() => null);
1321 if (String(body && body.status || '').toLowerCase() === 'error') return;
1322 const responseFrames = Array.isArray(body && body.frames) ? body.frames : [];
1323 for (const frame of responseFrames)
1324 {
1325 if (!frame) continue;
1326 const blob = base64ToBlob(frame.frameBase64, frame.contentType || 'image/png');
1327 if (!blob || !blob.size) continue;
1328 receivedBlobBytes += Number(blob.size) || 0;
1329 const cached = cacheSubtitleFrame({
1330 streamIndex: selectedStreamIndex,
1331 blob,
1332 metadata: {
1333 startTimeSeconds: Number(frame.startTimeSeconds),
1334 endTimeSeconds: Number(frame.endTimeSeconds),
1335 frameWidth: Number(frame.width),
1336 frameHeight: Number(frame.height),
1337 canvasWidth: Number(frame.canvasWidth),
1338 canvasHeight: Number(frame.canvasHeight),
1339 },
1340 });
1341 if (cached) cachedFrameEntry = cached;
1342 }
1343 responseMeta.shouldShowAtVideoTimeSeconds = Number.isFinite(Number(body && body.startTimeSeconds))
1344 ? Number(body.startTimeSeconds)
1345 : responseMeta.shouldShowAtVideoTimeSeconds;
1346 responseMeta.subtitleEndTimeSeconds = Number.isFinite(Number(body && body.endTimeSeconds))
1347 ? Number(body.endTimeSeconds)
1348 : responseMeta.subtitleEndTimeSeconds;
1349 } else
1350 {
1351 const payload = await res.arrayBuffer();
1352 receivedBlobBytes = Number(payload && payload.byteLength || 0);
1353 const metadata = parseFrameMetadata(res, nextTime, stepSeconds);
1354 const blob = new Blob([payload], {
1355 type: String(res.headers.get('Content-Type') || '').trim() || 'image/png',
1356 });
1357 cachedFrameEntry = cacheSubtitleFrame({
1358 streamIndex: selectedStreamIndex,
1359 blob,
1360 metadata,
1361 });
1362 }
1363
1364 // When foreground fetches are disabled, current-time rendering is
1365 // cache-only and may otherwise wait for a later timeupdate tick.
1366 // Render immediately if this prefetched frame covers current time.
1367 if (cachedFrameEntry)
1368 {
1369 const nowTime = Number(player.currentTime());
1370 if (Number.isFinite(nowTime) && nowTime >= 0)
1371 {
1372 const cachedForCurrentTime = findCachedFrameForTime(selectedStreamIndex, nowTime);
1373 if (cachedForCurrentTime)
1374 {
1375 renderSubtitleFrame(cachedForCurrentTime);
1376 }
1377 }
1378 }
1379
1380 logSubtitleEvent('subtitle_png_received', {
1381 ...responseMeta,
1382 receivedAtMs,
1383 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1384 requestedToReceivedMs: diffMilliseconds(receivedAtMs, prefetchRequestStartedAtMs),
1385 blobBytes: receivedBlobBytes,
1386 });
1387 prefetchedThroughTimeSeconds = prefetchProgressTimeSeconds;
1388 if (prefetchUsesRangeRequests)
1389 {
1390 setSeekMarkerTime('requested', prefetchedThroughTimeSeconds);
1391 setSeekMarkerTime('received', prefetchedThroughTimeSeconds);
1392 updateSeekBarMarkers();
1393 }
1394 const waitMs = getPrefetchDelayMs(Number(player.currentTime()));
1395 if (waitMs > 0)
1396 {
1397 await new Promise((resolve) => window.setTimeout(resolve, waitMs));
1398 }
1399 } catch (error)
1400 {
1401 clearRequestTimeout(timeoutId);
1402 if (prefetchTimedOut)
1403 {
1404 logSubtitleEvent('subtitle_png_request_failed', {
1405 requestId: prefetchRequestId,
1406 requestKind: 'prefetch',
1407 requestedAtMs: prefetchRequestStartedAtMs,
1408 errorName: 'AbortError',
1409 errorMessage: `Prefetch subtitle request timed out after ${Math.round(prefetchRequestTimeoutMs)}ms`,
1410 });
1411 return;
1412 }
1413 if (isAbortError(error)) return;
1414 logSubtitleEvent('subtitle_png_request_failed', {
1415 requestId: prefetchRequestId,
1416 requestKind: 'prefetch',
1417 requestedAtMs: prefetchRequestStartedAtMs,
1418 errorName: error && error.name ? String(error.name) : null,
1419 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1420 });
1421 return;
1422 }
1423 }
1424 })().finally(() =>
1425 {
1426 if (workerToken !== prefetchWorkerToken) return;
1427 prefetchAbortController = null;
1428 prefetchPromise = null;
1429 });
1430 };
1431
1432 const refreshFrame = async (force = false, allowCurrentFetchOverride = false, preservePrefetchState = false) =>
1433 {
1434 if (selectedStreamIndex === null) return;
1435 if (!overlayEl || !overlayImgEl) return;
1436 if (trackDisabled) return;
1437
1438 if (currentFramePromise && !force)
1439 {
1440 queuedCurrentRefresh = true;
1441 return;
1442 }
1443
1444 const currentTime = Number(player.currentTime());
1445 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1446
1447 const bucket = Math.floor(currentTime * 4);
1448 if (!force && bucket === activeBucket) return;
1449 activeBucket = bucket;
1450
1451 const cachedFrame = findCachedFrameForTime(selectedStreamIndex, currentTime);
1452 if (cachedFrame)
1453 {
1454 setSeekMarkerTime('requested', currentTime);
1455 setSeekMarkerTime('received', cachedFrame.startTimeSeconds);
1456 updateSeekBarMarkers();
1457 renderSubtitleFrame(cachedFrame);
1458 queueLookaheadPrefetch(currentTime, { reset: force });
1459 return;
1460 }
1461
1462 if (!currentFetchEnabled && !allowCurrentFetchOverride)
1463 {
1464 hideOverlay();
1465 const nowMs = Date.now();
1466 const shouldFallbackFetch = cacheMissFallbackEnabled
1467 && nowMs - lastCacheMissFallbackAtMs >= cacheMissFallbackIntervalMs;
1468 if (shouldFallbackFetch)
1469 {
1470 lastCacheMissFallbackAtMs = nowMs;
1471 logSubtitleEvent('subtitle_cache_miss_fallback_fetch', {
1472 requestKind: 'current',
1473 requestedAtMs: nowMs,
1474 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1475 });
1476 // Safety net for occasional cache key/window mismatches.
1477 // Uses normal current-frame path but does not reset prefetch state,
1478 // so background subtitle lead can continue growing while playing.
1479 return refreshFrame(true, true, true);
1480 }
1481 queueLookaheadPrefetch(currentTime, {
1482 reset: force,
1483 includeCurrentTime: true,
1484 });
1485 return;
1486 }
1487
1488 const refreshLifecycleToken = lifecycleToken;
1489 if (force && currentFramePromise)
1490 {
1491 cancelCurrentFrameRequest();
1492 }
1493 if (currentFramePromise)
1494 {
1495 queuedCurrentRefresh = true;
1496 queuedCurrentRefreshForce = queuedCurrentRefreshForce || !!force;
1497 return;
1498 }
1499 cancelCurrentFrameRequest();
1500 if (force && !preservePrefetchState) cancelPrefetchRequests({ resetProgress: true });
1501
1502 const token = ++currentFrameToken;
1503 const requestId = `current-${token}`;
1504 const requestStartedAtMs = Date.now();
1505 const controller = createAbortController();
1506 currentFrameAbortController = controller;
1507 const request = buildFrameRequest({
1508 streamIndex: selectedStreamIndex,
1509 currentTime,
1510 session,
1511 });
1512
1513 if (!request || !request.url)
1514 {
1515 disableTrack();
1516 return;
1517 }
1518
1519 logSubtitleEvent('subtitle_png_requested', {
1520 requestId,
1521 requestKind: 'current',
1522 requestUrl: String(request.url || ''),
1523 requestedAtMs: requestStartedAtMs,
1524 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1525 });
1526
1527 const frameRequestPromise = (async () =>
1528 {
1529 let currentTimedOut = false;
1530 const timeoutId = armRequestTimeout(controller, currentRequestTimeoutMs, () =>
1531 {
1532 currentTimedOut = true;
1533 });
1534 try
1535 {
1536 const res = await fetch(request.url, {
1537 method: request.method || 'GET',
1538 headers: request.headers,
1539 credentials: request.credentials,
1540 signal: controller ? controller.signal : undefined,
1541 });
1542 clearRequestTimeout(timeoutId);
1543
1544 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1545
1546 const responseMeta = {
1547 requestId,
1548 requestKind: 'current',
1549 status: res.status,
1550 serverRequestReceivedAtMs: parseHeaderInt(res, 'X-Subtitle-Request-Received-At-Ms'),
1551 serverResponseSentAtMs: parseHeaderInt(res, 'X-Subtitle-Response-Sent-At-Ms'),
1552 shouldShowAtVideoTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-Start-Time'),
1553 subtitleEndTimeSeconds: parseHeaderFloat(res, 'X-Subtitle-Frame-End-Time'),
1554 responseHeadersReceivedAtMs: Date.now(),
1555 requestedVideoTimeSeconds: roundLogNumber(currentTime),
1556 };
1557 logSubtitleEvent('subtitle_png_sent', {
1558 ...responseMeta,
1559 serverProcessingMs: diffMilliseconds(responseMeta.serverResponseSentAtMs, responseMeta.serverRequestReceivedAtMs),
1560 sentToHeadersReceivedMs: diffMilliseconds(responseMeta.responseHeadersReceivedAtMs, responseMeta.serverResponseSentAtMs),
1561 });
1562
1563 setSeekMarkerTime('requested', currentTime);
1564 const receivedMarkerTime = Number.isFinite(responseMeta.shouldShowAtVideoTimeSeconds)
1565 ? responseMeta.shouldShowAtVideoTimeSeconds
1566 : currentTime;
1567 setSeekMarkerTime('received', receivedMarkerTime);
1568 updateSeekBarMarkers();
1569
1570 if (res.status === 204)
1571 {
1572 const frameStatus = String(res.headers.get('X-Subtitle-Frame-Status') || '').toLowerCase();
1573 logSubtitleEvent('subtitle_png_not_available', {
1574 ...responseMeta,
1575 frameStatus,
1576 });
1577 hideOverlay();
1578 if (frameStatus === 'error') disableTrack();
1579 else queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1580 return;
1581 }
1582
1583 if (!res.ok)
1584 {
1585 disableTrack();
1586 return;
1587 }
1588
1589 const blob = await res.blob();
1590 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1591
1592 const receivedAtMs = Date.now();
1593 logSubtitleEvent('subtitle_png_received', {
1594 ...responseMeta,
1595 receivedAtMs,
1596 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1597 requestedToReceivedMs: diffMilliseconds(receivedAtMs, requestStartedAtMs),
1598 blobBytes: Number(blob && blob.size || 0),
1599 });
1600
1601 if (!blob || blob.size === 0)
1602 {
1603 disableTrack();
1604 return;
1605 }
1606 const cachedFrameEntry = cacheSubtitleFrame({
1607 streamIndex: selectedStreamIndex,
1608 blob,
1609 metadata: parseFrameMetadata(res, currentTime, prefetchStepSecondsMin),
1610 });
1611 if (cachedFrameEntry) renderSubtitleFrame(cachedFrameEntry);
1612
1613 void waitForImagePresentation(window, overlayImgEl).then((shownAtMs) =>
1614 {
1615 if (token !== currentFrameToken || refreshLifecycleToken !== lifecycleToken) return;
1616 const shownAtVideoTimeSeconds = roundLogNumber(player.currentTime());
1617 logSubtitleEvent('subtitle_png_shown', {
1618 ...responseMeta,
1619 receivedAtMs,
1620 shownAtMs,
1621 shownAtVideoTimeSeconds,
1622 sentToReceivedMs: diffMilliseconds(receivedAtMs, responseMeta.serverResponseSentAtMs),
1623 receivedToShownMs: diffMilliseconds(shownAtMs, receivedAtMs),
1624 shouldVsShownDiffSeconds: diffSeconds(shownAtVideoTimeSeconds, responseMeta.shouldShowAtVideoTimeSeconds),
1625 });
1626 });
1627
1628 queueLookaheadPrefetch(currentTime, { reset: force && !preservePrefetchState });
1629 } catch (error)
1630 {
1631 clearRequestTimeout(timeoutId);
1632 if (currentTimedOut)
1633 {
1634 logSubtitleEvent('subtitle_png_request_failed', {
1635 requestId,
1636 requestKind: 'current',
1637 requestedAtMs: requestStartedAtMs,
1638 errorName: 'AbortError',
1639 errorMessage: `Current subtitle request timed out after ${Math.round(currentRequestTimeoutMs)}ms`,
1640 });
1641 return;
1642 }
1643 if (isAbortError(error)) return;
1644 logSubtitleEvent('subtitle_png_request_failed', {
1645 requestId,
1646 requestKind: 'current',
1647 requestedAtMs: requestStartedAtMs,
1648 errorName: error && error.name ? String(error.name) : null,
1649 errorMessage: error && error.message ? String(error.message) : String(error || ''),
1650 });
1651 if (token === currentFrameToken && refreshLifecycleToken === lifecycleToken) disableTrack();
1652 }
1653 })();
1654
1655 currentFramePromise = frameRequestPromise;
1656 frameRequestPromise.finally(() =>
1657 {
1658 if (currentFramePromise !== frameRequestPromise) return;
1659 currentFrameAbortController = null;
1660 currentFramePromise = null;
1661 if (!queuedCurrentRefresh) return;
1662
1663 const queuedForce = queuedCurrentRefreshForce;
1664 queuedCurrentRefresh = false;
1665 queuedCurrentRefreshForce = false;
1666 void refreshFrame(queuedForce);
1667 });
1668
1669 return currentFramePromise;
1670 };
1671
1672 const dispose = () =>
1673 {
1674 stopPlaybackClockSync();
1675 resetRequestState();
1676 flushSubtitleLogs();
1677 closeMenu();
1678 hideOverlay();
1679 if (seekMarkerContainerEl) seekMarkerContainerEl.remove();
1680 seekMarkerContainerEl = null;
1681 seekMarkerRequestedEl = null;
1682 seekMarkerReceivedEl = null;
1683 revokeCachedFrameUrls();
1684 if (overlayEl) overlayEl.remove();
1685 if (menuEl) menuEl.remove();
1686 player.imageSubtitleOverlayController = null;
1687 buttonEl = null;
1688 };
1689
1690 overlayEl = document.createElement('div');
1691 overlayEl.className = 'video-subtitle-overlay';
1692 overlayEl.style.position = 'absolute';
1693 overlayEl.style.left = '0';
1694 overlayEl.style.right = '0';
1695 overlayEl.style.bottom = '3rem';
1696 overlayEl.style.display = 'none';
1697 overlayEl.style.zIndex = '3';
1698 overlayEl.style.pointerEvents = 'none';
1699 overlayEl.style.textAlign = 'center';
1700 overlayEl.style.padding = '0 0.75rem';
1701 overlayEl.style.maxHeight = '70%';
1702 overlayEl.style.overflow = 'hidden';
1703
1704 overlayImgEl = document.createElement('img');
1705 overlayImgEl.alt = 'Image subtitles';
1706 overlayImgEl.style.display = 'none';
1707 overlayImgEl.style.margin = '0 auto';
1708 overlayImgEl.style.objectFit = 'contain';
1709 overlayImgEl.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1710 overlayImgEl.style.maxWidth = '100%';
1711 overlayImgEl.style.height = 'auto';
1712 overlayEl.appendChild(overlayImgEl);
1713
1714 overlayImgElSecondary = document.createElement('img');
1715 overlayImgElSecondary.alt = 'Image subtitles (buffered)';
1716 overlayImgElSecondary.style.display = 'none';
1717 overlayImgElSecondary.style.margin = '0 auto';
1718 overlayImgElSecondary.style.objectFit = 'contain';
1719 overlayImgElSecondary.style.filter = 'drop-shadow(0 2px 2px rgba(0, 0, 0, 0.7))';
1720 overlayImgElSecondary.style.maxWidth = '100%';
1721 overlayImgElSecondary.style.height = 'auto';
1722 overlayEl.appendChild(overlayImgElSecondary);
1723
1724 menuEl = document.createElement('div');
1725 menuEl.className = 'video-subtitle-overlay-menu';
1726 menuEl.style.position = 'absolute';
1727 menuEl.style.right = '0.75rem';
1728 menuEl.style.bottom = 'calc(3rem + 0.5rem)';
1729 menuEl.style.minWidth = '14rem';
1730 menuEl.style.maxWidth = '20rem';
1731 menuEl.style.background = 'rgba(12, 12, 12, 0.96)';
1732 menuEl.style.border = '1px solid rgba(255, 255, 255, 0.15)';
1733 menuEl.style.borderRadius = '0.5rem';
1734 menuEl.style.boxShadow = '0 12px 28px rgba(0, 0, 0, 0.35)';
1735 menuEl.style.padding = '0.35rem';
1736 menuEl.style.display = 'none';
1737 menuEl.style.zIndex = '4';
1738
1739 const buildMenuItem = (label, streamIndex, isSelected) =>
1740 {
1741 const itemEl = document.createElement('button');
1742 itemEl.type = 'button';
1743 itemEl.className = 'video-subtitle-overlay-menu-item';
1744 itemEl.setAttribute('data-image-subtitle-stream-index', streamIndex === null ? 'off' : String(streamIndex));
1745 itemEl.setAttribute('aria-checked', isSelected ? 'true' : 'false');
1746 itemEl.style.display = 'block';
1747 itemEl.style.width = '100%';
1748 itemEl.style.margin = '0';
1749 itemEl.style.padding = '0.5rem 0.75rem';
1750 itemEl.style.border = '0';
1751 itemEl.style.borderRadius = '0.35rem';
1752 itemEl.style.background = isSelected ? 'rgba(255, 255, 255, 0.18)' : 'transparent';
1753 itemEl.style.color = '#fff';
1754 itemEl.style.textAlign = 'left';
1755 itemEl.style.cursor = 'pointer';
1756 itemEl.textContent = label;
1757 itemEl.addEventListener('click', () =>
1758 {
1759 setSelectedStreamIndex(streamIndex);
1760 closeMenu();
1761 });
1762 return itemEl;
1763 };
1764
1765 menuEl.appendChild(buildMenuItem('Off', null, false));
1766 for (const track of imageTracks)
1767 {
1768 menuEl.appendChild(buildMenuItem(track.label, track.streamIndex, false));
1769 }
1770
1771 const registerButton = () =>
1772 {
1773 if (!videojs || typeof videojs.getComponent !== 'function' || typeof videojs.registerComponent !== 'function') return;
1774 if (videojs.getComponent('ImageSubtitleButton')) return;
1775
1776 const Button = videojs.getComponent('Button');
1777 class ImageSubtitleButton extends Button
1778 {
1779 buildCSSClass ()
1780 {
1781 return `${super.buildCSSClass()} vjs-image-subtitle-button`;
1782 }
1783
1784 createEl ()
1785 {
1786 const el = super.createEl();
1787 el.type = 'button';
1788 el.setAttribute('title', 'Image subtitles');
1789 el.setAttribute('aria-label', 'Image subtitles');
1790 el.innerHTML = '<span aria-hidden="true">IM</span>';
1791 return el;
1792 }
1793
1794 handleClick ()
1795 {
1796 const controller = this.player().imageSubtitleOverlayController;
1797 if (controller) controller.toggleMenu();
1798 }
1799 }
1800
1801 videojs.registerComponent('ImageSubtitleButton', ImageSubtitleButton);
1802 };
1803
1804 const attachUi = () =>
1805 {
1806 if (!player.el()) return;
1807 registerButton();
1808 if (overlayEl.parentElement !== player.el()) player.el().appendChild(overlayEl);
1809 if (menuEl.parentElement !== player.el()) player.el().appendChild(menuEl);
1810 const controlBar = typeof player.getChild === 'function' ? player.getChild('controlBar') : null;
1811 if (controlBar && typeof controlBar.addChild === 'function' && !buttonEl)
1812 {
1813 const button = controlBar.addChild('ImageSubtitleButton', {});
1814 buttonEl = button && typeof button.el === 'function' ? button.el() : null;
1815 updateButtonState();
1816 }
1817 };
1818
1819 const applySavedTracks = () =>
1820 {
1821 const savedName = normaliseTrackName(prefs.imageSubtitleTrackName);
1822 if (savedName)
1823 {
1824 const savedByName = imageTracks.find((track) => normaliseTrackName(track.label) === savedName) || null;
1825 if (savedByName)
1826 {
1827 setSelectedStreamIndex(savedByName.streamIndex, { persist: false });
1828 return;
1829 }
1830 }
1831
1832 const savedIndex = Number(prefs.imageSubtitleTrackStreamIndex);
1833 if (Number.isInteger(savedIndex) && trackByStreamIndex.has(savedIndex))
1834 {
1835 setSelectedStreamIndex(savedIndex, { persist: false });
1836 return;
1837 }
1838
1839 const defaultTrack = imageTracks.find((track) => track.isDefault) || null;
1840 if (defaultTrack)
1841 {
1842 setSelectedStreamIndex(defaultTrack.streamIndex, { persist: false });
1843 return;
1844 }
1845
1846 setSelectedStreamIndex(null, { persist: false });
1847 };
1848
1849 player.imageSubtitleOverlayController = {
1850 toggleMenu,
1851 closeMenu,
1852 applySavedTracks,
1853 captureSelectedTracks: saveSelection,
1854 detach: dispose,
1855 };
1856
1857 player.on('timeupdate', () => { void refreshFrame(); });
1858 player.on('seeking', () => { void refreshFrame(true); });
1859 player.on('play', () => { void refreshFrame(true); });
1860 player.on('play', ensurePlaybackClockSync);
1861 player.on('pause', stopPlaybackClockSync);
1862 player.on('ended', stopPlaybackClockSync);
1863 player.on('fullscreenchange', () => { closeMenu(); void refreshFrame(true); });
1864 player.on('dispose', dispose);
1865 player.ready(() =>
1866 {
1867 attachUi();
1868 ensureSeekBarMarkers();
1869 updateMenuState();
1870 updateButtonState();
1871 updateSeekBarMarkers();
1872 applySavedTracks();
1873 if (menuOpen) openMenu();
1874 });
1875
1876 const onDurationHints = () =>
1877 {
1878 ensureSeekBarMarkers();
1879 updateSeekBarMarkers();
1880
1881 if (selectedStreamIndex === null || trackDisabled) return;
1882 const currentTime = Number(player.currentTime());
1883 if (!Number.isFinite(currentTime) || currentTime < 0) return;
1884
1885 queueLookaheadPrefetch(currentTime, {
1886 includeCurrentTime: true,
1887 });
1888 };
1889
1890 player.on('durationchange', onDurationHints);
1891 player.on('loadedmetadata', onDurationHints);
1892
1893 return player.imageSubtitleOverlayController;
1894 }
1895
1896 function formatDurationForDebug (seconds)
1897 {
1898 const value = Number(seconds);
1899 if (!Number.isFinite(value) || value < 0) return 'unknown';
1900
1901 const totalSeconds = Math.floor(value);
1902 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
1903 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
1904 const ss = String(totalSeconds % 60).padStart(2, '0');
1905 return `${hh}:${mm}:${ss}`;
1906 }
1907
1908 function installDurationFallback (player, originalDuration, duration)
1909 {
1910 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
1911
1912 player.__filemanagerDurationFallback = true;
1913 player.duration = function durationWithFallback (...args)
1914 {
1915 if (args.length) return originalDuration(...args);
1916 const current = Number(originalDuration());
1917 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
1918 };
1919 }
1920
1921 function normaliseVideoDuration (player, durationSeconds)
1922 {
1923 const duration = Number(durationSeconds);
1924 if (!player || !Number.isFinite(duration) || duration <= 0) return;
1925
1926 let originalDuration = null;
1927 let durationWasChanged = false;
1928 try
1929 {
1930 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
1931 installDurationFallback(player, originalDuration, duration);
1932 if (player.__filemanagerDurationApplied) return;
1933
1934 const current = originalDuration ? Number(originalDuration()) : NaN;
1935 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
1936 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
1937 if (withinTolerance)
1938 {
1939 player.__filemanagerDurationApplied = true;
1940 return;
1941 }
1942
1943 if (originalDuration)
1944 {
1945 durationWasChanged = true;
1946 originalDuration(duration);
1947 }
1948 } catch
1949 {
1950 // Ignore players that do not support setting duration.
1951 }
1952
1953 try
1954 {
1955 const updated = originalDuration ? Number(originalDuration()) : NaN;
1956 if (Number.isFinite(updated) && updated >= duration * 0.95)
1957 {
1958 player.__filemanagerDurationApplied = true;
1959 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
1960 return;
1961 }
1962
1963 player.__filemanagerDurationApplied = true;
1964 if (typeof player.trigger === 'function') player.trigger('durationchange');
1965 } catch
1966 {
1967 // Ignore duration fallback failures.
1968 }
1969 }
1970
1971 function ensureVideoPlaybackUi (player, durationSeconds)
1972 {
1973 if (!player || typeof player.on !== 'function') return;
1974
1975 const forceVodUi = () =>
1976 {
1977 normaliseVideoDuration(player, durationSeconds);
1978
1979 try
1980 {
1981 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
1982 {
1983 player.liveTracker.stopTracking();
1984 }
1985 } catch
1986 {
1987 // Ignore live tracker availability issues.
1988 }
1989
1990 try
1991 {
1992 if (typeof player.removeClass === 'function')
1993 {
1994 player.removeClass('vjs-live');
1995 }
1996 } catch
1997 {
1998 // Ignore class update failures.
1999 }
2000
2001 try
2002 {
2003 const display = player.el && player.el() && player.el().querySelector('.vjs-live-display');
2004 if (display) display.style.display = 'none';
2005 } catch
2006 {
2007 // Ignore missing DOM.
2008 }
2009 };
2010
2011 player.ready(forceVodUi);
2012 player.on('loadedmetadata', forceVodUi);
2013 player.on('durationchange', forceVodUi);
2014 player.on('loadedplaylist', forceVodUi);
2015 }
2016
2017 function configureVideoJsBuffering (videojs, opts = {})
2018 {
2019 if (opts.enabled === false) return;
2020 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
2021 videojs.__filemanagerBufferingConfigured = true;
2022
2023 const seconds = Number(opts.seconds);
2024 const bufferSeconds = Number.isFinite(seconds) && seconds > 0 ? seconds : 60 * 60;
2025
2026 try
2027 {
2028 videojs.Vhs.GOAL_BUFFER_LENGTH = bufferSeconds;
2029 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = bufferSeconds;
2030 videojs.Vhs.BUFFER_LOW_WATER_LINE = Math.max(30, Math.floor(bufferSeconds / 2));
2031 videojs.Vhs.MAX_BUFFER_LOW_WATER_LINE = bufferSeconds;
2032 } catch
2033 {
2034 // Ignore builds that do not expose VHS buffer configuration.
2035 }
2036 }
2037
2038 function enableVideoStreamClientCache ()
2039 {
2040 if (typeof navigator === 'undefined' || !navigator.serviceWorker || typeof navigator.serviceWorker.register !== 'function')
2041 {
2042 return Promise.resolve(false);
2043 }
2044
2045 if (window.__filemanagerVideoStreamCacheSwPromise)
2046 {
2047 return window.__filemanagerVideoStreamCacheSwPromise;
2048 }
2049
2050 window.__filemanagerVideoStreamCacheSwPromise = navigator.serviceWorker.register(VIDEO_STREAM_CACHE_SW_URL, {
2051 scope: '/',
2052 updateViaCache: 'none',
2053 }).then(() => true).catch(() => false);
2054
2055 return window.__filemanagerVideoStreamCacheSwPromise;
2056 }
2057
2058 function videoStreamCachePrefixFromPlaylistUrl (playlistUrl)
2059 {
2060 const raw = String(playlistUrl || '').trim();
2061 if (!raw) return null;
2062
2063 let parsed = null;
2064 try
2065 {
2066 parsed = new URL(raw, window.location.origin);
2067 } catch
2068 {
2069 return null;
2070 }
2071
2072 const pathname = String(parsed.pathname || '');
2073 if (!pathname) return null;
2074 const lastSlashIndex = pathname.lastIndexOf('/');
2075 const basePath = lastSlashIndex >= 0 ? pathname.slice(0, lastSlashIndex + 1) : '/';
2076 return `${parsed.origin}${basePath}`;
2077 }
2078
2079 function clearVideoStreamClientCache (playlistUrl)
2080 {
2081 const prefix = videoStreamCachePrefixFromPlaylistUrl(playlistUrl);
2082 if (!prefix || typeof caches === 'undefined' || typeof caches.open !== 'function')
2083 {
2084 return Promise.resolve();
2085 }
2086
2087 return caches.open(VIDEO_STREAM_CACHE_NAME).then(async (cache) =>
2088 {
2089 const requests = await cache.keys();
2090 const deletions = [];
2091 for (const request of requests)
2092 {
2093 const requestUrl = request && request.url ? String(request.url) : '';
2094 if (!requestUrl.startsWith(prefix)) continue;
2095 deletions.push(cache.delete(request));
2096 }
2097 await Promise.all(deletions);
2098 }).catch(() =>
2099 {
2100 // Keep cache cleanup best-effort only.
2101 });
2102 }
2103
2104 function parseHlsManifest (manifestText)
2105 {
2106 const lines = String(manifestText || '').split(/\r?\n/);
2107 const childPlaylists = [];
2108 const mediaAssets = [];
2109 const mediaSegmentUris = [];
2110 const mediaSegments = [];
2111 let expectPlaylistUri = false;
2112 let segmentCursorSeconds = 0;
2113 let pendingSegmentDurationSeconds = null;
2114
2115 for (const rawLine of lines)
2116 {
2117 const line = String(rawLine || '').trim();
2118 if (!line) continue;
2119
2120 if (line.startsWith('#'))
2121 {
2122 if (/^#EXT-X-STREAM-INF/i.test(line))
2123 {
2124 expectPlaylistUri = true;
2125 continue;
2126 }
2127
2128 const segmentDurationMatch = line.match(/^#EXTINF\s*:\s*([0-9]+(?:\.[0-9]+)?)/i);
2129 if (segmentDurationMatch)
2130 {
2131 const parsed = Number.parseFloat(segmentDurationMatch[1]);
2132 pendingSegmentDurationSeconds = Number.isFinite(parsed) && parsed > 0
2133 ? parsed
2134 : VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2135 continue;
2136 }
2137
2138 const mapMatch = line.match(/^#EXT-X-MAP\s*:\s*.*?URI="([^"]+)"/i);
2139 if (mapMatch && mapMatch[1]) mediaAssets.push(mapMatch[1]);
2140 continue;
2141 }
2142
2143 if (expectPlaylistUri || /\.m3u8(?:$|\?)/i.test(line))
2144 {
2145 childPlaylists.push(line);
2146 expectPlaylistUri = false;
2147 } else
2148 {
2149 mediaAssets.push(line);
2150 mediaSegmentUris.push(line);
2151 if (Number.isFinite(pendingSegmentDurationSeconds) && pendingSegmentDurationSeconds > 0)
2152 {
2153 const startTimeSeconds = segmentCursorSeconds;
2154 segmentCursorSeconds += pendingSegmentDurationSeconds;
2155 mediaSegments.push({
2156 uri: line,
2157 startTimeSeconds,
2158 endTimeSeconds: segmentCursorSeconds,
2159 });
2160 }
2161 pendingSegmentDurationSeconds = null;
2162 }
2163 }
2164
2165 return {
2166 childPlaylists,
2167 mediaAssets,
2168 mediaSegmentUris,
2169 mediaSegments,
2170 endList: /#EXT-X-ENDLIST/i.test(String(manifestText || '')),
2171 };
2172 }
2173
2174 function inferSegmentEndSecondsFromAssetUrl (assetUrl)
2175 {
2176 const value = String(assetUrl || '');
2177 if (!value) return null;
2178
2179 let pathname = value;
2180 try
2181 {
2182 pathname = new URL(value, window.location.href).pathname || value;
2183 } catch
2184 {
2185 // Ignore URL parsing failures and fall back to raw value matching.
2186 }
2187
2188 const match = pathname.match(/_segment_(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i)
2189 || pathname.match(/(?:^|[/._-])seg(?:ment)?[_-]?(\d+)(?:\.[a-z0-9]+)?(?:$|\?)/i);
2190 if (!match) return null;
2191
2192 const segmentIndex = Number.parseInt(match[1], 10);
2193 if (!Number.isInteger(segmentIndex) || segmentIndex < 0) return null;
2194 return (segmentIndex + 1) * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2195 }
2196
2197 function bindStreamAheadSeekMarker (player, streamAheadPrefetch, opts = {})
2198 {
2199 if (!player || typeof player.on !== 'function' || !streamAheadPrefetch) return null;
2200
2201 const markerChar = String(opts.markerChar || ':').slice(0, 1) || ':';
2202 const markerColor = String(opts.markerColor || '#d6d6d6');
2203 const showTimeTooltip = opts.showTimeTooltip === true;
2204 let markerEl = null;
2205 let markerContainerEl = null;
2206 let cachedThroughSeconds = null;
2207 let cachedThroughRatio = null;
2208 let detachProgressListener = null;
2209
2210 const currentDuration = () =>
2211 {
2212 const duration = Number(player.duration && player.duration());
2213 return Number.isFinite(duration) && duration > 0 ? duration : null;
2214 };
2215
2216 const updateMarker = () =>
2217 {
2218 if (!markerEl) return;
2219
2220 const duration = currentDuration();
2221 if (!duration || !Number.isFinite(cachedThroughSeconds) || cachedThroughSeconds < 0)
2222 {
2223 markerEl.style.display = 'none';
2224 return;
2225 }
2226
2227 const ratioFromSeconds = Number.isFinite(cachedThroughSeconds)
2228 ? Math.max(0, Math.min(1, cachedThroughSeconds / duration))
2229 : null;
2230 const ratioFromSections = Number.isFinite(cachedThroughRatio)
2231 ? Math.max(0, Math.min(1, cachedThroughRatio))
2232 : null;
2233 const ratio = Number.isFinite(ratioFromSeconds)
2234 ? ratioFromSeconds
2235 : ratioFromSections;
2236 if (!Number.isFinite(ratio) || ratio <= 0)
2237 {
2238 markerEl.style.display = 'none';
2239 return;
2240 }
2241
2242 markerEl.style.display = 'block';
2243 markerEl.style.left = `${(ratio * 100).toFixed(4)}%`;
2244 if (showTimeTooltip)
2245 {
2246 if (Number.isFinite(cachedThroughSeconds))
2247 {
2248 markerEl.title = `Walker cached through ${formatClockTime(cachedThroughSeconds)}`;
2249 } else if (Number.isFinite(cachedThroughRatio))
2250 {
2251 markerEl.title = `Walker cached through ${Math.round(cachedThroughRatio * 100)}%`;
2252 } else
2253 {
2254 markerEl.title = 'Walker cached through';
2255 }
2256 } else
2257 {
2258 markerEl.removeAttribute('title');
2259 }
2260 };
2261
2262 const ensureMarker = () =>
2263 {
2264 if (markerContainerEl && markerContainerEl.isConnected)
2265 {
2266 updateMarker();
2267 return;
2268 }
2269
2270 const playerEl = player.el && player.el();
2271 if (!playerEl) return;
2272
2273 const seekBarEl = playerEl.querySelector('.vjs-seek-bar')
2274 || playerEl.querySelector('.vjs-progress-holder')
2275 || playerEl.querySelector('.vjs-progress-control');
2276 if (!seekBarEl) return;
2277
2278 const computedPosition = window.getComputedStyle(seekBarEl).position;
2279 if (computedPosition === 'static') seekBarEl.style.position = 'relative';
2280
2281 markerContainerEl = document.createElement('div');
2282 markerContainerEl.className = 'vjs-stream-ahead-cache-marker-container';
2283 markerContainerEl.style.position = 'absolute';
2284 markerContainerEl.style.left = '0';
2285 markerContainerEl.style.right = '0';
2286 markerContainerEl.style.top = '50%';
2287 markerContainerEl.style.height = '10px';
2288 markerContainerEl.style.transform = 'translateY(-50%)';
2289 markerContainerEl.style.pointerEvents = 'none';
2290 markerContainerEl.style.zIndex = '4';
2291
2292 markerEl = document.createElement('span');
2293 markerEl.className = 'vjs-stream-ahead-cache-marker';
2294 markerEl.style.position = 'absolute';
2295 markerEl.style.top = '50%';
2296 markerEl.style.width = '10px';
2297 markerEl.style.height = '10px';
2298 markerEl.style.transform = 'translate(-50%, -50%)';
2299 markerEl.style.color = markerColor;
2300 markerEl.style.fontFamily = 'monospace';
2301 markerEl.style.fontSize = '12px';
2302 markerEl.style.fontWeight = '700';
2303 markerEl.style.lineHeight = '10px';
2304 markerEl.style.textAlign = 'center';
2305 markerEl.style.display = 'none';
2306 markerEl.style.textShadow = '0 0 2px rgba(0, 0, 0, 0.65)';
2307 markerEl.textContent = markerChar;
2308 markerEl.setAttribute('aria-hidden', 'true');
2309 if (showTimeTooltip)
2310 {
2311 markerEl.title = 'Walker cached through 00:00';
2312 }
2313
2314 markerContainerEl.appendChild(markerEl);
2315 seekBarEl.appendChild(markerContainerEl);
2316 updateMarker();
2317 };
2318
2319 const onDurationHint = () =>
2320 {
2321 ensureMarker();
2322 updateMarker();
2323 };
2324
2325 player.on('loadedmetadata', onDurationHint);
2326 player.on('durationchange', onDurationHint);
2327 player.on('loadedplaylist', onDurationHint);
2328 player.ready(onDurationHint);
2329
2330 if (typeof streamAheadPrefetch.subscribe === 'function')
2331 {
2332 detachProgressListener = streamAheadPrefetch.subscribe((status) =>
2333 {
2334 const nextCachedThrough = status && Number.isFinite(Number(status.cachedThroughSeconds))
2335 ? Number(status.cachedThroughSeconds)
2336 : null;
2337 cachedThroughSeconds = nextCachedThrough;
2338 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
2339 ? Number(status.cachedThroughRatio)
2340 : null;
2341 ensureMarker();
2342 updateMarker();
2343 });
2344 } else if (typeof streamAheadPrefetch.getStatus === 'function')
2345 {
2346 const status = streamAheadPrefetch.getStatus();
2347 cachedThroughSeconds = status && Number.isFinite(Number(status.cachedThroughSeconds))
2348 ? Number(status.cachedThroughSeconds)
2349 : null;
2350 cachedThroughRatio = status && Number.isFinite(Number(status.cachedThroughRatio))
2351 ? Number(status.cachedThroughRatio)
2352 : null;
2353 ensureMarker();
2354 updateMarker();
2355 }
2356
2357 return {
2358 detach: () =>
2359 {
2360 if (typeof detachProgressListener === 'function')
2361 {
2362 try { detachProgressListener(); } catch { /* ignore detach races */ }
2363 detachProgressListener = null;
2364 }
2365
2366 if (markerContainerEl && markerContainerEl.parentNode)
2367 {
2368 markerContainerEl.parentNode.removeChild(markerContainerEl);
2369 }
2370 markerContainerEl = null;
2371 markerEl = null;
2372 },
2373 };
2374 }
2375
2376 function bindStreamAheadPrefetch (opts = {})
2377 {
2378 const basePlaylistUrl = String(opts.playlistUrl || '').trim();
2379 if (!basePlaylistUrl) return null;
2380
2381 const pollIntervalMsRaw = Number(opts.pollIntervalMs);
2382 const pollIntervalMs = Number.isFinite(pollIntervalMsRaw) && pollIntervalMsRaw >= 0
2383 ? pollIntervalMsRaw
2384 : VIDEO_STREAM_AHEAD_PREFETCH_POLL_MS_DEFAULT;
2385 const headers = opts.headers;
2386 const credentials = opts.credentials;
2387
2388 const playlistStatusByUrl = new Map();
2389 const knownPlaylistUrls = new Set([basePlaylistUrl]);
2390 const fetchedAssetUrls = new Set();
2391 const segmentEndSecondsByAssetUrl = new Map();
2392 const discoveredSegmentUrls = new Set();
2393 const fetchedSegmentUrls = new Set();
2394 const progressListeners = new Set();
2395 const controller = typeof AbortController === 'function' ? new AbortController() : null;
2396 let stopped = false;
2397 let cachedThroughSeconds = null;
2398 let cachedThroughRatio = null;
2399 let fetchedTimelineAssetCount = 0;
2400
2401 const recalculateSegmentRatio = () =>
2402 {
2403 const totalSegments = discoveredSegmentUrls.size;
2404 if (totalSegments <= 0)
2405 {
2406 cachedThroughRatio = null;
2407 return;
2408 }
2409 cachedThroughRatio = Math.max(0, Math.min(1, fetchedSegmentUrls.size / totalSegments));
2410 };
2411
2412 const resolveUrl = (value, parentUrl) =>
2413 {
2414 try
2415 {
2416 return new URL(String(value || '').trim(), parentUrl || window.location.href).toString();
2417 } catch
2418 {
2419 return null;
2420 }
2421 };
2422
2423 const wait = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms));
2424
2425 const fetchText = async (url) =>
2426 {
2427 const res = await fetch(url, {
2428 method: 'GET',
2429 headers,
2430 credentials,
2431 cache: 'no-store',
2432 signal: controller ? controller.signal : undefined,
2433 });
2434 if (!res || !res.ok) return null;
2435 return res.text();
2436 };
2437
2438 const fetchAsset = async (url) =>
2439 {
2440 const res = await fetch(url, {
2441 method: 'GET',
2442 headers,
2443 credentials,
2444 signal: controller ? controller.signal : undefined,
2445 });
2446 if (!res || !res.ok) return false;
2447 // Ensure body fully reads so browser/service-worker caches the asset bytes.
2448 await res.arrayBuffer();
2449 return true;
2450 };
2451
2452 const getStatus = () => ({
2453 cachedThroughSeconds,
2454 cachedThroughRatio,
2455 knownPlaylistCount: knownPlaylistUrls.size,
2456 fetchedAssetCount: fetchedAssetUrls.size,
2457 fetchedTimelineAssetCount,
2458 totalSegmentCount: discoveredSegmentUrls.size,
2459 fetchedSegmentCount: fetchedSegmentUrls.size,
2460 allPlaylistsComplete: Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true),
2461 stopped,
2462 });
2463
2464 const appearsTimelineAsset = (assetUrl) =>
2465 /(?:\.ts|\.m4s|\.mp4|\.aac|\.m4a)(?:$|\?)/i.test(String(assetUrl || ''));
2466
2467 const emitProgress = () =>
2468 {
2469 const status = getStatus();
2470 for (const listener of Array.from(progressListeners))
2471 {
2472 try
2473 {
2474 listener(status);
2475 } catch
2476 {
2477 // Keep progress listeners best-effort only.
2478 }
2479 }
2480 };
2481
2482 const workerPromise = (async () =>
2483 {
2484 while (!stopped)
2485 {
2486 const nextAssetUrlSet = new Set();
2487
2488 for (const playlistUrl of Array.from(knownPlaylistUrls))
2489 {
2490 if (stopped) return;
2491 const manifestText = await fetchText(playlistUrl).catch(() => null);
2492 if (!manifestText) continue;
2493
2494 const parsed = parseHlsManifest(manifestText);
2495 playlistStatusByUrl.set(playlistUrl, !!parsed.endList);
2496
2497 for (const child of parsed.childPlaylists)
2498 {
2499 const resolved = resolveUrl(child, playlistUrl);
2500 if (!resolved) continue;
2501 knownPlaylistUrls.add(resolved);
2502 if (!playlistStatusByUrl.has(resolved)) playlistStatusByUrl.set(resolved, false);
2503 }
2504
2505 for (const asset of parsed.mediaAssets)
2506 {
2507 const resolved = resolveUrl(asset, playlistUrl);
2508 if (!resolved || fetchedAssetUrls.has(resolved)) continue;
2509 nextAssetUrlSet.add(resolved);
2510 }
2511
2512 for (const segment of parsed.mediaSegments)
2513 {
2514 if (!segment || !segment.uri) continue;
2515 const resolved = resolveUrl(segment.uri, playlistUrl);
2516 if (!resolved) continue;
2517 if (!Number.isFinite(segment.endTimeSeconds) || segment.endTimeSeconds < 0) continue;
2518 segmentEndSecondsByAssetUrl.set(resolved, Number(segment.endTimeSeconds));
2519 }
2520
2521 for (const segmentUri of parsed.mediaSegmentUris)
2522 {
2523 const resolved = resolveUrl(segmentUri, playlistUrl);
2524 if (!resolved) continue;
2525 discoveredSegmentUrls.add(resolved);
2526 }
2527 }
2528
2529 recalculateSegmentRatio();
2530 emitProgress();
2531
2532 const nextAssetUrls = Array.from(nextAssetUrlSet);
2533 for (const assetUrl of nextAssetUrls)
2534 {
2535 if (stopped) return;
2536 const fetched = await fetchAsset(assetUrl).catch(() => false);
2537 if (!fetched) continue;
2538
2539 fetchedAssetUrls.add(assetUrl);
2540 if (discoveredSegmentUrls.has(assetUrl))
2541 {
2542 fetchedSegmentUrls.add(assetUrl);
2543 }
2544 const mappedSegmentEndSeconds = segmentEndSecondsByAssetUrl.get(assetUrl);
2545 const inferredSegmentEndSeconds = inferSegmentEndSecondsFromAssetUrl(assetUrl);
2546 let fallbackSegmentEndSeconds = null;
2547 if (!Number.isFinite(mappedSegmentEndSeconds) && !Number.isFinite(inferredSegmentEndSeconds) && appearsTimelineAsset(assetUrl))
2548 {
2549 fetchedTimelineAssetCount += 1;
2550 fallbackSegmentEndSeconds = fetchedTimelineAssetCount * VIDEO_STREAM_SEGMENT_DURATION_FALLBACK_SECONDS;
2551 }
2552
2553 const segmentEndSeconds = [mappedSegmentEndSeconds, inferredSegmentEndSeconds, fallbackSegmentEndSeconds]
2554 .filter((value) => Number.isFinite(value))
2555 .reduce((maxValue, value) => (value > maxValue ? value : maxValue), -1);
2556
2557 if (Number.isFinite(segmentEndSeconds))
2558 {
2559 if (!Number.isFinite(cachedThroughSeconds) || segmentEndSeconds > cachedThroughSeconds)
2560 {
2561 cachedThroughSeconds = segmentEndSeconds;
2562 }
2563 }
2564
2565 recalculateSegmentRatio();
2566 emitProgress();
2567 }
2568
2569 const allPlaylistsComplete = Array.from(knownPlaylistUrls).every((url) => playlistStatusByUrl.get(url) === true);
2570 if (allPlaylistsComplete && !nextAssetUrls.length)
2571 {
2572 emitProgress();
2573 return;
2574 }
2575
2576 if (pollIntervalMs > 0)
2577 {
2578 await wait(pollIntervalMs);
2579 }
2580 }
2581 })();
2582
2583 return {
2584 stop: () =>
2585 {
2586 stopped = true;
2587 if (controller && typeof controller.abort === 'function')
2588 {
2589 try { controller.abort(); } catch { /* ignore abort races */ }
2590 }
2591 emitProgress();
2592 },
2593 done: () => workerPromise,
2594 getStatus,
2595 subscribe: (listener) =>
2596 {
2597 if (typeof listener !== 'function') return () => { };
2598 progressListeners.add(listener);
2599 try { listener(getStatus()); } catch { /* ignore listener failures */ }
2600 return () =>
2601 {
2602 progressListeners.delete(listener);
2603 };
2604 },
2605 };
2606 }
2607
2608 function applyDefaultTextTrackPrefs ()
2609 {
2610 try
2611 {
2612 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
2613 } catch
2614 {
2615 // Ignore localStorage failures.
2616 }
2617 }
2618
2619 window.FilemanagerSharedVideoPlayer = {
2620 applyDefaultTextTrackPrefs,
2621 bindImageSubtitleOverlay,
2622 bindStreamAheadPrefetch,
2623 bindStreamAheadSeekMarker,
2624 bindTrackPrefs,
2625 clearVideoStreamClientCache,
2626 configureVideoJsBuffering,
2627 enableVideoStreamClientCache,
2628 ensureVideoPlaybackUi,
2629 normaliseVideoDuration,
2630 };
2631}());