BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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