BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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