BlueGit

timfa filemanager

Files

filemanager / tests / shared-video-player.test.js

shared-video-player.test.js

Add subtitle range prefetching
timfa Tim Falken · pushed by timfa · 5 months ago
e3527da6 History
shared-video-player.test.js 57.3 KiB Download Raw
1'use strict';
2
3const fs = require('fs');
4const path = require('path');
5const { JSDOM } = require('jsdom');
6
7function flushAsyncWork (window, rounds = 6)
8{
9 let chain = Promise.resolve();
10 for (let i = 0; i < rounds; i++)
11 {
12 chain = chain.then(() => new Promise((resolve) => window.setTimeout(resolve, 0)));
13 }
14 return chain;
15}
16
17function buildPlayerHarness (window)
18{
19 const registeredComponents = new Map();
20
21 class MockButton
22 {
23 constructor(player)
24 {
25 this._player = player;
26 this._el = null;
27 }
28
29 player ()
30 {
31 return this._player;
32 }
33
34 buildCSSClass ()
35 {
36 return 'vjs-control';
37 }
38
39 createEl ()
40 {
41 const el = window.document.createElement('button');
42 el.className = this.buildCSSClass();
43 return el;
44 }
45
46 el ()
47 {
48 if (!this._el) this._el = this.createEl();
49 return this._el;
50 }
51 }
52
53 registeredComponents.set('Button', MockButton);
54
55 const videojs = {
56 getComponent: (name) => registeredComponents.get(name),
57 registerComponent: (name, component) =>
58 {
59 registeredComponents.set(name, component);
60 },
61 };
62
63 const events = new Map();
64 const playerEl = window.document.createElement('div');
65 const progressControlEl = window.document.createElement('div');
66 progressControlEl.className = 'vjs-progress-control';
67 playerEl.appendChild(progressControlEl);
68 let currentTime = 0;
69 let durationSeconds = 10;
70 let bufferedEndSeconds = null;
71
72 const player = {
73 ready (cb)
74 {
75 if (typeof cb === 'function') cb();
76 },
77 on (type, fn)
78 {
79 if (!events.has(type)) events.set(type, new Set());
80 events.get(type).add(fn);
81 },
82 trigger (type)
83 {
84 const listeners = events.get(type);
85 if (!listeners) return;
86 for (const fn of Array.from(listeners)) fn();
87 },
88 currentTime ()
89 {
90 return currentTime;
91 },
92 setCurrentTime (next)
93 {
94 currentTime = Number(next);
95 },
96 duration (nextValue)
97 {
98 if (typeof nextValue === 'number')
99 {
100 durationSeconds = nextValue;
101 }
102 return durationSeconds;
103 },
104 bufferedEnd ()
105 {
106 return bufferedEndSeconds;
107 },
108 setBufferedEnd (next)
109 {
110 bufferedEndSeconds = Number.isFinite(next) ? Number(next) : null;
111 },
112 el ()
113 {
114 return playerEl;
115 },
116 getChild (name)
117 {
118 if (name !== 'controlBar') return null;
119 return {
120 addChild (componentName)
121 {
122 const Component = registeredComponents.get(componentName);
123 if (!Component) return null;
124 const instance = new Component(player);
125 playerEl.appendChild(instance.el());
126 return instance;
127 },
128 };
129 },
130 };
131
132 return { player, videojs };
133}
134
135function loadSharedVideoPlayer (window)
136{
137 const script = fs.readFileSync(path.join(__dirname, '../public/shared-video-player.js'), 'utf8');
138 window.eval(script);
139 return window.FilemanagerSharedVideoPlayer;
140}
141
142describe('shared image subtitle prefetching', () =>
143{
144 function createWindow ()
145 {
146 const dom = new JSDOM('<!doctype html><html><body></body></html>', {
147 url: 'http://localhost/',
148 runScripts: 'dangerously',
149 pretendToBeVisual: true,
150 });
151
152 dom.window.AbortController = AbortController;
153 dom.window.Response = Response;
154 dom.window.Headers = Headers;
155 dom.window.Request = Request;
156 dom.window.URL.createObjectURL = () => 'blob:subtitle';
157 dom.window.URL.revokeObjectURL = () => { };
158
159 return dom.window;
160 }
161
162 test('prefetches lookahead frames even when no subtitle is currently active', async () =>
163 {
164 const window = createWindow();
165 const helper = loadSharedVideoPlayer(window);
166 const { player, videojs } = buildPlayerHarness(window);
167 const requestedTimes = [];
168
169 window.fetch = jest.fn(async (url) =>
170 {
171 const parsed = new URL(url, 'http://localhost/');
172 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
173 return new Response(null, {
174 status: 204,
175 headers: { 'X-Subtitle-Frame-Status': 'none' },
176 });
177 });
178
179 helper.bindImageSubtitleOverlay(player, videojs, {}, {
180 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
181 }, {
182 lookaheadSeconds: 1,
183 buildFrameRequest: ({ currentTime, streamIndex }) => ({
184 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
185 }),
186 });
187
188 await flushAsyncWork(window);
189
190 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1]));
191
192 window.close();
193 });
194
195 test('prefetches subtitle frames through known video duration even with short lookahead', async () =>
196 {
197 const window = createWindow();
198 const helper = loadSharedVideoPlayer(window);
199 const { player, videojs } = buildPlayerHarness(window);
200 const requestedTimes = [];
201
202 player.duration(3);
203
204 window.fetch = jest.fn(async (url) =>
205 {
206 const parsed = new URL(url, 'http://localhost/');
207 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
208 return new Response(null, {
209 status: 204,
210 headers: { 'X-Subtitle-Frame-Status': 'none' },
211 });
212 });
213
214 helper.bindImageSubtitleOverlay(player, videojs, {}, {
215 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
216 }, {
217 lookaheadSeconds: 0.5,
218 buildFrameRequest: ({ currentTime, streamIndex }) => ({
219 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
220 }),
221 });
222
223 await flushAsyncWork(window, 18);
224
225 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3]));
226
227 window.close();
228 });
229
230 test('prefetch expands to video end when duration metadata appears later', async () =>
231 {
232 const window = createWindow();
233 const helper = loadSharedVideoPlayer(window);
234 const { player, videojs } = buildPlayerHarness(window);
235 const requestedTimes = [];
236
237 player.duration(Number.NaN);
238
239 window.fetch = jest.fn(async (url) =>
240 {
241 const parsed = new URL(url, 'http://localhost/');
242 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
243 return new Response(null, {
244 status: 204,
245 headers: { 'X-Subtitle-Frame-Status': 'none' },
246 });
247 });
248
249 helper.bindImageSubtitleOverlay(player, videojs, {}, {
250 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
251 }, {
252 lookaheadSeconds: 0.5,
253 initialPrefetchSeconds: 0,
254 buildFrameRequest: ({ currentTime, streamIndex }) => ({
255 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
256 }),
257 });
258
259 await flushAsyncWork(window, 6);
260 expect(requestedTimes).toContain(0);
261
262 requestedTimes.length = 0;
263 player.duration(4);
264 player.trigger('durationchange');
265 await flushAsyncWork(window, 14);
266
267 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]));
268
269 window.close();
270 });
271
272 test('prefetches at least through the buffered video end', async () =>
273 {
274 const window = createWindow();
275 const helper = loadSharedVideoPlayer(window);
276 const { player, videojs } = buildPlayerHarness(window);
277 const requestedTimes = [];
278
279 player.setBufferedEnd(3);
280
281 window.fetch = jest.fn(async (url) =>
282 {
283 const parsed = new URL(url, 'http://localhost/');
284 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
285 return new Response(null, {
286 status: 204,
287 headers: { 'X-Subtitle-Frame-Status': 'none' },
288 });
289 });
290
291 helper.bindImageSubtitleOverlay(player, videojs, {}, {
292 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
293 }, {
294 lookaheadSeconds: 0.5,
295 buildFrameRequest: ({ currentTime, streamIndex }) => ({
296 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
297 }),
298 });
299
300 await flushAsyncWork(window, 12);
301
302 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3]));
303
304 window.close();
305 });
306
307 test('prefetch respects configured larger prefetch step size', async () =>
308 {
309 const window = createWindow();
310 const helper = loadSharedVideoPlayer(window);
311 const { player, videojs } = buildPlayerHarness(window);
312 const requestedTimes = [];
313
314 player.duration(6);
315
316 window.fetch = jest.fn(async (url) =>
317 {
318 const parsed = new URL(url, 'http://localhost/');
319 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
320 return new Response(null, {
321 status: 204,
322 headers: { 'X-Subtitle-Frame-Status': 'none' },
323 });
324 });
325
326 helper.bindImageSubtitleOverlay(player, videojs, {}, {
327 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
328 }, {
329 lookaheadSeconds: 0,
330 initialPrefetchSeconds: 0,
331 prefetchStepSeconds: 2,
332 buildFrameRequest: ({ currentTime, streamIndex }) => ({
333 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
334 }),
335 });
336
337 await flushAsyncWork(window, 14);
338
339 expect(requestedTimes).toEqual(expect.arrayContaining([0, 2, 4, 6]));
340
341 window.close();
342 });
343
344 test('adaptive prefetch step increases stride when cache lead grows', async () =>
345 {
346 const window = createWindow();
347 const helper = loadSharedVideoPlayer(window);
348 const { player, videojs } = buildPlayerHarness(window);
349 const requestedTimes = [];
350
351 player.duration(40);
352
353 window.fetch = jest.fn(async (url) =>
354 {
355 const parsed = new URL(url, 'http://localhost/');
356 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
357 return new Response(null, {
358 status: 204,
359 headers: { 'X-Subtitle-Frame-Status': 'none' },
360 });
361 });
362
363 helper.bindImageSubtitleOverlay(player, videojs, {}, {
364 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
365 }, {
366 lookaheadSeconds: 20,
367 initialPrefetchSeconds: 0,
368 prefetchAdaptiveStepEnabled: true,
369 prefetchStepSecondsMin: 1,
370 prefetchStepSecondsMax: 5,
371 buildFrameRequest: ({ currentTime, streamIndex }) => ({
372 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
373 }),
374 });
375
376 await flushAsyncWork(window, 20);
377
378 const strideSamples = [];
379 for (let i = 1; i < requestedTimes.length; i++)
380 {
381 const stride = requestedTimes[i] - requestedTimes[i - 1];
382 if (Number.isFinite(stride) && stride > 0) strideSamples.push(Number(stride.toFixed(3)));
383 }
384
385 expect(strideSamples.some((stride) => stride > 1.25)).toBe(true);
386
387 window.close();
388 });
389
390 test('prefetch can cache subtitle frames from a range request and render immediately', async () =>
391 {
392 const window = createWindow();
393 const helper = loadSharedVideoPlayer(window);
394 const { player, videojs } = buildPlayerHarness(window);
395 const requestedUrls = [];
396
397 player.duration(12);
398 player.setCurrentTime(2);
399
400 window.fetch = jest.fn(async (url) =>
401 {
402 const parsed = new URL(url, 'http://localhost/');
403 requestedUrls.push(parsed.pathname + parsed.search);
404
405 if (parsed.pathname === '/subtitle-range')
406 {
407 return new Response(JSON.stringify({
408 status: 'ok',
409 startTimeSeconds: Number(parsed.searchParams.get('startTimeSeconds')),
410 endTimeSeconds: Number(parsed.searchParams.get('endTimeSeconds')),
411 frames: [
412 {
413 left: 0,
414 top: 0,
415 width: 320,
416 height: 180,
417 canvasWidth: 640,
418 canvasHeight: 360,
419 startTimeSeconds: 2,
420 endTimeSeconds: 4,
421 contentType: 'image/png',
422 frameBase64: Buffer.from('png-data').toString('base64'),
423 },
424 ],
425 }), {
426 status: 200,
427 headers: { 'Content-Type': 'application/json' },
428 });
429 }
430
431 return new Response(null, {
432 status: 204,
433 headers: { 'X-Subtitle-Frame-Status': 'none' },
434 });
435 });
436
437 helper.bindImageSubtitleOverlay(player, videojs, {}, {
438 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
439 }, {
440 currentFetchEnabled: false,
441 cacheMissFallbackEnabled: false,
442 lookaheadSeconds: 0,
443 initialPrefetchSeconds: 0,
444 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
445 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
446 }),
447 buildFrameRequest: ({ currentTime, streamIndex }) => ({
448 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
449 }),
450 });
451
452 await flushAsyncWork(window, 10);
453
454 expect(requestedUrls.some((url) => url.startsWith('/subtitle-range'))).toBe(true);
455 expect(requestedUrls.some((url) => url.startsWith('/subtitle-frame'))).toBe(false);
456
457 const overlay = player.el().querySelector('.video-subtitle-overlay');
458 expect(overlay).toBeTruthy();
459 expect(overlay.style.display).toBe('block');
460
461 window.close();
462 });
463
464 test('prefetch uses furthest buffered end when player.bufferedEnd under-reports', async () =>
465 {
466 const window = createWindow();
467 const helper = loadSharedVideoPlayer(window);
468 const { player, videojs } = buildPlayerHarness(window);
469 const requestedTimes = [];
470
471 player.setBufferedEnd(0);
472 player.tech = () => ({
473 el: () => ({
474 buffered: {
475 length: 1,
476 end: () => 6,
477 },
478 }),
479 });
480
481 window.fetch = jest.fn(async (url) =>
482 {
483 const parsed = new URL(url, 'http://localhost/');
484 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
485 return new Response(null, {
486 status: 204,
487 headers: { 'X-Subtitle-Frame-Status': 'none' },
488 });
489 });
490
491 helper.bindImageSubtitleOverlay(player, videojs, {}, {
492 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
493 }, {
494 lookaheadSeconds: 0,
495 initialPrefetchSeconds: 0,
496 buildFrameRequest: ({ currentTime, streamIndex }) => ({
497 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
498 }),
499 });
500
501 await flushAsyncWork(window, 16);
502
503 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
504
505 window.close();
506 });
507
508 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
509 {
510 const window = createWindow();
511 const helper = loadSharedVideoPlayer(window);
512 const { player, videojs } = buildPlayerHarness(window);
513 const requestedTimes = [];
514
515 player.setBufferedEnd(35);
516
517 window.fetch = jest.fn(async (url) =>
518 {
519 const parsed = new URL(url, 'http://localhost/');
520 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
521 requestedTimes.push(timeSeconds);
522 return new Response(null, {
523 status: 204,
524 headers: { 'X-Subtitle-Frame-Status': 'none' },
525 });
526 });
527
528 helper.bindImageSubtitleOverlay(player, videojs, {}, {
529 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
530 }, {
531 lookaheadSeconds: 0,
532 initialPrefetchSeconds: 0,
533 buildFrameRequest: ({ currentTime, streamIndex }) => ({
534 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
535 }),
536 });
537
538 await flushAsyncWork(window, 8);
539 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
540
541 requestedTimes.length = 0;
542 player.setCurrentTime(20);
543 player.setBufferedEnd(40);
544 player.trigger('timeupdate');
545 await flushAsyncWork(window, 8);
546
547 expect(requestedTimes).toContain(20);
548 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
549 expect(prefetchAfterJump.length).toBeGreaterThan(0);
550 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
551
552 window.close();
553 });
554
555 test('does not restart current subtitle request while one is in flight', async () =>
556 {
557 const window = createWindow();
558 const helper = loadSharedVideoPlayer(window);
559 const { player, videojs } = buildPlayerHarness(window);
560 const pendingResolvers = [];
561 const requestTimes = [];
562
563 window.fetch = jest.fn((url, init = {}) =>
564 {
565 const parsed = new URL(url, 'http://localhost/');
566 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
567
568 if (pendingResolvers.length === 0)
569 {
570 return new Promise((resolve) =>
571 {
572 pendingResolvers.push(() => resolve(new Response(null, {
573 status: 204,
574 headers: { 'X-Subtitle-Frame-Status': 'none' },
575 })));
576 });
577 }
578
579 expect(init.signal && init.signal.aborted).toBe(false);
580 return Promise.resolve(new Response(null, {
581 status: 204,
582 headers: { 'X-Subtitle-Frame-Status': 'none' },
583 }));
584 });
585
586 helper.bindImageSubtitleOverlay(player, videojs, {}, {
587 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
588 }, {
589 lookaheadSeconds: 0,
590 initialPrefetchSeconds: 0,
591 buildFrameRequest: ({ currentTime, streamIndex }) => ({
592 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
593 }),
594 });
595
596 await flushAsyncWork(window, 3);
597 expect(window.fetch).toHaveBeenCalledTimes(1);
598
599 player.setCurrentTime(1.5);
600 player.trigger('timeupdate');
601 player.setCurrentTime(2.25);
602 player.trigger('timeupdate');
603 await flushAsyncWork(window, 2);
604
605 expect(window.fetch).toHaveBeenCalledTimes(1);
606
607 pendingResolvers[0]();
608 await flushAsyncWork(window, 5);
609
610 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
611 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
612
613 window.close();
614 });
615
616 test('renders a prefetched frame for the current paused time without waiting for another timeupdate', async () =>
617 {
618 const window = createWindow();
619 const helper = loadSharedVideoPlayer(window);
620 const { player, videojs } = buildPlayerHarness(window);
621
622 player.duration(120);
623 player.setCurrentTime(118.95);
624
625 window.fetch = jest.fn(async (url) =>
626 {
627 const parsed = new URL(url, 'http://localhost/');
628 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
629 const headers = {
630 'Content-Type': 'image/png',
631 };
632
633 if (Math.abs(timeSeconds - 118.95) < 0.001)
634 {
635 headers['X-Subtitle-Frame-Start-Time'] = '118.90';
636 headers['X-Subtitle-Frame-End-Time'] = '119.00';
637 headers['X-Subtitle-Frame-Width'] = '640';
638 headers['X-Subtitle-Frame-Height'] = '80';
639 headers['X-Subtitle-Frame-Canvas-Width'] = '1920';
640 headers['X-Subtitle-Frame-Canvas-Height'] = '1080';
641 return new Response(new Uint8Array([137, 80, 78, 71]), { status: 200, headers });
642 }
643
644 return new Response(null, {
645 status: 204,
646 headers: { 'X-Subtitle-Frame-Status': 'none' },
647 });
648 });
649
650 helper.bindImageSubtitleOverlay(player, videojs, {}, {
651 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
652 }, {
653 currentFetchEnabled: false,
654 cacheMissFallbackEnabled: false,
655 lookaheadSeconds: 0,
656 initialPrefetchSeconds: 0,
657 buildFrameRequest: ({ currentTime, streamIndex }) => ({
658 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
659 }),
660 });
661
662 await flushAsyncWork(window, 10);
663
664 const overlay = player.el().querySelector('.video-subtitle-overlay');
665 const overlayImg = overlay && overlay.querySelector('img');
666 expect(overlay).toBeTruthy();
667 expect(overlayImg).toBeTruthy();
668 expect(overlay.style.display).toBe('block');
669 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
670
671 window.close();
672 });
673
674 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
675 {
676 const window = createWindow();
677 const helper = loadSharedVideoPlayer(window);
678 const { player, videojs } = buildPlayerHarness(window);
679 const activeSignals = [];
680
681 window.fetch = jest.fn((url, init = {}) =>
682 {
683 const parsed = new URL(url, 'http://localhost/');
684 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
685
686 if (timeSeconds === 0)
687 {
688 return Promise.resolve(new Response(null, {
689 status: 204,
690 headers: { 'X-Subtitle-Frame-Status': 'none' },
691 }));
692 }
693
694 activeSignals.push(init.signal || null);
695
696 return new Promise((resolve, reject) =>
697 {
698 if (init.signal && typeof init.signal.addEventListener === 'function')
699 {
700 init.signal.addEventListener('abort', () =>
701 {
702 reject(new DOMException('Aborted', 'AbortError'));
703 }, { once: true });
704 }
705 });
706 });
707
708 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
709 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
710 }, {
711 lookaheadSeconds: 1,
712 buildFrameRequest: ({ currentTime, streamIndex }) => ({
713 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
714 }),
715 });
716
717 await flushAsyncWork(window, 3);
718 expect(activeSignals.length).toBeGreaterThan(0);
719
720 controller.detach();
721 await flushAsyncWork(window, 2);
722
723 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
724
725 window.close();
726 });
727
728 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
729 {
730 const window = createWindow();
731 const helper = loadSharedVideoPlayer(window);
732 const { player, videojs } = buildPlayerHarness(window);
733 const sentBatches = [];
734
735 window.fetch = jest.fn(async () =>
736 {
737 return new Response('png-data', {
738 status: 200,
739 headers: {
740 'Content-Type': 'image/png',
741 'X-Subtitle-Frame-Status': 'ok',
742 'X-Subtitle-Request-Received-At-Ms': '1000',
743 'X-Subtitle-Response-Sent-At-Ms': '1012',
744 'X-Subtitle-Frame-Start-Time': '1.5',
745 'X-Subtitle-Frame-End-Time': '3.2',
746 'X-Subtitle-Frame-Width': '320',
747 'X-Subtitle-Frame-Height': '180',
748 'X-Subtitle-Frame-Canvas-Width': '640',
749 'X-Subtitle-Frame-Canvas-Height': '360',
750 },
751 });
752 });
753
754 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
755 sessionId: 'sess-1',
756 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
757 }, {
758 lookaheadSeconds: 0,
759 sendSubtitleLogBatch: (entries) =>
760 {
761 sentBatches.push(entries);
762 return Promise.resolve();
763 },
764 buildFrameRequest: ({ currentTime, streamIndex }) => ({
765 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
766 }),
767 });
768
769 await flushAsyncWork(window, 8);
770 controller.detach();
771 await flushAsyncWork(window, 4);
772
773 const flattened = sentBatches.flat();
774 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
775 'subtitle_png_requested',
776 'subtitle_png_sent',
777 'subtitle_png_received',
778 ]));
779
780 window.close();
781 });
782
783 test('logs prefetch subtitle lifecycle events', async () =>
784 {
785 const window = createWindow();
786 const helper = loadSharedVideoPlayer(window);
787 const { player, videojs } = buildPlayerHarness(window);
788 const sentBatches = [];
789
790 window.fetch = jest.fn(async () =>
791 {
792 return new Response(null, {
793 status: 204,
794 headers: {
795 'X-Subtitle-Frame-Status': 'none',
796 'X-Subtitle-Request-Received-At-Ms': '1000',
797 'X-Subtitle-Response-Sent-At-Ms': '1010',
798 'X-Subtitle-Frame-Start-Time': '2',
799 'X-Subtitle-Frame-End-Time': '3',
800 },
801 });
802 });
803
804 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
805 sessionId: 'sess-1',
806 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
807 }, {
808 lookaheadSeconds: 1,
809 sendSubtitleLogBatch: (entries) =>
810 {
811 sentBatches.push(entries);
812 return Promise.resolve();
813 },
814 buildFrameRequest: ({ currentTime, streamIndex }) => ({
815 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
816 }),
817 });
818
819 await flushAsyncWork(window, 8);
820 controller.detach();
821 await flushAsyncWork(window, 4);
822
823 const flattened = sentBatches.flat();
824 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
825 expect(prefetchEvents).toEqual(expect.arrayContaining([
826 'subtitle_png_requested',
827 'subtitle_png_sent',
828 'subtitle_png_not_available',
829 ]));
830
831 window.close();
832 });
833
834 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
835 {
836 const window = createWindow();
837 const helper = loadSharedVideoPlayer(window);
838 const { player, videojs } = buildPlayerHarness(window);
839 const sentBatches = [];
840
841 player.setCurrentTime(8);
842 window.fetch = jest.fn(async () =>
843 {
844 return new Response(null, {
845 status: 204,
846 headers: {
847 'X-Subtitle-Frame-Status': 'none',
848 'X-Subtitle-Request-Received-At-Ms': '1000',
849 'X-Subtitle-Response-Sent-At-Ms': '1010',
850 },
851 });
852 });
853
854 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
855 sessionId: 'sess-1',
856 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
857 }, {
858 currentFetchEnabled: false,
859 cacheMissFallbackEnabled: false,
860 lookaheadSeconds: 0,
861 sendSubtitleLogBatch: (entries) =>
862 {
863 sentBatches.push(entries);
864 return Promise.resolve();
865 },
866 buildFrameRequest: ({ currentTime, streamIndex }) => ({
867 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
868 }),
869 });
870
871 await flushAsyncWork(window, 8);
872 controller.detach();
873 await flushAsyncWork(window, 4);
874
875 const flattened = sentBatches.flat();
876 expect(flattened.length).toBeGreaterThan(0);
877 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
878 expect(requestKinds.has('prefetch')).toBe(true);
879 expect(requestKinds.has('current')).toBe(false);
880
881 window.close();
882 });
883
884 test('cache-only mode falls back to throttled current fetch on cache miss', async () =>
885 {
886 const window = createWindow();
887 const helper = loadSharedVideoPlayer(window);
888 const { player, videojs } = buildPlayerHarness(window);
889
890 let requestCount = 0;
891 window.fetch = jest.fn(async () =>
892 {
893 requestCount += 1;
894 if (requestCount === 1)
895 {
896 return new Response(new Uint8Array([137, 80, 78, 71]), {
897 status: 200,
898 headers: {
899 'Content-Type': 'image/png',
900 'X-Subtitle-Frame-Start-Time': '2.00',
901 'X-Subtitle-Frame-End-Time': '2.50',
902 'X-Subtitle-Frame-Width': '600',
903 'X-Subtitle-Frame-Height': '72',
904 'X-Subtitle-Frame-Canvas-Width': '1920',
905 'X-Subtitle-Frame-Canvas-Height': '1080',
906 },
907 });
908 }
909
910 return new Response(null, {
911 status: 204,
912 headers: { 'X-Subtitle-Frame-Status': 'none' },
913 });
914 });
915
916 player.setCurrentTime(2.2);
917
918 helper.bindImageSubtitleOverlay(player, videojs, {}, {
919 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
920 }, {
921 currentFetchEnabled: false,
922 cacheMissFallbackIntervalMs: 2000,
923 lookaheadSeconds: 0,
924 initialPrefetchSeconds: 0,
925 buildFrameRequest: ({ currentTime, streamIndex }) => ({
926 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
927 }),
928 });
929
930 await flushAsyncWork(window, 10);
931
932 const overlay = player.el().querySelector('.video-subtitle-overlay');
933 const overlayImg = overlay && overlay.querySelector('img');
934 expect(window.fetch).toHaveBeenCalled();
935 expect(overlay.style.display).toBe('block');
936 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
937
938 window.close();
939 });
940
941 test('cache-miss fallback does not reset prefetch progress on repeated triggers', async () =>
942 {
943 const window = createWindow();
944 const helper = loadSharedVideoPlayer(window);
945 const { player, videojs } = buildPlayerHarness(window);
946
947 let nowMs = 1000;
948 const realNow = window.Date.now;
949 window.Date.now = () => nowMs;
950
951 let abortedCount = 0;
952 window.fetch = jest.fn((url, init = {}) =>
953 {
954 return new Promise((resolve, reject) =>
955 {
956 const signal = init && init.signal;
957 const onAbort = () =>
958 {
959 abortedCount += 1;
960 const err = new Error('aborted');
961 err.name = 'AbortError';
962 reject(err);
963 };
964
965 if (signal && typeof signal.addEventListener === 'function')
966 {
967 if (signal.aborted) return onAbort();
968 signal.addEventListener('abort', onAbort, { once: true });
969 }
970
971 window.setTimeout(() =>
972 {
973 if (signal && signal.aborted) return;
974 resolve(new Response(null, {
975 status: 204,
976 headers: { 'X-Subtitle-Frame-Status': 'none' },
977 }));
978 }, 80);
979 });
980 });
981
982 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
983 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
984 }, {
985 currentFetchEnabled: false,
986 cacheMissFallbackIntervalMs: 20,
987 lookaheadSeconds: 2,
988 initialPrefetchSeconds: 0,
989 buildFrameRequest: ({ currentTime, streamIndex }) => ({
990 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
991 }),
992 });
993
994 await flushAsyncWork(window, 4);
995
996 player.setCurrentTime(5);
997 player.trigger('timeupdate');
998 nowMs += 40;
999 player.setCurrentTime(5.5);
1000 player.trigger('timeupdate');
1001 nowMs += 40;
1002 player.setCurrentTime(6);
1003 player.trigger('timeupdate');
1004
1005 await flushAsyncWork(window, 12);
1006 expect(abortedCount).toBe(0);
1007
1008 window.Date.now = realNow;
1009 controller.detach();
1010 window.close();
1011 });
1012
1013 test('cache-only mode performs initial warmup prefetch window on load', async () =>
1014 {
1015 const window = createWindow();
1016 const helper = loadSharedVideoPlayer(window);
1017 const { player, videojs } = buildPlayerHarness(window);
1018 const requestedTimes = [];
1019
1020 window.fetch = jest.fn(async (url) =>
1021 {
1022 const parsed = new URL(url, 'http://localhost/');
1023 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
1024 return new Response(null, {
1025 status: 204,
1026 headers: {
1027 'X-Subtitle-Frame-Status': 'none',
1028 'X-Subtitle-Request-Received-At-Ms': '1000',
1029 'X-Subtitle-Response-Sent-At-Ms': '1010',
1030 },
1031 });
1032 });
1033
1034 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1035 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1036 }, {
1037 currentFetchEnabled: false,
1038 lookaheadSeconds: 0,
1039 initialPrefetchSeconds: 2,
1040 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1041 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1042 }),
1043 });
1044
1045 await flushAsyncWork(window, 12);
1046
1047 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2]));
1048
1049 controller.detach();
1050 await flushAsyncWork(window, 2);
1051 window.close();
1052 });
1053
1054 test('renders requested and received subtitle markers on the seek bar', async () =>
1055 {
1056 const window = createWindow();
1057 const helper = loadSharedVideoPlayer(window);
1058 const { player, videojs } = buildPlayerHarness(window);
1059
1060 window.fetch = jest.fn(async () =>
1061 {
1062 return new Response('png-data', {
1063 status: 200,
1064 headers: {
1065 'Content-Type': 'image/png',
1066 'X-Subtitle-Frame-Status': 'ok',
1067 'X-Subtitle-Request-Received-At-Ms': '1000',
1068 'X-Subtitle-Response-Sent-At-Ms': '1012',
1069 'X-Subtitle-Frame-Start-Time': '2.5',
1070 'X-Subtitle-Frame-End-Time': '3.5',
1071 'X-Subtitle-Frame-Width': '320',
1072 'X-Subtitle-Frame-Height': '180',
1073 'X-Subtitle-Frame-Canvas-Width': '640',
1074 'X-Subtitle-Frame-Canvas-Height': '360',
1075 },
1076 });
1077 });
1078
1079 player.duration(10);
1080 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1081 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1082 }, {
1083 lookaheadSeconds: 0,
1084 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1085 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1086 }),
1087 });
1088
1089 await flushAsyncWork(window, 8);
1090
1091 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1092 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1093 expect(requestedMarker).toBeTruthy();
1094 expect(receivedMarker).toBeTruthy();
1095 expect(requestedMarker.style.display).toBe('block');
1096 expect(receivedMarker.style.display).toBe('block');
1097 expect(requestedMarker.style.left).toBe('100.0000%');
1098 expect(receivedMarker.style.left).toBe('25.0000%');
1099 expect(requestedMarker.textContent).toBe(']');
1100 expect(receivedMarker.textContent).toBe('[');
1101
1102 controller.detach();
1103 await new Promise((resolve) => window.setTimeout(resolve, 300));
1104 await flushAsyncWork(window, 2);
1105
1106 window.close();
1107 });
1108
1109 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
1110 {
1111 const window = createWindow();
1112 const helper = loadSharedVideoPlayer(window);
1113 const { player, videojs } = buildPlayerHarness(window);
1114
1115 player.duration(10);
1116 player.setCurrentTime(4);
1117 window.fetch = jest.fn(async () =>
1118 {
1119 return new Response(null, {
1120 status: 204,
1121 headers: {
1122 'X-Subtitle-Frame-Status': 'none',
1123 'X-Subtitle-Request-Received-At-Ms': '1000',
1124 'X-Subtitle-Response-Sent-At-Ms': '1010',
1125 },
1126 });
1127 });
1128
1129 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1130 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1131 }, {
1132 lookaheadSeconds: 0,
1133 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1134 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1135 }),
1136 });
1137
1138 await flushAsyncWork(window, 8);
1139
1140 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1141 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1142 expect(requestedMarker).toBeTruthy();
1143 expect(receivedMarker).toBeTruthy();
1144 expect(requestedMarker.style.display).toBe('block');
1145 expect(receivedMarker.style.display).toBe('block');
1146 expect(requestedMarker.style.left).toBe('100.0000%');
1147 expect(receivedMarker.style.left).toBe('100.0000%');
1148 expect(requestedMarker.textContent).toBe(']');
1149 expect(receivedMarker.textContent).toBe('[');
1150
1151 controller.detach();
1152 await flushAsyncWork(window, 2);
1153 window.close();
1154 });
1155
1156 test('keeps existing marker positions while the next request is still in flight', async () =>
1157 {
1158 const window = createWindow();
1159 const helper = loadSharedVideoPlayer(window);
1160 const { player, videojs } = buildPlayerHarness(window);
1161 let pendingResolve = null;
1162
1163 player.duration(10);
1164 window.fetch = jest.fn((url) =>
1165 {
1166 const parsed = new URL(url, 'http://localhost/');
1167 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1168
1169 if (timeSeconds === 0)
1170 {
1171 return Promise.resolve(new Response('png-data', {
1172 status: 200,
1173 headers: {
1174 'Content-Type': 'image/png',
1175 'X-Subtitle-Frame-Status': 'ok',
1176 'X-Subtitle-Frame-Start-Time': '2',
1177 'X-Subtitle-Frame-End-Time': '3',
1178 'X-Subtitle-Frame-Width': '320',
1179 'X-Subtitle-Frame-Height': '180',
1180 'X-Subtitle-Frame-Canvas-Width': '640',
1181 'X-Subtitle-Frame-Canvas-Height': '360',
1182 },
1183 }));
1184 }
1185
1186 return new Promise((resolve) =>
1187 {
1188 pendingResolve = resolve;
1189 });
1190 });
1191
1192 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1193 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1194 }, {
1195 lookaheadSeconds: 0,
1196 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1197 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1198 }),
1199 });
1200
1201 await flushAsyncWork(window, 8);
1202
1203 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1204 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1205 expect(requestedMarker).toBeTruthy();
1206 expect(receivedMarker).toBeTruthy();
1207 expect(requestedMarker.style.left).toBe('0.0000%');
1208 expect(receivedMarker.style.left).toBe('20.0000%');
1209
1210 player.setCurrentTime(1.5);
1211 player.trigger('timeupdate');
1212 await flushAsyncWork(window, 2);
1213
1214 expect(requestedMarker.style.left).toBe('0.0000%');
1215 expect(receivedMarker.style.left).toBe('20.0000%');
1216
1217 pendingResolve(new Response(null, {
1218 status: 204,
1219 headers: {
1220 'X-Subtitle-Frame-Status': 'none',
1221 },
1222 }));
1223
1224 await flushAsyncWork(window, 8);
1225 expect(requestedMarker.style.display).toBe('block');
1226 expect(receivedMarker.style.display).toBe('block');
1227 expect(requestedMarker.style.left).toBe('15.0000%');
1228 expect(receivedMarker.style.left).toBe('20.0000%');
1229
1230 controller.detach();
1231 await flushAsyncWork(window, 2);
1232 window.close();
1233 });
1234
1235 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
1236 {
1237 const window = createWindow();
1238 const helper = loadSharedVideoPlayer(window);
1239 const { player, videojs } = buildPlayerHarness(window);
1240 const requestedTimes = [];
1241
1242 player.duration(12);
1243 window.fetch = jest.fn(async (url) =>
1244 {
1245 const parsed = new URL(url, 'http://localhost/');
1246 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1247 requestedTimes.push(timeSeconds);
1248
1249 if (requestedTimes.length === 1)
1250 {
1251 return new Response('png-data', {
1252 status: 200,
1253 headers: {
1254 'Content-Type': 'image/png',
1255 'X-Subtitle-Frame-Status': 'ok',
1256 'X-Subtitle-Frame-Start-Time': '4',
1257 'X-Subtitle-Frame-End-Time': '5',
1258 'X-Subtitle-Frame-Width': '320',
1259 'X-Subtitle-Frame-Height': '180',
1260 'X-Subtitle-Frame-Canvas-Width': '640',
1261 'X-Subtitle-Frame-Canvas-Height': '360',
1262 },
1263 });
1264 }
1265
1266 return new Response('png-data', {
1267 status: 200,
1268 headers: {
1269 'Content-Type': 'image/png',
1270 'X-Subtitle-Frame-Status': 'ok',
1271 'X-Subtitle-Frame-Start-Time': '2',
1272 'X-Subtitle-Frame-End-Time': '3',
1273 'X-Subtitle-Frame-Width': '320',
1274 'X-Subtitle-Frame-Height': '180',
1275 'X-Subtitle-Frame-Canvas-Width': '640',
1276 'X-Subtitle-Frame-Canvas-Height': '360',
1277 },
1278 });
1279 });
1280
1281 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1282 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1283 }, {
1284 lookaheadSeconds: 0,
1285 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1286 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1287 }),
1288 });
1289
1290 await flushAsyncWork(window, 8);
1291
1292 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1293 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1294 expect(requestedMarker).toBeTruthy();
1295 expect(receivedMarker).toBeTruthy();
1296 expect(requestedMarker.style.left).toBe('100.0000%');
1297 expect(receivedMarker.style.left).toBe('33.3333%');
1298
1299 player.setCurrentTime(1.5);
1300 player.trigger('timeupdate');
1301 await flushAsyncWork(window, 8);
1302
1303 // Second response reports an older start time, but markers stay monotonic.
1304 expect(requestedMarker.style.left).toBe('100.0000%');
1305 expect(receivedMarker.style.left).toBe('33.3333%');
1306
1307 controller.detach();
1308 await flushAsyncWork(window, 2);
1309 window.close();
1310 });
1311
1312 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
1313 {
1314 const window = createWindow();
1315 const helper = loadSharedVideoPlayer(window);
1316 const { player, videojs } = buildPlayerHarness(window);
1317 const requestedTimes = [];
1318
1319 window.fetch = jest.fn((url, init = {}) =>
1320 {
1321 const parsed = new URL(url, 'http://localhost/');
1322 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1323 requestedTimes.push(timeSeconds);
1324
1325 if (requestedTimes.length === 1)
1326 {
1327 return new Promise((resolve, reject) =>
1328 {
1329 if (init.signal && typeof init.signal.addEventListener === 'function')
1330 {
1331 init.signal.addEventListener('abort', () =>
1332 {
1333 reject(new window.DOMException('Aborted', 'AbortError'));
1334 }, { once: true });
1335 }
1336 });
1337 }
1338
1339 return Promise.resolve(new Response(null, {
1340 status: 204,
1341 headers: {
1342 'X-Subtitle-Frame-Status': 'none',
1343 },
1344 }));
1345 });
1346
1347 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1348 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1349 }, {
1350 lookaheadSeconds: 0,
1351 currentRequestTimeoutMs: 300,
1352 logToConsole: false,
1353 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1354 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1355 }),
1356 });
1357
1358 await flushAsyncWork(window, 4);
1359 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1360 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1361
1362 player.setCurrentTime(5);
1363 player.trigger('seeking');
1364 await flushAsyncWork(window, 20);
1365
1366 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1367 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
1368
1369 controller.detach();
1370 await flushAsyncWork(window, 2);
1371 window.close();
1372 });
1373
1374 test('recovers when a current subtitle request hangs and times out', async () =>
1375 {
1376 const window = createWindow();
1377 const helper = loadSharedVideoPlayer(window);
1378 const { player, videojs } = buildPlayerHarness(window);
1379 const requestedTimes = [];
1380
1381 window.fetch = jest.fn((url, init = {}) =>
1382 {
1383 const parsed = new URL(url, 'http://localhost/');
1384 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1385 requestedTimes.push(timeSeconds);
1386
1387 if (requestedTimes.length === 1)
1388 {
1389 return new Promise((resolve, reject) =>
1390 {
1391 if (init.signal && typeof init.signal.addEventListener === 'function')
1392 {
1393 init.signal.addEventListener('abort', () =>
1394 {
1395 reject(new window.DOMException('Aborted', 'AbortError'));
1396 }, { once: true });
1397 }
1398 });
1399 }
1400
1401 return Promise.resolve(new Response(null, {
1402 status: 204,
1403 headers: { 'X-Subtitle-Frame-Status': 'none' },
1404 }));
1405 });
1406
1407 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1408 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1409 }, {
1410 lookaheadSeconds: 0,
1411 currentRequestTimeoutMs: 250,
1412 logToConsole: false,
1413 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1414 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1415 }),
1416 });
1417
1418 await flushAsyncWork(window, 3);
1419
1420 player.setCurrentTime(1.5);
1421 player.trigger('timeupdate');
1422
1423 await new Promise((resolve) => window.setTimeout(resolve, 320));
1424 player.trigger('timeupdate');
1425 await new Promise((resolve) => window.setTimeout(resolve, 220));
1426 await flushAsyncWork(window, 20);
1427
1428 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1429 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
1430
1431 controller.detach();
1432 await new Promise((resolve) => window.setTimeout(resolve, 200));
1433 await flushAsyncWork(window, 20);
1434 window.close();
1435 });
1436
1437 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1438 {
1439 const window = createWindow();
1440 const helper = loadSharedVideoPlayer(window);
1441 const { player, videojs } = buildPlayerHarness(window);
1442
1443 player.duration(10);
1444 player.setCurrentTime(2);
1445 window.fetch = jest.fn(async (url) =>
1446 {
1447 const parsed = new URL(url, 'http://localhost/');
1448 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1449
1450 if (Math.abs(timeSeconds - 2) < 1e-6)
1451 {
1452 return new Response('png-data', {
1453 status: 200,
1454 headers: {
1455 'Content-Type': 'image/png',
1456 'X-Subtitle-Frame-Status': 'ok',
1457 'X-Subtitle-Frame-Start-Time': '2',
1458 'X-Subtitle-Frame-End-Time': '3',
1459 'X-Subtitle-Frame-Width': '320',
1460 'X-Subtitle-Frame-Height': '180',
1461 'X-Subtitle-Frame-Canvas-Width': '640',
1462 'X-Subtitle-Frame-Canvas-Height': '360',
1463 },
1464 });
1465 }
1466
1467 return new Response(null, {
1468 status: 204,
1469 headers: {
1470 'X-Subtitle-Frame-Status': 'none',
1471 },
1472 });
1473 });
1474
1475 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1476 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1477 }, {
1478 lookaheadSeconds: 0,
1479 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1480 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1481 }),
1482 });
1483
1484 await flushAsyncWork(window, 8);
1485 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1486 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1487
1488 player.setCurrentTime(4);
1489 player.trigger('timeupdate');
1490 await flushAsyncWork(window, 8);
1491 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1492 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1493
1494 const overlay = player.el().querySelector('.video-subtitle-overlay');
1495 expect(overlay).toBeTruthy();
1496 expect(overlay.style.display).toBe('none');
1497
1498 player.setCurrentTime(2.5);
1499 player.trigger('timeupdate');
1500 await flushAsyncWork(window, 8);
1501
1502 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1503 expect(overlay.style.display).toBe('block');
1504
1505 controller.detach();
1506 await flushAsyncWork(window, 2);
1507 window.close();
1508 });
1509
1510 test('registers stream cache service worker once when supported', async () =>
1511 {
1512 const window = createWindow();
1513 const helper = loadSharedVideoPlayer(window);
1514 const register = jest.fn(async () => ({}));
1515 window.navigator.serviceWorker = { register };
1516
1517 const first = await helper.enableVideoStreamClientCache();
1518 const second = await helper.enableVideoStreamClientCache();
1519
1520 expect(first).toBe(true);
1521 expect(second).toBe(true);
1522 expect(register).toHaveBeenCalledTimes(1);
1523 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1524 scope: '/',
1525 updateViaCache: 'none',
1526 });
1527
1528 window.close();
1529 });
1530
1531 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1532 {
1533 const window = createWindow();
1534 const helper = loadSharedVideoPlayer(window);
1535 const requestedUrls = [];
1536
1537 window.fetch = jest.fn(async (input) =>
1538 {
1539 const url = String(input && input.url ? input.url : input);
1540 requestedUrls.push(url);
1541
1542 if (url === 'http://localhost/master.m3u8')
1543 {
1544 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1545 status: 200,
1546 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1547 });
1548 }
1549
1550 if (url === 'http://localhost/stream_0.m3u8')
1551 {
1552 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1553 status: 200,
1554 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1555 });
1556 }
1557
1558 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1559 {
1560 return new Response(new Uint8Array([1, 2, 3, 4]), {
1561 status: 200,
1562 headers: { 'Content-Type': 'video/mp2t' },
1563 });
1564 }
1565
1566 return new Response(null, { status: 404 });
1567 });
1568
1569 const controller = helper.bindStreamAheadPrefetch({
1570 playlistUrl: 'http://localhost/master.m3u8',
1571 pollIntervalMs: 0,
1572 credentials: 'same-origin',
1573 });
1574
1575 expect(controller).toBeTruthy();
1576 await controller.done();
1577
1578 expect(requestedUrls).toEqual(expect.arrayContaining([
1579 'http://localhost/master.m3u8',
1580 'http://localhost/stream_0.m3u8',
1581 'http://localhost/seg0.ts',
1582 'http://localhost/seg1.ts',
1583 ]));
1584
1585 controller.stop();
1586 window.close();
1587 });
1588
1589 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
1590 {
1591 const window = createWindow();
1592 const helper = loadSharedVideoPlayer(window);
1593 const progressSamples = [];
1594
1595 window.fetch = jest.fn(async (input) =>
1596 {
1597 const url = String(input && input.url ? input.url : input);
1598
1599 if (url === 'http://localhost/master.m3u8')
1600 {
1601 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1602 status: 200,
1603 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1604 });
1605 }
1606
1607 if (url === 'http://localhost/stream_0.m3u8')
1608 {
1609 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1610 status: 200,
1611 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1612 });
1613 }
1614
1615 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1616 {
1617 return new Response(new Uint8Array([1, 2, 3, 4]), {
1618 status: 200,
1619 headers: { 'Content-Type': 'video/mp2t' },
1620 });
1621 }
1622
1623 return new Response(null, { status: 404 });
1624 });
1625
1626 const controller = helper.bindStreamAheadPrefetch({
1627 playlistUrl: 'http://localhost/master.m3u8',
1628 pollIntervalMs: 0,
1629 credentials: 'same-origin',
1630 });
1631
1632 expect(controller).toBeTruthy();
1633 const unsubscribe = controller.subscribe((status) =>
1634 {
1635 progressSamples.push(status && status.cachedThroughSeconds);
1636 });
1637
1638 await controller.done();
1639 unsubscribe();
1640
1641 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1642
1643 controller.stop();
1644 window.close();
1645 });
1646
1647 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
1648 {
1649 const window = createWindow();
1650 const helper = loadSharedVideoPlayer(window);
1651 const progressSamples = [];
1652
1653 window.fetch = jest.fn(async (input) =>
1654 {
1655 const url = String(input && input.url ? input.url : input);
1656
1657 if (url === 'http://localhost/master.m3u8')
1658 {
1659 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1660 status: 200,
1661 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1662 });
1663 }
1664
1665 if (url === 'http://localhost/stream_0.m3u8')
1666 {
1667 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
1668 status: 200,
1669 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1670 });
1671 }
1672
1673 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
1674 {
1675 return new Response(new Uint8Array([1, 2, 3, 4]), {
1676 status: 200,
1677 headers: { 'Content-Type': 'video/mp2t' },
1678 });
1679 }
1680
1681 return new Response(null, { status: 404 });
1682 });
1683
1684 const controller = helper.bindStreamAheadPrefetch({
1685 playlistUrl: 'http://localhost/master.m3u8',
1686 pollIntervalMs: 0,
1687 credentials: 'same-origin',
1688 });
1689
1690 expect(controller).toBeTruthy();
1691 const unsubscribe = controller.subscribe((status) =>
1692 {
1693 progressSamples.push(status && status.cachedThroughSeconds);
1694 });
1695
1696 await controller.done();
1697 unsubscribe();
1698
1699 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1700
1701 controller.stop();
1702 window.close();
1703 });
1704
1705 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
1706 {
1707 const window = createWindow();
1708 const helper = loadSharedVideoPlayer(window);
1709 const progressSamples = [];
1710
1711 window.fetch = jest.fn(async (input) =>
1712 {
1713 const url = String(input && input.url ? input.url : input);
1714
1715 if (url === 'http://localhost/master.m3u8')
1716 {
1717 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1718 status: 200,
1719 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1720 });
1721 }
1722
1723 if (url === 'http://localhost/stream_0.m3u8')
1724 {
1725 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
1726 status: 200,
1727 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1728 });
1729 }
1730
1731 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
1732 {
1733 return new Response(new Uint8Array([1, 2, 3, 4]), {
1734 status: 200,
1735 headers: { 'Content-Type': 'video/mp4' },
1736 });
1737 }
1738
1739 return new Response(null, { status: 404 });
1740 });
1741
1742 const controller = helper.bindStreamAheadPrefetch({
1743 playlistUrl: 'http://localhost/master.m3u8',
1744 pollIntervalMs: 0,
1745 credentials: 'same-origin',
1746 });
1747
1748 expect(controller).toBeTruthy();
1749 const unsubscribe = controller.subscribe((status) =>
1750 {
1751 progressSamples.push(status && status.cachedThroughSeconds);
1752 });
1753
1754 await controller.done();
1755 unsubscribe();
1756
1757 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
1758
1759 controller.stop();
1760 window.close();
1761 });
1762
1763 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
1764 {
1765 const window = createWindow();
1766 const helper = loadSharedVideoPlayer(window);
1767 const statusSamples = [];
1768
1769 window.fetch = jest.fn(async (input) =>
1770 {
1771 const url = String(input && input.url ? input.url : input);
1772
1773 if (url === 'http://localhost/master.m3u8')
1774 {
1775 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1776 status: 200,
1777 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1778 });
1779 }
1780
1781 if (url === 'http://localhost/stream_0.m3u8')
1782 {
1783 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
1784 status: 200,
1785 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1786 });
1787 }
1788
1789 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
1790 {
1791 return new Response(new Uint8Array([1, 2, 3, 4]), {
1792 status: 200,
1793 headers: { 'Content-Type': 'application/octet-stream' },
1794 });
1795 }
1796
1797 return new Response(null, { status: 404 });
1798 });
1799
1800 const controller = helper.bindStreamAheadPrefetch({
1801 playlistUrl: 'http://localhost/master.m3u8',
1802 pollIntervalMs: 0,
1803 credentials: 'same-origin',
1804 });
1805
1806 expect(controller).toBeTruthy();
1807 const unsubscribe = controller.subscribe((status) =>
1808 {
1809 statusSamples.push(status || {});
1810 });
1811
1812 await controller.done();
1813 unsubscribe();
1814
1815 const finalStatus = statusSamples[statusSamples.length - 1] || {};
1816 expect(finalStatus.totalSegmentCount).toBe(2);
1817 expect(finalStatus.fetchedSegmentCount).toBe(2);
1818 expect(finalStatus.cachedThroughRatio).toBe(1);
1819
1820 controller.stop();
1821 window.close();
1822 });
1823
1824 test('clears cached stream assets for a finished playlist session', async () =>
1825 {
1826 const window = createWindow();
1827 const helper = loadSharedVideoPlayer(window);
1828 const requests = [
1829 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
1830 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
1831 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
1832 ];
1833 const deleteCalls = [];
1834 const cache = {
1835 keys: jest.fn(async () => requests),
1836 delete: jest.fn(async (request) =>
1837 {
1838 deleteCalls.push(request.url);
1839 return true;
1840 }),
1841 };
1842 window.caches = {
1843 open: jest.fn(async () => cache),
1844 };
1845
1846 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
1847
1848 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
1849 expect(cache.keys).toHaveBeenCalledTimes(1);
1850 expect(deleteCalls).toEqual(expect.arrayContaining([
1851 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
1852 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
1853 ]));
1854 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
1855
1856 window.close();
1857 });
1858});