BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

d3ee4c42 History
shared-video-player.test.js 69.9 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('range prefetch clamps the tail window to the known video duration', async () =>
308 {
309 const window = createWindow();
310 const helper = loadSharedVideoPlayer(window);
311 const { player, videojs } = buildPlayerHarness(window);
312 const requestedRanges = [];
313
314 player.duration(10);
315 player.setCurrentTime(8.5);
316
317 window.fetch = jest.fn(async (url) =>
318 {
319 const parsed = new URL(url, 'http://localhost/');
320 requestedRanges.push({
321 start: Number(parsed.searchParams.get('startTimeSeconds')),
322 end: Number(parsed.searchParams.get('endTimeSeconds')),
323 });
324 return new Response(JSON.stringify({ status: 'ok', frames: [] }), {
325 status: 200,
326 headers: { 'Content-Type': 'application/json' },
327 });
328 });
329
330 helper.bindImageSubtitleOverlay(player, videojs, {}, {
331 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
332 }, {
333 lookaheadSeconds: 0,
334 initialPrefetchSeconds: 0,
335 currentFetchEnabled: false,
336 cacheMissFallbackEnabled: false,
337 prefetchAdaptiveStepEnabled: true,
338 prefetchStepSecondsMin: 3,
339 prefetchStepSecondsMax: 3,
340 buildFrameRequest: ({ currentTime, streamIndex }) => ({
341 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
342 }),
343 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
344 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
345 }),
346 });
347
348 player.trigger('timeupdate');
349 await flushAsyncWork(window, 10);
350
351 expect(requestedRanges.length).toBeGreaterThan(0);
352 expect(requestedRanges[0]).toEqual({ start: 8.5, end: 10 });
353 expect(requestedRanges.every((range) => range.end <= 10)).toBe(true);
354
355 window.close();
356 });
357
358 test('prefetch respects configured larger prefetch step size', async () =>
359 {
360 const window = createWindow();
361 const helper = loadSharedVideoPlayer(window);
362 const { player, videojs } = buildPlayerHarness(window);
363 const requestedTimes = [];
364
365 player.duration(6);
366
367 window.fetch = jest.fn(async (url) =>
368 {
369 const parsed = new URL(url, 'http://localhost/');
370 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
371 return new Response(null, {
372 status: 204,
373 headers: { 'X-Subtitle-Frame-Status': 'none' },
374 });
375 });
376
377 helper.bindImageSubtitleOverlay(player, videojs, {}, {
378 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
379 }, {
380 lookaheadSeconds: 0,
381 initialPrefetchSeconds: 0,
382 prefetchStepSeconds: 2,
383 buildFrameRequest: ({ currentTime, streamIndex }) => ({
384 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
385 }),
386 });
387
388 await flushAsyncWork(window, 14);
389
390 expect(requestedTimes).toEqual(expect.arrayContaining([0, 2, 4, 6]));
391
392 window.close();
393 });
394
395 test('adaptive prefetch step increases stride when cache lead grows', async () =>
396 {
397 const window = createWindow();
398 const helper = loadSharedVideoPlayer(window);
399 const { player, videojs } = buildPlayerHarness(window);
400 const requestedTimes = [];
401
402 player.duration(40);
403
404 window.fetch = jest.fn(async (url) =>
405 {
406 const parsed = new URL(url, 'http://localhost/');
407 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
408 return new Response(null, {
409 status: 204,
410 headers: { 'X-Subtitle-Frame-Status': 'none' },
411 });
412 });
413
414 helper.bindImageSubtitleOverlay(player, videojs, {}, {
415 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
416 }, {
417 lookaheadSeconds: 20,
418 initialPrefetchSeconds: 0,
419 prefetchAdaptiveStepEnabled: true,
420 prefetchStepSecondsMin: 1,
421 prefetchStepSecondsMax: 5,
422 buildFrameRequest: ({ currentTime, streamIndex }) => ({
423 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
424 }),
425 });
426
427 await flushAsyncWork(window, 20);
428
429 const strideSamples = [];
430 for (let i = 1; i < requestedTimes.length; i++)
431 {
432 const stride = requestedTimes[i] - requestedTimes[i - 1];
433 if (Number.isFinite(stride) && stride > 0) strideSamples.push(Number(stride.toFixed(3)));
434 }
435
436 expect(strideSamples.some((stride) => stride > 1.25)).toBe(true);
437
438 window.close();
439 });
440
441 test('prefetch can cache subtitle frames from a range request and render immediately', async () =>
442 {
443 const window = createWindow();
444 const helper = loadSharedVideoPlayer(window);
445 const { player, videojs } = buildPlayerHarness(window);
446 const requestedUrls = [];
447
448 player.duration(12);
449 player.setCurrentTime(2);
450
451 window.fetch = jest.fn(async (url) =>
452 {
453 const parsed = new URL(url, 'http://localhost/');
454 requestedUrls.push(parsed.pathname + parsed.search);
455
456 if (parsed.pathname === '/subtitle-range')
457 {
458 return new Response(JSON.stringify({
459 status: 'ok',
460 startTimeSeconds: Number(parsed.searchParams.get('startTimeSeconds')),
461 endTimeSeconds: Number(parsed.searchParams.get('endTimeSeconds')),
462 frames: [
463 {
464 left: 0,
465 top: 0,
466 width: 320,
467 height: 180,
468 canvasWidth: 640,
469 canvasHeight: 360,
470 startTimeSeconds: 2,
471 endTimeSeconds: 4,
472 contentType: 'image/png',
473 frameBase64: Buffer.from('png-data').toString('base64'),
474 },
475 ],
476 }), {
477 status: 200,
478 headers: { 'Content-Type': 'application/json' },
479 });
480 }
481
482 return new Response(null, {
483 status: 204,
484 headers: { 'X-Subtitle-Frame-Status': 'none' },
485 });
486 });
487
488 helper.bindImageSubtitleOverlay(player, videojs, {}, {
489 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
490 }, {
491 currentFetchEnabled: false,
492 cacheMissFallbackEnabled: false,
493 lookaheadSeconds: 0,
494 initialPrefetchSeconds: 0,
495 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
496 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
497 }),
498 buildFrameRequest: ({ currentTime, streamIndex }) => ({
499 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
500 }),
501 });
502
503 await flushAsyncWork(window, 10);
504
505 expect(requestedUrls.some((url) => url.startsWith('/subtitle-range'))).toBe(true);
506 expect(requestedUrls.some((url) => url.startsWith('/subtitle-frame'))).toBe(false);
507
508 const overlay = player.el().querySelector('.video-subtitle-overlay');
509 expect(overlay).toBeTruthy();
510 expect(overlay.style.display).toBe('block');
511
512 window.close();
513 });
514
515 test('prefetch uses furthest buffered end when player.bufferedEnd under-reports', async () =>
516 {
517 const window = createWindow();
518 const helper = loadSharedVideoPlayer(window);
519 const { player, videojs } = buildPlayerHarness(window);
520 const requestedTimes = [];
521
522 player.setBufferedEnd(0);
523 player.tech = () => ({
524 el: () => ({
525 buffered: {
526 length: 1,
527 end: () => 6,
528 },
529 }),
530 });
531
532 window.fetch = jest.fn(async (url) =>
533 {
534 const parsed = new URL(url, 'http://localhost/');
535 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
536 return new Response(null, {
537 status: 204,
538 headers: { 'X-Subtitle-Frame-Status': 'none' },
539 });
540 });
541
542 helper.bindImageSubtitleOverlay(player, videojs, {}, {
543 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
544 }, {
545 lookaheadSeconds: 0,
546 initialPrefetchSeconds: 0,
547 buildFrameRequest: ({ currentTime, streamIndex }) => ({
548 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
549 }),
550 });
551
552 await flushAsyncWork(window, 16);
553
554 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6]));
555
556 window.close();
557 });
558
559 test('prefetch frontier jumps to current playback time instead of replaying stale lag', async () =>
560 {
561 const window = createWindow();
562 const helper = loadSharedVideoPlayer(window);
563 const { player, videojs } = buildPlayerHarness(window);
564 const requestedTimes = [];
565
566 player.duration(60);
567 player.setBufferedEnd(2);
568
569 window.fetch = jest.fn(async (url) =>
570 {
571 const parsed = new URL(url, 'http://localhost/');
572 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
573 requestedTimes.push(timeSeconds);
574 return new Response(null, {
575 status: 204,
576 headers: { 'X-Subtitle-Frame-Status': 'none' },
577 });
578 });
579
580 helper.bindImageSubtitleOverlay(player, videojs, {}, {
581 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
582 }, {
583 lookaheadSeconds: 0,
584 initialPrefetchSeconds: 0,
585 buildFrameRequest: ({ currentTime, streamIndex }) => ({
586 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
587 }),
588 });
589
590 await flushAsyncWork(window, 8);
591 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5]));
592
593 requestedTimes.length = 0;
594 player.setCurrentTime(20);
595 player.setBufferedEnd(40);
596 player.trigger('timeupdate');
597 await flushAsyncWork(window, 8);
598
599 expect(requestedTimes).toContain(20);
600 expect(requestedTimes.some((value) => value < 20)).toBe(false);
601 const prefetchAfterJump = requestedTimes.filter((value) => value > 20);
602 if (prefetchAfterJump.length)
603 {
604 expect(Math.min(...prefetchAfterJump)).toBeGreaterThanOrEqual(20.5);
605 }
606
607 window.close();
608 });
609
610 test('does not restart current subtitle request while one is in flight', async () =>
611 {
612 const window = createWindow();
613 const helper = loadSharedVideoPlayer(window);
614 const { player, videojs } = buildPlayerHarness(window);
615 const pendingResolvers = [];
616 const requestTimes = [];
617
618 window.fetch = jest.fn((url, init = {}) =>
619 {
620 const parsed = new URL(url, 'http://localhost/');
621 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
622
623 if (pendingResolvers.length === 0)
624 {
625 return new Promise((resolve) =>
626 {
627 pendingResolvers.push(() => resolve(new Response(null, {
628 status: 204,
629 headers: { 'X-Subtitle-Frame-Status': 'none' },
630 })));
631 });
632 }
633
634 expect(init.signal && init.signal.aborted).toBe(false);
635 return Promise.resolve(new Response(null, {
636 status: 204,
637 headers: { 'X-Subtitle-Frame-Status': 'none' },
638 }));
639 });
640
641 helper.bindImageSubtitleOverlay(player, videojs, {}, {
642 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
643 }, {
644 lookaheadSeconds: 0,
645 initialPrefetchSeconds: 0,
646 buildFrameRequest: ({ currentTime, streamIndex }) => ({
647 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
648 }),
649 });
650
651 await flushAsyncWork(window, 3);
652 expect(window.fetch).toHaveBeenCalledTimes(1);
653
654 player.setCurrentTime(1.5);
655 player.trigger('timeupdate');
656 player.setCurrentTime(2.25);
657 player.trigger('timeupdate');
658 await flushAsyncWork(window, 2);
659
660 expect(window.fetch).toHaveBeenCalledTimes(1);
661
662 pendingResolvers[0]();
663 await flushAsyncWork(window, 5);
664
665 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
666 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
667
668 window.close();
669 });
670
671 test('renders a prefetched frame for the current paused time without waiting for another timeupdate', async () =>
672 {
673 const window = createWindow();
674 const helper = loadSharedVideoPlayer(window);
675 const { player, videojs } = buildPlayerHarness(window);
676
677 player.duration(120);
678 player.setCurrentTime(118.95);
679
680 window.fetch = jest.fn(async (url) =>
681 {
682 const parsed = new URL(url, 'http://localhost/');
683 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
684 const headers = {
685 'Content-Type': 'image/png',
686 };
687
688 if (Math.abs(timeSeconds - 118.95) < 0.001)
689 {
690 headers['X-Subtitle-Frame-Start-Time'] = '118.90';
691 headers['X-Subtitle-Frame-End-Time'] = '119.00';
692 headers['X-Subtitle-Frame-Width'] = '640';
693 headers['X-Subtitle-Frame-Height'] = '80';
694 headers['X-Subtitle-Frame-Canvas-Width'] = '1920';
695 headers['X-Subtitle-Frame-Canvas-Height'] = '1080';
696 return new Response(new Uint8Array([137, 80, 78, 71]), { status: 200, headers });
697 }
698
699 return new Response(null, {
700 status: 204,
701 headers: { 'X-Subtitle-Frame-Status': 'none' },
702 });
703 });
704
705 helper.bindImageSubtitleOverlay(player, videojs, {}, {
706 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
707 }, {
708 currentFetchEnabled: false,
709 cacheMissFallbackEnabled: false,
710 lookaheadSeconds: 0,
711 initialPrefetchSeconds: 0,
712 buildFrameRequest: ({ currentTime, streamIndex }) => ({
713 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
714 }),
715 });
716
717 await flushAsyncWork(window, 10);
718
719 const overlay = player.el().querySelector('.video-subtitle-overlay');
720 const overlayImg = overlay && overlay.querySelector('img');
721 expect(overlay).toBeTruthy();
722 expect(overlayImg).toBeTruthy();
723 expect(overlay.style.display).toBe('block');
724 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
725
726 window.close();
727 });
728
729 test('syncs caption visibility from cache between sparse timeupdate events', async () =>
730 {
731 const window = createWindow();
732 const helper = loadSharedVideoPlayer(window);
733 const { player, videojs } = buildPlayerHarness(window);
734
735 // JSDOM raf cadence can be inconsistent; force timeout fallback for stable checks.
736 window.requestAnimationFrame = undefined;
737 window.cancelAnimationFrame = undefined;
738
739 player.duration(20);
740
741 window.fetch = jest.fn(async () =>
742 {
743 return new Response(new Uint8Array([137, 80, 78, 71]), {
744 status: 200,
745 headers: {
746 'Content-Type': 'image/png',
747 'X-Subtitle-Frame-Start-Time': '1',
748 'X-Subtitle-Frame-End-Time': '2',
749 'X-Subtitle-Frame-Width': '640',
750 'X-Subtitle-Frame-Height': '80',
751 'X-Subtitle-Frame-Canvas-Width': '1920',
752 'X-Subtitle-Frame-Canvas-Height': '1080',
753 },
754 });
755 });
756
757 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
758 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
759 }, {
760 lookaheadSeconds: 0,
761 initialPrefetchSeconds: 0,
762 buildFrameRequest: ({ currentTime, streamIndex }) => ({
763 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
764 }),
765 });
766
767 await flushAsyncWork(window, 8);
768
769 const overlay = player.el().querySelector('.video-subtitle-overlay');
770 expect(overlay).toBeTruthy();
771
772 player.setCurrentTime(1.2);
773 player.trigger('play');
774 await new Promise((resolve) => window.setTimeout(resolve, 50));
775 await flushAsyncWork(window, 2);
776 expect(overlay.style.display).toBe('block');
777
778 player.setCurrentTime(2.2);
779 await new Promise((resolve) => window.setTimeout(resolve, 50));
780 await flushAsyncWork(window, 2);
781 expect(overlay.style.display).toBe('none');
782
783 controller.detach();
784 await flushAsyncWork(window, 2);
785 window.close();
786 });
787
788 test('uses video-frame media clock for precise cached caption timing', async () =>
789 {
790 const window = createWindow();
791 const helper = loadSharedVideoPlayer(window);
792 const { player, videojs } = buildPlayerHarness(window);
793
794 let frameCallback = null;
795 let frameCallbackId = 0;
796 const videoEl = window.document.createElement('video');
797 videoEl.requestVideoFrameCallback = jest.fn((cb) =>
798 {
799 frameCallback = cb;
800 frameCallbackId += 1;
801 return frameCallbackId;
802 });
803 videoEl.cancelVideoFrameCallback = jest.fn();
804 player.el().appendChild(videoEl);
805
806 window.fetch = jest.fn(async () =>
807 {
808 return new Response(new Uint8Array([137, 80, 78, 71]), {
809 status: 200,
810 headers: {
811 'Content-Type': 'image/png',
812 'X-Subtitle-Frame-Start-Time': '1',
813 'X-Subtitle-Frame-End-Time': '2',
814 'X-Subtitle-Frame-Width': '640',
815 'X-Subtitle-Frame-Height': '80',
816 'X-Subtitle-Frame-Canvas-Width': '1920',
817 'X-Subtitle-Frame-Canvas-Height': '1080',
818 },
819 });
820 });
821
822 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
823 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
824 }, {
825 lookaheadSeconds: 0,
826 initialPrefetchSeconds: 0,
827 currentFetchEnabled: false,
828 cacheMissFallbackEnabled: false,
829 buildFrameRequest: ({ currentTime, streamIndex }) => ({
830 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
831 }),
832 });
833
834 await flushAsyncWork(window, 8);
835
836 const overlay = player.el().querySelector('.video-subtitle-overlay');
837 expect(overlay).toBeTruthy();
838 expect(videoEl.requestVideoFrameCallback).toHaveBeenCalled();
839 expect(typeof frameCallback).toBe('function');
840
841 player.setCurrentTime(9);
842 player.trigger('play');
843
844 frameCallback(1000, { mediaTime: 1.5 });
845 await flushAsyncWork(window, 3);
846 expect(overlay.style.display).toBe('block');
847
848 const nextFrameCallback = frameCallback;
849 nextFrameCallback(1016, { mediaTime: 2.2 });
850 await flushAsyncWork(window, 3);
851 expect(overlay.style.display).toBe('none');
852
853 controller.detach();
854 await flushAsyncWork(window, 2);
855 window.close();
856 });
857
858 test('keeps tightly spaced captions renderable across near-boundary samples', async () =>
859 {
860 const window = createWindow();
861 const helper = loadSharedVideoPlayer(window);
862 const { player, videojs } = buildPlayerHarness(window);
863
864 let objectUrlSeq = 0;
865 window.URL.createObjectURL = () => `blob:subtitle-${++objectUrlSeq}`;
866
867 window.fetch = jest.fn(async (url) =>
868 {
869 const parsed = new URL(url, 'http://localhost/');
870 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
871 const headers = {
872 'Content-Type': 'image/png',
873 'X-Subtitle-Frame-Width': '640',
874 'X-Subtitle-Frame-Height': '80',
875 'X-Subtitle-Frame-Canvas-Width': '1920',
876 'X-Subtitle-Frame-Canvas-Height': '1080',
877 };
878
879 if (Math.abs(timeSeconds - 8.351) < 0.02)
880 {
881 headers['X-Subtitle-Frame-Start-Time'] = '8.351';
882 headers['X-Subtitle-Frame-End-Time'] = '8.410';
883 } else
884 {
885 return new Response(null, {
886 status: 204,
887 headers: { 'X-Subtitle-Frame-Status': 'none' },
888 });
889 }
890
891 return new Response(new Uint8Array([137, 80, 78, 71]), {
892 status: 200,
893 headers,
894 });
895 });
896
897 helper.bindImageSubtitleOverlay(player, videojs, {}, {
898 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
899 }, {
900 currentFetchEnabled: false,
901 cacheMissFallbackEnabled: false,
902 lookaheadSeconds: 0,
903 initialPrefetchSeconds: 0,
904 buildFrameRequest: ({ currentTime, streamIndex }) => ({
905 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
906 }),
907 });
908
909 await flushAsyncWork(window, 8);
910
911 const overlay = player.el().querySelector('.video-subtitle-overlay');
912 const overlayImg = overlay && overlay.querySelector('img');
913 expect(overlay).toBeTruthy();
914
915 player.setCurrentTime(8.344);
916 player.trigger('play');
917 await new Promise((resolve) => window.setTimeout(resolve, 50));
918 await flushAsyncWork(window, 2);
919
920 expect(overlay.style.display).toBe('block');
921 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle-1');
922
923 window.close();
924 });
925
926 test('resyncs the displayed caption after a seek without waiting for timeupdate', async () =>
927 {
928 const window = createWindow();
929 const helper = loadSharedVideoPlayer(window);
930 const { player, videojs } = buildPlayerHarness(window);
931
932 window.requestAnimationFrame = undefined;
933 window.cancelAnimationFrame = undefined;
934
935 window.fetch = jest.fn(async (url) =>
936 {
937 const parsed = new URL(url, 'http://localhost/');
938 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
939 const headers = {
940 'Content-Type': 'image/png',
941 'X-Subtitle-Frame-Width': '640',
942 'X-Subtitle-Frame-Height': '80',
943 'X-Subtitle-Frame-Canvas-Width': '1920',
944 'X-Subtitle-Frame-Canvas-Height': '1080',
945 };
946
947 if (Math.abs(timeSeconds - 1.2) < 0.001)
948 {
949 headers['X-Subtitle-Frame-Start-Time'] = '1.0';
950 headers['X-Subtitle-Frame-End-Time'] = '2.0';
951 } else if (Math.abs(timeSeconds - 3.2) < 0.001)
952 {
953 headers['X-Subtitle-Frame-Start-Time'] = '3.0';
954 headers['X-Subtitle-Frame-End-Time'] = '4.0';
955 } else
956 {
957 return new Response(null, {
958 status: 204,
959 headers: { 'X-Subtitle-Frame-Status': 'none' },
960 });
961 }
962
963 return new Response(new Uint8Array([137, 80, 78, 71]), {
964 status: 200,
965 headers,
966 });
967 });
968
969 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
970 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
971 }, {
972 currentFetchEnabled: false,
973 cacheMissFallbackEnabled: false,
974 lookaheadSeconds: 0,
975 initialPrefetchSeconds: 0,
976 buildFrameRequest: ({ currentTime, streamIndex }) => ({
977 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
978 }),
979 });
980
981 await flushAsyncWork(window, 8);
982
983 const overlay = player.el().querySelector('.video-subtitle-overlay');
984 expect(overlay).toBeTruthy();
985
986 player.setCurrentTime(1.2);
987 player.trigger('play');
988 await new Promise((resolve) => window.setTimeout(resolve, 50));
989 await flushAsyncWork(window, 2);
990 expect(overlay.style.display).toBe('block');
991
992 player.trigger('pause');
993 player.setCurrentTime(3.2);
994 player.trigger('seeked');
995 await flushAsyncWork(window, 6);
996
997 expect(overlay.style.display).toBe('block');
998 expect(overlay.querySelector('img').getAttribute('src')).toBe('blob:subtitle');
999
1000 controller.detach();
1001 await flushAsyncWork(window, 2);
1002 window.close();
1003 });
1004
1005 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
1006 {
1007 const window = createWindow();
1008 const helper = loadSharedVideoPlayer(window);
1009 const { player, videojs } = buildPlayerHarness(window);
1010 const activeSignals = [];
1011
1012 window.fetch = jest.fn((url, init = {}) =>
1013 {
1014 const parsed = new URL(url, 'http://localhost/');
1015 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1016
1017 if (timeSeconds === 0)
1018 {
1019 return Promise.resolve(new Response(null, {
1020 status: 204,
1021 headers: { 'X-Subtitle-Frame-Status': 'none' },
1022 }));
1023 }
1024
1025 activeSignals.push(init.signal || null);
1026
1027 return new Promise((resolve, reject) =>
1028 {
1029 if (init.signal && typeof init.signal.addEventListener === 'function')
1030 {
1031 init.signal.addEventListener('abort', () =>
1032 {
1033 reject(new DOMException('Aborted', 'AbortError'));
1034 }, { once: true });
1035 }
1036 });
1037 });
1038
1039 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1040 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1041 }, {
1042 lookaheadSeconds: 1,
1043 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1044 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1045 }),
1046 });
1047
1048 await flushAsyncWork(window, 3);
1049 expect(activeSignals.length).toBeGreaterThan(0);
1050
1051 controller.detach();
1052 await flushAsyncWork(window, 2);
1053
1054 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
1055
1056 window.close();
1057 });
1058
1059 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
1060 {
1061 const window = createWindow();
1062 const helper = loadSharedVideoPlayer(window);
1063 const { player, videojs } = buildPlayerHarness(window);
1064 const sentBatches = [];
1065
1066 window.fetch = jest.fn(async () =>
1067 {
1068 return new Response('png-data', {
1069 status: 200,
1070 headers: {
1071 'Content-Type': 'image/png',
1072 'X-Subtitle-Frame-Status': 'ok',
1073 'X-Subtitle-Request-Received-At-Ms': '1000',
1074 'X-Subtitle-Response-Sent-At-Ms': '1012',
1075 'X-Subtitle-Frame-Start-Time': '1.5',
1076 'X-Subtitle-Frame-End-Time': '3.2',
1077 'X-Subtitle-Frame-Width': '320',
1078 'X-Subtitle-Frame-Height': '180',
1079 'X-Subtitle-Frame-Canvas-Width': '640',
1080 'X-Subtitle-Frame-Canvas-Height': '360',
1081 },
1082 });
1083 });
1084
1085 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1086 sessionId: 'sess-1',
1087 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1088 }, {
1089 lookaheadSeconds: 0,
1090 sendSubtitleLogBatch: (entries) =>
1091 {
1092 sentBatches.push(entries);
1093 return Promise.resolve();
1094 },
1095 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1096 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1097 }),
1098 });
1099
1100 await flushAsyncWork(window, 8);
1101 controller.detach();
1102 await flushAsyncWork(window, 4);
1103
1104 const flattened = sentBatches.flat();
1105 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
1106 'subtitle_png_requested',
1107 'subtitle_png_sent',
1108 'subtitle_png_received',
1109 ]));
1110
1111 window.close();
1112 });
1113
1114 test('logs prefetch subtitle lifecycle events', async () =>
1115 {
1116 const window = createWindow();
1117 const helper = loadSharedVideoPlayer(window);
1118 const { player, videojs } = buildPlayerHarness(window);
1119 const sentBatches = [];
1120
1121 window.fetch = jest.fn(async () =>
1122 {
1123 return new Response(null, {
1124 status: 204,
1125 headers: {
1126 'X-Subtitle-Frame-Status': 'none',
1127 'X-Subtitle-Request-Received-At-Ms': '1000',
1128 'X-Subtitle-Response-Sent-At-Ms': '1010',
1129 'X-Subtitle-Frame-Start-Time': '2',
1130 'X-Subtitle-Frame-End-Time': '3',
1131 },
1132 });
1133 });
1134
1135 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1136 sessionId: 'sess-1',
1137 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1138 }, {
1139 lookaheadSeconds: 1,
1140 sendSubtitleLogBatch: (entries) =>
1141 {
1142 sentBatches.push(entries);
1143 return Promise.resolve();
1144 },
1145 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1146 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1147 }),
1148 });
1149
1150 await flushAsyncWork(window, 8);
1151 controller.detach();
1152 await flushAsyncWork(window, 4);
1153
1154 const flattened = sentBatches.flat();
1155 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
1156 expect(prefetchEvents).toEqual(expect.arrayContaining([
1157 'subtitle_png_requested',
1158 'subtitle_png_sent',
1159 'subtitle_png_not_available',
1160 ]));
1161
1162 window.close();
1163 });
1164
1165 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
1166 {
1167 const window = createWindow();
1168 const helper = loadSharedVideoPlayer(window);
1169 const { player, videojs } = buildPlayerHarness(window);
1170 const sentBatches = [];
1171
1172 player.setCurrentTime(8);
1173 window.fetch = jest.fn(async () =>
1174 {
1175 return new Response(null, {
1176 status: 204,
1177 headers: {
1178 'X-Subtitle-Frame-Status': 'none',
1179 'X-Subtitle-Request-Received-At-Ms': '1000',
1180 'X-Subtitle-Response-Sent-At-Ms': '1010',
1181 },
1182 });
1183 });
1184
1185 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1186 sessionId: 'sess-1',
1187 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1188 }, {
1189 currentFetchEnabled: false,
1190 cacheMissFallbackEnabled: false,
1191 lookaheadSeconds: 0,
1192 sendSubtitleLogBatch: (entries) =>
1193 {
1194 sentBatches.push(entries);
1195 return Promise.resolve();
1196 },
1197 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1198 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1199 }),
1200 });
1201
1202 await flushAsyncWork(window, 8);
1203 controller.detach();
1204 await flushAsyncWork(window, 4);
1205
1206 const flattened = sentBatches.flat();
1207 expect(flattened.length).toBeGreaterThan(0);
1208 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
1209 expect(requestKinds.has('prefetch')).toBe(true);
1210 expect(requestKinds.has('current')).toBe(false);
1211
1212 window.close();
1213 });
1214
1215 test('cache-only mode falls back to throttled current fetch on cache miss', async () =>
1216 {
1217 const window = createWindow();
1218 const helper = loadSharedVideoPlayer(window);
1219 const { player, videojs } = buildPlayerHarness(window);
1220
1221 let requestCount = 0;
1222 window.fetch = jest.fn(async () =>
1223 {
1224 requestCount += 1;
1225 if (requestCount === 1)
1226 {
1227 return new Response(new Uint8Array([137, 80, 78, 71]), {
1228 status: 200,
1229 headers: {
1230 'Content-Type': 'image/png',
1231 'X-Subtitle-Frame-Start-Time': '2.00',
1232 'X-Subtitle-Frame-End-Time': '2.50',
1233 'X-Subtitle-Frame-Width': '600',
1234 'X-Subtitle-Frame-Height': '72',
1235 'X-Subtitle-Frame-Canvas-Width': '1920',
1236 'X-Subtitle-Frame-Canvas-Height': '1080',
1237 },
1238 });
1239 }
1240
1241 return new Response(null, {
1242 status: 204,
1243 headers: { 'X-Subtitle-Frame-Status': 'none' },
1244 });
1245 });
1246
1247 player.setCurrentTime(2.2);
1248
1249 helper.bindImageSubtitleOverlay(player, videojs, {}, {
1250 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1251 }, {
1252 currentFetchEnabled: false,
1253 cacheMissFallbackIntervalMs: 2000,
1254 lookaheadSeconds: 0,
1255 initialPrefetchSeconds: 0,
1256 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1257 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1258 }),
1259 });
1260
1261 await flushAsyncWork(window, 10);
1262
1263 const overlay = player.el().querySelector('.video-subtitle-overlay');
1264 const overlayImg = overlay && overlay.querySelector('img');
1265 expect(window.fetch).toHaveBeenCalled();
1266 expect(overlay.style.display).toBe('block');
1267 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
1268
1269 window.close();
1270 });
1271
1272 test('cache-miss fallback does not reset prefetch progress on repeated triggers', async () =>
1273 {
1274 const window = createWindow();
1275 const helper = loadSharedVideoPlayer(window);
1276 const { player, videojs } = buildPlayerHarness(window);
1277
1278 let nowMs = 1000;
1279 const realNow = window.Date.now;
1280 window.Date.now = () => nowMs;
1281
1282 let abortedCount = 0;
1283 window.fetch = jest.fn((url, init = {}) =>
1284 {
1285 return new Promise((resolve, reject) =>
1286 {
1287 const signal = init && init.signal;
1288 const onAbort = () =>
1289 {
1290 abortedCount += 1;
1291 const err = new Error('aborted');
1292 err.name = 'AbortError';
1293 reject(err);
1294 };
1295
1296 if (signal && typeof signal.addEventListener === 'function')
1297 {
1298 if (signal.aborted) return onAbort();
1299 signal.addEventListener('abort', onAbort, { once: true });
1300 }
1301
1302 window.setTimeout(() =>
1303 {
1304 if (signal && signal.aborted) return;
1305 resolve(new Response(null, {
1306 status: 204,
1307 headers: { 'X-Subtitle-Frame-Status': 'none' },
1308 }));
1309 }, 80);
1310 });
1311 });
1312
1313 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1314 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1315 }, {
1316 currentFetchEnabled: false,
1317 cacheMissFallbackIntervalMs: 20,
1318 lookaheadSeconds: 2,
1319 initialPrefetchSeconds: 0,
1320 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1321 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1322 }),
1323 });
1324
1325 await flushAsyncWork(window, 4);
1326
1327 player.setCurrentTime(5);
1328 player.trigger('timeupdate');
1329 nowMs += 40;
1330 player.setCurrentTime(5.5);
1331 player.trigger('timeupdate');
1332 nowMs += 40;
1333 player.setCurrentTime(6);
1334 player.trigger('timeupdate');
1335
1336 await flushAsyncWork(window, 12);
1337 expect(abortedCount).toBe(0);
1338
1339 window.Date.now = realNow;
1340 controller.detach();
1341 window.close();
1342 });
1343
1344 test('cache-only mode performs initial warmup prefetch window on load', async () =>
1345 {
1346 const window = createWindow();
1347 const helper = loadSharedVideoPlayer(window);
1348 const { player, videojs } = buildPlayerHarness(window);
1349 const requestedTimes = [];
1350
1351 window.fetch = jest.fn(async (url) =>
1352 {
1353 const parsed = new URL(url, 'http://localhost/');
1354 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
1355 return new Response(null, {
1356 status: 204,
1357 headers: {
1358 'X-Subtitle-Frame-Status': 'none',
1359 'X-Subtitle-Request-Received-At-Ms': '1000',
1360 'X-Subtitle-Response-Sent-At-Ms': '1010',
1361 },
1362 });
1363 });
1364
1365 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1366 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1367 }, {
1368 currentFetchEnabled: false,
1369 lookaheadSeconds: 0,
1370 initialPrefetchSeconds: 2,
1371 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1372 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1373 }),
1374 });
1375
1376 await flushAsyncWork(window, 12);
1377
1378 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2]));
1379
1380 controller.detach();
1381 await flushAsyncWork(window, 2);
1382 window.close();
1383 });
1384
1385 test('renders requested and received subtitle markers on the seek bar', async () =>
1386 {
1387 const window = createWindow();
1388 const helper = loadSharedVideoPlayer(window);
1389 const { player, videojs } = buildPlayerHarness(window);
1390
1391 window.fetch = jest.fn(async () =>
1392 {
1393 return new Response('png-data', {
1394 status: 200,
1395 headers: {
1396 'Content-Type': 'image/png',
1397 'X-Subtitle-Frame-Status': 'ok',
1398 'X-Subtitle-Request-Received-At-Ms': '1000',
1399 'X-Subtitle-Response-Sent-At-Ms': '1012',
1400 'X-Subtitle-Frame-Start-Time': '2.5',
1401 'X-Subtitle-Frame-End-Time': '3.5',
1402 'X-Subtitle-Frame-Width': '320',
1403 'X-Subtitle-Frame-Height': '180',
1404 'X-Subtitle-Frame-Canvas-Width': '640',
1405 'X-Subtitle-Frame-Canvas-Height': '360',
1406 },
1407 });
1408 });
1409
1410 player.duration(10);
1411 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1412 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1413 }, {
1414 lookaheadSeconds: 0,
1415 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1416 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1417 }),
1418 });
1419
1420 await flushAsyncWork(window, 8);
1421
1422 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1423 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1424 expect(requestedMarker).toBeTruthy();
1425 expect(receivedMarker).toBeTruthy();
1426 expect(requestedMarker.style.display).toBe('block');
1427 expect(receivedMarker.style.display).toBe('block');
1428 expect(requestedMarker.style.left).toBe('100.0000%');
1429 expect(receivedMarker.style.left).toBe('25.0000%');
1430 expect(requestedMarker.textContent).toBe(']');
1431 expect(receivedMarker.textContent).toBe('[');
1432
1433 controller.detach();
1434 await new Promise((resolve) => window.setTimeout(resolve, 300));
1435 await flushAsyncWork(window, 2);
1436
1437 window.close();
1438 });
1439
1440 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
1441 {
1442 const window = createWindow();
1443 const helper = loadSharedVideoPlayer(window);
1444 const { player, videojs } = buildPlayerHarness(window);
1445
1446 player.duration(10);
1447 player.setCurrentTime(4);
1448 window.fetch = jest.fn(async () =>
1449 {
1450 return new Response(null, {
1451 status: 204,
1452 headers: {
1453 'X-Subtitle-Frame-Status': 'none',
1454 'X-Subtitle-Request-Received-At-Ms': '1000',
1455 'X-Subtitle-Response-Sent-At-Ms': '1010',
1456 },
1457 });
1458 });
1459
1460 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1461 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1462 }, {
1463 lookaheadSeconds: 0,
1464 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1465 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1466 }),
1467 });
1468
1469 await flushAsyncWork(window, 8);
1470
1471 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1472 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1473 expect(requestedMarker).toBeTruthy();
1474 expect(receivedMarker).toBeTruthy();
1475 expect(requestedMarker.style.display).toBe('block');
1476 expect(receivedMarker.style.display).toBe('block');
1477 expect(requestedMarker.style.left).toBe('100.0000%');
1478 expect(receivedMarker.style.left).toBe('100.0000%');
1479 expect(requestedMarker.textContent).toBe(']');
1480 expect(receivedMarker.textContent).toBe('[');
1481
1482 controller.detach();
1483 await flushAsyncWork(window, 2);
1484 window.close();
1485 });
1486
1487 test('advances seek markers to the end of an empty prefetch tail window', async () =>
1488 {
1489 const window = createWindow();
1490 const helper = loadSharedVideoPlayer(window);
1491 const { player, videojs } = buildPlayerHarness(window);
1492
1493 player.duration(120);
1494 player.setCurrentTime(110);
1495
1496 window.fetch = jest.fn(async () =>
1497 {
1498 return new Response(null, {
1499 status: 204,
1500 headers: {
1501 'X-Subtitle-Frame-Status': 'none',
1502 'X-Subtitle-Request-Received-At-Ms': '1000',
1503 'X-Subtitle-Response-Sent-At-Ms': '1010',
1504 },
1505 });
1506 });
1507
1508 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1509 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1510 }, {
1511 lookaheadSeconds: 0,
1512 initialPrefetchSeconds: 0,
1513 currentFetchEnabled: false,
1514 cacheMissFallbackEnabled: false,
1515 prefetchAdaptiveStepEnabled: true,
1516 prefetchStepSecondsMin: 10,
1517 prefetchStepSecondsMax: 10,
1518 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1519 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1520 }),
1521 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
1522 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
1523 }),
1524 });
1525
1526 player.trigger('timeupdate');
1527 await flushAsyncWork(window, 8);
1528
1529 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1530 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1531 expect(requestedMarker).toBeTruthy();
1532 expect(receivedMarker).toBeTruthy();
1533 expect(requestedMarker.style.left).toBe('100.0000%');
1534 expect(receivedMarker.style.left).toBe('100.0000%');
1535
1536 controller.detach();
1537 await flushAsyncWork(window, 2);
1538 window.close();
1539 });
1540
1541 test('keeps existing marker positions while the next request is still in flight', async () =>
1542 {
1543 const window = createWindow();
1544 const helper = loadSharedVideoPlayer(window);
1545 const { player, videojs } = buildPlayerHarness(window);
1546 let pendingResolve = null;
1547
1548 player.duration(10);
1549 window.fetch = jest.fn((url) =>
1550 {
1551 const parsed = new URL(url, 'http://localhost/');
1552 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1553
1554 if (timeSeconds === 0)
1555 {
1556 return Promise.resolve(new Response('png-data', {
1557 status: 200,
1558 headers: {
1559 'Content-Type': 'image/png',
1560 'X-Subtitle-Frame-Status': 'ok',
1561 'X-Subtitle-Frame-Start-Time': '2',
1562 'X-Subtitle-Frame-End-Time': '3',
1563 'X-Subtitle-Frame-Width': '320',
1564 'X-Subtitle-Frame-Height': '180',
1565 'X-Subtitle-Frame-Canvas-Width': '640',
1566 'X-Subtitle-Frame-Canvas-Height': '360',
1567 },
1568 }));
1569 }
1570
1571 return new Promise((resolve) =>
1572 {
1573 pendingResolve = resolve;
1574 });
1575 });
1576
1577 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1578 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1579 }, {
1580 lookaheadSeconds: 0,
1581 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1582 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1583 }),
1584 });
1585
1586 await flushAsyncWork(window, 8);
1587
1588 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1589 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1590 expect(requestedMarker).toBeTruthy();
1591 expect(receivedMarker).toBeTruthy();
1592 expect(requestedMarker.style.left).toBe('0.0000%');
1593 expect(receivedMarker.style.left).toBe('20.0000%');
1594
1595 player.setCurrentTime(1.5);
1596 player.trigger('timeupdate');
1597 await flushAsyncWork(window, 2);
1598
1599 expect(requestedMarker.style.left).toBe('0.0000%');
1600 expect(receivedMarker.style.left).toBe('20.0000%');
1601
1602 pendingResolve(new Response(null, {
1603 status: 204,
1604 headers: {
1605 'X-Subtitle-Frame-Status': 'none',
1606 },
1607 }));
1608
1609 await flushAsyncWork(window, 8);
1610 expect(requestedMarker.style.display).toBe('block');
1611 expect(receivedMarker.style.display).toBe('block');
1612 expect(requestedMarker.style.left).toBe('15.0000%');
1613 expect(receivedMarker.style.left).toBe('20.0000%');
1614
1615 controller.detach();
1616 await flushAsyncWork(window, 2);
1617 window.close();
1618 });
1619
1620 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
1621 {
1622 const window = createWindow();
1623 const helper = loadSharedVideoPlayer(window);
1624 const { player, videojs } = buildPlayerHarness(window);
1625 const requestedTimes = [];
1626
1627 player.duration(12);
1628 window.fetch = jest.fn(async (url) =>
1629 {
1630 const parsed = new URL(url, 'http://localhost/');
1631 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1632 requestedTimes.push(timeSeconds);
1633
1634 if (requestedTimes.length === 1)
1635 {
1636 return new Response('png-data', {
1637 status: 200,
1638 headers: {
1639 'Content-Type': 'image/png',
1640 'X-Subtitle-Frame-Status': 'ok',
1641 'X-Subtitle-Frame-Start-Time': '4',
1642 'X-Subtitle-Frame-End-Time': '5',
1643 'X-Subtitle-Frame-Width': '320',
1644 'X-Subtitle-Frame-Height': '180',
1645 'X-Subtitle-Frame-Canvas-Width': '640',
1646 'X-Subtitle-Frame-Canvas-Height': '360',
1647 },
1648 });
1649 }
1650
1651 return new Response('png-data', {
1652 status: 200,
1653 headers: {
1654 'Content-Type': 'image/png',
1655 'X-Subtitle-Frame-Status': 'ok',
1656 'X-Subtitle-Frame-Start-Time': '2',
1657 'X-Subtitle-Frame-End-Time': '3',
1658 'X-Subtitle-Frame-Width': '320',
1659 'X-Subtitle-Frame-Height': '180',
1660 'X-Subtitle-Frame-Canvas-Width': '640',
1661 'X-Subtitle-Frame-Canvas-Height': '360',
1662 },
1663 });
1664 });
1665
1666 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1667 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1668 }, {
1669 lookaheadSeconds: 0,
1670 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1671 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1672 }),
1673 });
1674
1675 await flushAsyncWork(window, 8);
1676
1677 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1678 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1679 expect(requestedMarker).toBeTruthy();
1680 expect(receivedMarker).toBeTruthy();
1681 expect(requestedMarker.style.left).toBe('100.0000%');
1682 expect(receivedMarker.style.left).toBe('33.3333%');
1683
1684 player.setCurrentTime(1.5);
1685 player.trigger('timeupdate');
1686 await flushAsyncWork(window, 8);
1687
1688 // Second response reports an older start time, but markers stay monotonic.
1689 expect(requestedMarker.style.left).toBe('100.0000%');
1690 expect(receivedMarker.style.left).toBe('33.3333%');
1691
1692 controller.detach();
1693 await flushAsyncWork(window, 2);
1694 window.close();
1695 });
1696
1697 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
1698 {
1699 const window = createWindow();
1700 const helper = loadSharedVideoPlayer(window);
1701 const { player, videojs } = buildPlayerHarness(window);
1702 const requestedTimes = [];
1703
1704 window.fetch = jest.fn((url, init = {}) =>
1705 {
1706 const parsed = new URL(url, 'http://localhost/');
1707 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1708 requestedTimes.push(timeSeconds);
1709
1710 if (requestedTimes.length === 1)
1711 {
1712 return new Promise((resolve, reject) =>
1713 {
1714 if (init.signal && typeof init.signal.addEventListener === 'function')
1715 {
1716 init.signal.addEventListener('abort', () =>
1717 {
1718 reject(new window.DOMException('Aborted', 'AbortError'));
1719 }, { once: true });
1720 }
1721 });
1722 }
1723
1724 return Promise.resolve(new Response(null, {
1725 status: 204,
1726 headers: {
1727 'X-Subtitle-Frame-Status': 'none',
1728 },
1729 }));
1730 });
1731
1732 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1733 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1734 }, {
1735 lookaheadSeconds: 0,
1736 currentRequestTimeoutMs: 300,
1737 logToConsole: false,
1738 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1739 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1740 }),
1741 });
1742
1743 await flushAsyncWork(window, 4);
1744 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1745 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1746
1747 player.setCurrentTime(5);
1748 player.trigger('seeking');
1749 await flushAsyncWork(window, 20);
1750
1751 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1752 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
1753
1754 controller.detach();
1755 await flushAsyncWork(window, 2);
1756 window.close();
1757 });
1758
1759 test('recovers when a current subtitle request hangs and times out', async () =>
1760 {
1761 const window = createWindow();
1762 const helper = loadSharedVideoPlayer(window);
1763 const { player, videojs } = buildPlayerHarness(window);
1764 const requestedTimes = [];
1765
1766 window.fetch = jest.fn((url, init = {}) =>
1767 {
1768 const parsed = new URL(url, 'http://localhost/');
1769 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1770 requestedTimes.push(timeSeconds);
1771
1772 if (requestedTimes.length === 1)
1773 {
1774 return new Promise((resolve, reject) =>
1775 {
1776 if (init.signal && typeof init.signal.addEventListener === 'function')
1777 {
1778 init.signal.addEventListener('abort', () =>
1779 {
1780 reject(new window.DOMException('Aborted', 'AbortError'));
1781 }, { once: true });
1782 }
1783 });
1784 }
1785
1786 return Promise.resolve(new Response(null, {
1787 status: 204,
1788 headers: { 'X-Subtitle-Frame-Status': 'none' },
1789 }));
1790 });
1791
1792 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1793 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1794 }, {
1795 lookaheadSeconds: 0,
1796 currentRequestTimeoutMs: 250,
1797 logToConsole: false,
1798 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1799 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1800 }),
1801 });
1802
1803 await flushAsyncWork(window, 3);
1804
1805 player.setCurrentTime(1.5);
1806 player.trigger('timeupdate');
1807
1808 await new Promise((resolve) => window.setTimeout(resolve, 320));
1809 player.trigger('timeupdate');
1810 await new Promise((resolve) => window.setTimeout(resolve, 220));
1811 await flushAsyncWork(window, 20);
1812
1813 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1814 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
1815
1816 controller.detach();
1817 await new Promise((resolve) => window.setTimeout(resolve, 200));
1818 await flushAsyncWork(window, 20);
1819 window.close();
1820 });
1821
1822 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1823 {
1824 const window = createWindow();
1825 const helper = loadSharedVideoPlayer(window);
1826 const { player, videojs } = buildPlayerHarness(window);
1827
1828 player.duration(10);
1829 player.setCurrentTime(2);
1830 window.fetch = jest.fn(async (url) =>
1831 {
1832 const parsed = new URL(url, 'http://localhost/');
1833 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1834
1835 if (Math.abs(timeSeconds - 2) < 1e-6)
1836 {
1837 return new Response('png-data', {
1838 status: 200,
1839 headers: {
1840 'Content-Type': 'image/png',
1841 'X-Subtitle-Frame-Status': 'ok',
1842 'X-Subtitle-Frame-Start-Time': '2',
1843 'X-Subtitle-Frame-End-Time': '3',
1844 'X-Subtitle-Frame-Width': '320',
1845 'X-Subtitle-Frame-Height': '180',
1846 'X-Subtitle-Frame-Canvas-Width': '640',
1847 'X-Subtitle-Frame-Canvas-Height': '360',
1848 },
1849 });
1850 }
1851
1852 return new Response(null, {
1853 status: 204,
1854 headers: {
1855 'X-Subtitle-Frame-Status': 'none',
1856 },
1857 });
1858 });
1859
1860 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1861 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1862 }, {
1863 lookaheadSeconds: 0,
1864 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1865 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1866 }),
1867 });
1868
1869 await flushAsyncWork(window, 8);
1870 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1871 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1872
1873 player.setCurrentTime(4);
1874 player.trigger('timeupdate');
1875 await flushAsyncWork(window, 8);
1876 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1877 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1878
1879 const overlay = player.el().querySelector('.video-subtitle-overlay');
1880 expect(overlay).toBeTruthy();
1881 expect(overlay.style.display).toBe('none');
1882
1883 player.setCurrentTime(2.5);
1884 player.trigger('timeupdate');
1885 await flushAsyncWork(window, 8);
1886
1887 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1888 expect(overlay.style.display).toBe('block');
1889
1890 controller.detach();
1891 await flushAsyncWork(window, 2);
1892 window.close();
1893 });
1894
1895 test('registers stream cache service worker once when supported', async () =>
1896 {
1897 const window = createWindow();
1898 const helper = loadSharedVideoPlayer(window);
1899 const register = jest.fn(async () => ({}));
1900 window.navigator.serviceWorker = { register };
1901
1902 const first = await helper.enableVideoStreamClientCache();
1903 const second = await helper.enableVideoStreamClientCache();
1904
1905 expect(first).toBe(true);
1906 expect(second).toBe(true);
1907 expect(register).toHaveBeenCalledTimes(1);
1908 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1909 scope: '/',
1910 updateViaCache: 'none',
1911 });
1912
1913 window.close();
1914 });
1915
1916 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1917 {
1918 const window = createWindow();
1919 const helper = loadSharedVideoPlayer(window);
1920 const requestedUrls = [];
1921
1922 window.fetch = jest.fn(async (input) =>
1923 {
1924 const url = String(input && input.url ? input.url : input);
1925 requestedUrls.push(url);
1926
1927 if (url === 'http://localhost/master.m3u8')
1928 {
1929 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1930 status: 200,
1931 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1932 });
1933 }
1934
1935 if (url === 'http://localhost/stream_0.m3u8')
1936 {
1937 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1938 status: 200,
1939 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1940 });
1941 }
1942
1943 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
1944 {
1945 return new Response(new Uint8Array([1, 2, 3, 4]), {
1946 status: 200,
1947 headers: { 'Content-Type': 'video/mp2t' },
1948 });
1949 }
1950
1951 return new Response(null, { status: 404 });
1952 });
1953
1954 const controller = helper.bindStreamAheadPrefetch({
1955 playlistUrl: 'http://localhost/master.m3u8',
1956 pollIntervalMs: 0,
1957 credentials: 'same-origin',
1958 });
1959
1960 expect(controller).toBeTruthy();
1961 await controller.done();
1962
1963 expect(requestedUrls).toEqual(expect.arrayContaining([
1964 'http://localhost/master.m3u8',
1965 'http://localhost/stream_0.m3u8',
1966 'http://localhost/seg0.ts',
1967 'http://localhost/seg1.ts',
1968 ]));
1969
1970 controller.stop();
1971 window.close();
1972 });
1973
1974 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
1975 {
1976 const window = createWindow();
1977 const helper = loadSharedVideoPlayer(window);
1978 const progressSamples = [];
1979
1980 window.fetch = jest.fn(async (input) =>
1981 {
1982 const url = String(input && input.url ? input.url : input);
1983
1984 if (url === 'http://localhost/master.m3u8')
1985 {
1986 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
1987 status: 200,
1988 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1989 });
1990 }
1991
1992 if (url === 'http://localhost/stream_0.m3u8')
1993 {
1994 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
1995 status: 200,
1996 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
1997 });
1998 }
1999
2000 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
2001 {
2002 return new Response(new Uint8Array([1, 2, 3, 4]), {
2003 status: 200,
2004 headers: { 'Content-Type': 'video/mp2t' },
2005 });
2006 }
2007
2008 return new Response(null, { status: 404 });
2009 });
2010
2011 const controller = helper.bindStreamAheadPrefetch({
2012 playlistUrl: 'http://localhost/master.m3u8',
2013 pollIntervalMs: 0,
2014 credentials: 'same-origin',
2015 });
2016
2017 expect(controller).toBeTruthy();
2018 const unsubscribe = controller.subscribe((status) =>
2019 {
2020 progressSamples.push(status && status.cachedThroughSeconds);
2021 });
2022
2023 await controller.done();
2024 unsubscribe();
2025
2026 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2027
2028 controller.stop();
2029 window.close();
2030 });
2031
2032 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
2033 {
2034 const window = createWindow();
2035 const helper = loadSharedVideoPlayer(window);
2036 const progressSamples = [];
2037
2038 window.fetch = jest.fn(async (input) =>
2039 {
2040 const url = String(input && input.url ? input.url : input);
2041
2042 if (url === 'http://localhost/master.m3u8')
2043 {
2044 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2045 status: 200,
2046 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2047 });
2048 }
2049
2050 if (url === 'http://localhost/stream_0.m3u8')
2051 {
2052 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
2053 status: 200,
2054 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2055 });
2056 }
2057
2058 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
2059 {
2060 return new Response(new Uint8Array([1, 2, 3, 4]), {
2061 status: 200,
2062 headers: { 'Content-Type': 'video/mp2t' },
2063 });
2064 }
2065
2066 return new Response(null, { status: 404 });
2067 });
2068
2069 const controller = helper.bindStreamAheadPrefetch({
2070 playlistUrl: 'http://localhost/master.m3u8',
2071 pollIntervalMs: 0,
2072 credentials: 'same-origin',
2073 });
2074
2075 expect(controller).toBeTruthy();
2076 const unsubscribe = controller.subscribe((status) =>
2077 {
2078 progressSamples.push(status && status.cachedThroughSeconds);
2079 });
2080
2081 await controller.done();
2082 unsubscribe();
2083
2084 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2085
2086 controller.stop();
2087 window.close();
2088 });
2089
2090 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
2091 {
2092 const window = createWindow();
2093 const helper = loadSharedVideoPlayer(window);
2094 const progressSamples = [];
2095
2096 window.fetch = jest.fn(async (input) =>
2097 {
2098 const url = String(input && input.url ? input.url : input);
2099
2100 if (url === 'http://localhost/master.m3u8')
2101 {
2102 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2103 status: 200,
2104 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2105 });
2106 }
2107
2108 if (url === 'http://localhost/stream_0.m3u8')
2109 {
2110 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
2111 status: 200,
2112 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2113 });
2114 }
2115
2116 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
2117 {
2118 return new Response(new Uint8Array([1, 2, 3, 4]), {
2119 status: 200,
2120 headers: { 'Content-Type': 'video/mp4' },
2121 });
2122 }
2123
2124 return new Response(null, { status: 404 });
2125 });
2126
2127 const controller = helper.bindStreamAheadPrefetch({
2128 playlistUrl: 'http://localhost/master.m3u8',
2129 pollIntervalMs: 0,
2130 credentials: 'same-origin',
2131 });
2132
2133 expect(controller).toBeTruthy();
2134 const unsubscribe = controller.subscribe((status) =>
2135 {
2136 progressSamples.push(status && status.cachedThroughSeconds);
2137 });
2138
2139 await controller.done();
2140 unsubscribe();
2141
2142 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2143
2144 controller.stop();
2145 window.close();
2146 });
2147
2148 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
2149 {
2150 const window = createWindow();
2151 const helper = loadSharedVideoPlayer(window);
2152 const statusSamples = [];
2153
2154 window.fetch = jest.fn(async (input) =>
2155 {
2156 const url = String(input && input.url ? input.url : input);
2157
2158 if (url === 'http://localhost/master.m3u8')
2159 {
2160 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2161 status: 200,
2162 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2163 });
2164 }
2165
2166 if (url === 'http://localhost/stream_0.m3u8')
2167 {
2168 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
2169 status: 200,
2170 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2171 });
2172 }
2173
2174 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
2175 {
2176 return new Response(new Uint8Array([1, 2, 3, 4]), {
2177 status: 200,
2178 headers: { 'Content-Type': 'application/octet-stream' },
2179 });
2180 }
2181
2182 return new Response(null, { status: 404 });
2183 });
2184
2185 const controller = helper.bindStreamAheadPrefetch({
2186 playlistUrl: 'http://localhost/master.m3u8',
2187 pollIntervalMs: 0,
2188 credentials: 'same-origin',
2189 });
2190
2191 expect(controller).toBeTruthy();
2192 const unsubscribe = controller.subscribe((status) =>
2193 {
2194 statusSamples.push(status || {});
2195 });
2196
2197 await controller.done();
2198 unsubscribe();
2199
2200 const finalStatus = statusSamples[statusSamples.length - 1] || {};
2201 expect(finalStatus.totalSegmentCount).toBe(2);
2202 expect(finalStatus.fetchedSegmentCount).toBe(2);
2203 expect(finalStatus.cachedThroughRatio).toBe(1);
2204
2205 controller.stop();
2206 window.close();
2207 });
2208
2209 test('clears cached stream assets for a finished playlist session', async () =>
2210 {
2211 const window = createWindow();
2212 const helper = loadSharedVideoPlayer(window);
2213 const requests = [
2214 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
2215 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
2216 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
2217 ];
2218 const deleteCalls = [];
2219 const cache = {
2220 keys: jest.fn(async () => requests),
2221 delete: jest.fn(async (request) =>
2222 {
2223 deleteCalls.push(request.url);
2224 return true;
2225 }),
2226 };
2227 window.caches = {
2228 open: jest.fn(async () => cache),
2229 };
2230
2231 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
2232
2233 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
2234 expect(cache.keys).toHaveBeenCalledTimes(1);
2235 expect(deleteCalls).toEqual(expect.arrayContaining([
2236 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
2237 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
2238 ]));
2239 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
2240
2241 window.close();
2242 });
2243});