BlueGit

timfa filemanager

Files

filemanager / public / shared-video-player.js

shared-video-player.js

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