BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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