BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

275f660d History
shared-video-player.test.js 72.1 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('defers periodic resync while caption is visible and runs it after caption ends', async () =>
1006 {
1007 const window = createWindow();
1008 const helper = loadSharedVideoPlayer(window);
1009 const { player, videojs } = buildPlayerHarness(window);
1010 const requestedTimes = [];
1011
1012 window.requestAnimationFrame = undefined;
1013 window.cancelAnimationFrame = undefined;
1014
1015 player.setCurrentTime(1.2);
1016
1017 window.fetch = jest.fn(async (url) =>
1018 {
1019 const parsed = new URL(url, 'http://localhost/');
1020 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1021 requestedTimes.push(timeSeconds);
1022
1023 const headers = {
1024 'Content-Type': 'image/png',
1025 'X-Subtitle-Frame-Width': '640',
1026 'X-Subtitle-Frame-Height': '80',
1027 'X-Subtitle-Frame-Canvas-Width': '1920',
1028 'X-Subtitle-Frame-Canvas-Height': '1080',
1029 };
1030
1031 if (Math.abs(timeSeconds - 1.2) < 0.01)
1032 {
1033 headers['X-Subtitle-Frame-Start-Time'] = '1.0';
1034 headers['X-Subtitle-Frame-End-Time'] = '2.0';
1035 return new Response(new Uint8Array([137, 80, 78, 71]), {
1036 status: 200,
1037 headers,
1038 });
1039 }
1040
1041 return new Response(null, {
1042 status: 204,
1043 headers: { 'X-Subtitle-Frame-Status': 'none' },
1044 });
1045 });
1046
1047 helper.bindImageSubtitleOverlay(player, videojs, {}, {
1048 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1049 }, {
1050 lookaheadSeconds: 0,
1051 initialPrefetchSeconds: 0,
1052 periodicResyncIntervalMs: 120,
1053 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1054 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1055 }),
1056 });
1057
1058 await flushAsyncWork(window, 8);
1059 player.trigger('play');
1060 await new Promise((resolve) => window.setTimeout(resolve, 300));
1061 await flushAsyncWork(window, 2);
1062
1063 const fetchCallsDuringCaption = window.fetch.mock.calls.length;
1064
1065 player.setCurrentTime(20);
1066 await new Promise((resolve) => window.setTimeout(resolve, 160));
1067 await flushAsyncWork(window, 3);
1068
1069 expect(window.fetch.mock.calls.length).toBeGreaterThan(fetchCallsDuringCaption);
1070 expect(requestedTimes.some((time) => Math.abs(time - 20) < 0.01)).toBe(true);
1071
1072 window.close();
1073 });
1074
1075 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
1076 {
1077 const window = createWindow();
1078 const helper = loadSharedVideoPlayer(window);
1079 const { player, videojs } = buildPlayerHarness(window);
1080 const activeSignals = [];
1081
1082 window.fetch = jest.fn((url, init = {}) =>
1083 {
1084 const parsed = new URL(url, 'http://localhost/');
1085 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1086
1087 if (timeSeconds === 0)
1088 {
1089 return Promise.resolve(new Response(null, {
1090 status: 204,
1091 headers: { 'X-Subtitle-Frame-Status': 'none' },
1092 }));
1093 }
1094
1095 activeSignals.push(init.signal || null);
1096
1097 return new Promise((resolve, reject) =>
1098 {
1099 if (init.signal && typeof init.signal.addEventListener === 'function')
1100 {
1101 init.signal.addEventListener('abort', () =>
1102 {
1103 reject(new DOMException('Aborted', 'AbortError'));
1104 }, { once: true });
1105 }
1106 });
1107 });
1108
1109 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1110 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1111 }, {
1112 lookaheadSeconds: 1,
1113 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1114 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1115 }),
1116 });
1117
1118 await flushAsyncWork(window, 3);
1119 expect(activeSignals.length).toBeGreaterThan(0);
1120
1121 controller.detach();
1122 await flushAsyncWork(window, 2);
1123
1124 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
1125
1126 window.close();
1127 });
1128
1129 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
1130 {
1131 const window = createWindow();
1132 const helper = loadSharedVideoPlayer(window);
1133 const { player, videojs } = buildPlayerHarness(window);
1134 const sentBatches = [];
1135
1136 window.fetch = jest.fn(async () =>
1137 {
1138 return new Response('png-data', {
1139 status: 200,
1140 headers: {
1141 'Content-Type': 'image/png',
1142 'X-Subtitle-Frame-Status': 'ok',
1143 'X-Subtitle-Request-Received-At-Ms': '1000',
1144 'X-Subtitle-Response-Sent-At-Ms': '1012',
1145 'X-Subtitle-Frame-Start-Time': '1.5',
1146 'X-Subtitle-Frame-End-Time': '3.2',
1147 'X-Subtitle-Frame-Width': '320',
1148 'X-Subtitle-Frame-Height': '180',
1149 'X-Subtitle-Frame-Canvas-Width': '640',
1150 'X-Subtitle-Frame-Canvas-Height': '360',
1151 },
1152 });
1153 });
1154
1155 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1156 sessionId: 'sess-1',
1157 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1158 }, {
1159 lookaheadSeconds: 0,
1160 sendSubtitleLogBatch: (entries) =>
1161 {
1162 sentBatches.push(entries);
1163 return Promise.resolve();
1164 },
1165 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1166 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1167 }),
1168 });
1169
1170 await flushAsyncWork(window, 8);
1171 controller.detach();
1172 await flushAsyncWork(window, 4);
1173
1174 const flattened = sentBatches.flat();
1175 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
1176 'subtitle_png_requested',
1177 'subtitle_png_sent',
1178 'subtitle_png_received',
1179 ]));
1180
1181 window.close();
1182 });
1183
1184 test('logs prefetch subtitle lifecycle events', async () =>
1185 {
1186 const window = createWindow();
1187 const helper = loadSharedVideoPlayer(window);
1188 const { player, videojs } = buildPlayerHarness(window);
1189 const sentBatches = [];
1190
1191 window.fetch = jest.fn(async () =>
1192 {
1193 return new Response(null, {
1194 status: 204,
1195 headers: {
1196 'X-Subtitle-Frame-Status': 'none',
1197 'X-Subtitle-Request-Received-At-Ms': '1000',
1198 'X-Subtitle-Response-Sent-At-Ms': '1010',
1199 'X-Subtitle-Frame-Start-Time': '2',
1200 'X-Subtitle-Frame-End-Time': '3',
1201 },
1202 });
1203 });
1204
1205 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1206 sessionId: 'sess-1',
1207 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1208 }, {
1209 lookaheadSeconds: 1,
1210 sendSubtitleLogBatch: (entries) =>
1211 {
1212 sentBatches.push(entries);
1213 return Promise.resolve();
1214 },
1215 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1216 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1217 }),
1218 });
1219
1220 await flushAsyncWork(window, 8);
1221 controller.detach();
1222 await flushAsyncWork(window, 4);
1223
1224 const flattened = sentBatches.flat();
1225 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
1226 expect(prefetchEvents).toEqual(expect.arrayContaining([
1227 'subtitle_png_requested',
1228 'subtitle_png_sent',
1229 'subtitle_png_not_available',
1230 ]));
1231
1232 window.close();
1233 });
1234
1235 test('cache-only current mode avoids direct current subtitle fetch requests', async () =>
1236 {
1237 const window = createWindow();
1238 const helper = loadSharedVideoPlayer(window);
1239 const { player, videojs } = buildPlayerHarness(window);
1240 const sentBatches = [];
1241
1242 player.setCurrentTime(8);
1243 window.fetch = jest.fn(async () =>
1244 {
1245 return new Response(null, {
1246 status: 204,
1247 headers: {
1248 'X-Subtitle-Frame-Status': 'none',
1249 'X-Subtitle-Request-Received-At-Ms': '1000',
1250 'X-Subtitle-Response-Sent-At-Ms': '1010',
1251 },
1252 });
1253 });
1254
1255 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1256 sessionId: 'sess-1',
1257 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1258 }, {
1259 currentFetchEnabled: false,
1260 cacheMissFallbackEnabled: false,
1261 lookaheadSeconds: 0,
1262 sendSubtitleLogBatch: (entries) =>
1263 {
1264 sentBatches.push(entries);
1265 return Promise.resolve();
1266 },
1267 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1268 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1269 }),
1270 });
1271
1272 await flushAsyncWork(window, 8);
1273 controller.detach();
1274 await flushAsyncWork(window, 4);
1275
1276 const flattened = sentBatches.flat();
1277 expect(flattened.length).toBeGreaterThan(0);
1278 const requestKinds = new Set(flattened.map((entry) => entry.requestKind).filter(Boolean));
1279 expect(requestKinds.has('prefetch')).toBe(true);
1280 expect(requestKinds.has('current')).toBe(false);
1281
1282 window.close();
1283 });
1284
1285 test('cache-only mode falls back to throttled current fetch on cache miss', async () =>
1286 {
1287 const window = createWindow();
1288 const helper = loadSharedVideoPlayer(window);
1289 const { player, videojs } = buildPlayerHarness(window);
1290
1291 let requestCount = 0;
1292 window.fetch = jest.fn(async () =>
1293 {
1294 requestCount += 1;
1295 if (requestCount === 1)
1296 {
1297 return new Response(new Uint8Array([137, 80, 78, 71]), {
1298 status: 200,
1299 headers: {
1300 'Content-Type': 'image/png',
1301 'X-Subtitle-Frame-Start-Time': '2.00',
1302 'X-Subtitle-Frame-End-Time': '2.50',
1303 'X-Subtitle-Frame-Width': '600',
1304 'X-Subtitle-Frame-Height': '72',
1305 'X-Subtitle-Frame-Canvas-Width': '1920',
1306 'X-Subtitle-Frame-Canvas-Height': '1080',
1307 },
1308 });
1309 }
1310
1311 return new Response(null, {
1312 status: 204,
1313 headers: { 'X-Subtitle-Frame-Status': 'none' },
1314 });
1315 });
1316
1317 player.setCurrentTime(2.2);
1318
1319 helper.bindImageSubtitleOverlay(player, videojs, {}, {
1320 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1321 }, {
1322 currentFetchEnabled: false,
1323 cacheMissFallbackIntervalMs: 2000,
1324 lookaheadSeconds: 0,
1325 initialPrefetchSeconds: 0,
1326 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1327 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1328 }),
1329 });
1330
1331 await flushAsyncWork(window, 10);
1332
1333 const overlay = player.el().querySelector('.video-subtitle-overlay');
1334 const overlayImg = overlay && overlay.querySelector('img');
1335 expect(window.fetch).toHaveBeenCalled();
1336 expect(overlay.style.display).toBe('block');
1337 expect(overlayImg.getAttribute('src')).toBe('blob:subtitle');
1338
1339 window.close();
1340 });
1341
1342 test('cache-miss fallback does not reset prefetch progress on repeated triggers', async () =>
1343 {
1344 const window = createWindow();
1345 const helper = loadSharedVideoPlayer(window);
1346 const { player, videojs } = buildPlayerHarness(window);
1347
1348 let nowMs = 1000;
1349 const realNow = window.Date.now;
1350 window.Date.now = () => nowMs;
1351
1352 let abortedCount = 0;
1353 window.fetch = jest.fn((url, init = {}) =>
1354 {
1355 return new Promise((resolve, reject) =>
1356 {
1357 const signal = init && init.signal;
1358 const onAbort = () =>
1359 {
1360 abortedCount += 1;
1361 const err = new Error('aborted');
1362 err.name = 'AbortError';
1363 reject(err);
1364 };
1365
1366 if (signal && typeof signal.addEventListener === 'function')
1367 {
1368 if (signal.aborted) return onAbort();
1369 signal.addEventListener('abort', onAbort, { once: true });
1370 }
1371
1372 window.setTimeout(() =>
1373 {
1374 if (signal && signal.aborted) return;
1375 resolve(new Response(null, {
1376 status: 204,
1377 headers: { 'X-Subtitle-Frame-Status': 'none' },
1378 }));
1379 }, 80);
1380 });
1381 });
1382
1383 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1384 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1385 }, {
1386 currentFetchEnabled: false,
1387 cacheMissFallbackIntervalMs: 20,
1388 lookaheadSeconds: 2,
1389 initialPrefetchSeconds: 0,
1390 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1391 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1392 }),
1393 });
1394
1395 await flushAsyncWork(window, 4);
1396
1397 player.setCurrentTime(5);
1398 player.trigger('timeupdate');
1399 nowMs += 40;
1400 player.setCurrentTime(5.5);
1401 player.trigger('timeupdate');
1402 nowMs += 40;
1403 player.setCurrentTime(6);
1404 player.trigger('timeupdate');
1405
1406 await flushAsyncWork(window, 12);
1407 expect(abortedCount).toBe(0);
1408
1409 window.Date.now = realNow;
1410 controller.detach();
1411 window.close();
1412 });
1413
1414 test('cache-only mode performs initial warmup prefetch window on load', async () =>
1415 {
1416 const window = createWindow();
1417 const helper = loadSharedVideoPlayer(window);
1418 const { player, videojs } = buildPlayerHarness(window);
1419 const requestedTimes = [];
1420
1421 window.fetch = jest.fn(async (url) =>
1422 {
1423 const parsed = new URL(url, 'http://localhost/');
1424 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
1425 return new Response(null, {
1426 status: 204,
1427 headers: {
1428 'X-Subtitle-Frame-Status': 'none',
1429 'X-Subtitle-Request-Received-At-Ms': '1000',
1430 'X-Subtitle-Response-Sent-At-Ms': '1010',
1431 },
1432 });
1433 });
1434
1435 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1436 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1437 }, {
1438 currentFetchEnabled: false,
1439 lookaheadSeconds: 0,
1440 initialPrefetchSeconds: 2,
1441 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1442 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1443 }),
1444 });
1445
1446 await flushAsyncWork(window, 12);
1447
1448 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1, 1.5, 2]));
1449
1450 controller.detach();
1451 await flushAsyncWork(window, 2);
1452 window.close();
1453 });
1454
1455 test('renders requested and received subtitle markers on the seek bar', async () =>
1456 {
1457 const window = createWindow();
1458 const helper = loadSharedVideoPlayer(window);
1459 const { player, videojs } = buildPlayerHarness(window);
1460
1461 window.fetch = jest.fn(async () =>
1462 {
1463 return new Response('png-data', {
1464 status: 200,
1465 headers: {
1466 'Content-Type': 'image/png',
1467 'X-Subtitle-Frame-Status': 'ok',
1468 'X-Subtitle-Request-Received-At-Ms': '1000',
1469 'X-Subtitle-Response-Sent-At-Ms': '1012',
1470 'X-Subtitle-Frame-Start-Time': '2.5',
1471 'X-Subtitle-Frame-End-Time': '3.5',
1472 'X-Subtitle-Frame-Width': '320',
1473 'X-Subtitle-Frame-Height': '180',
1474 'X-Subtitle-Frame-Canvas-Width': '640',
1475 'X-Subtitle-Frame-Canvas-Height': '360',
1476 },
1477 });
1478 });
1479
1480 player.duration(10);
1481 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1482 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1483 }, {
1484 lookaheadSeconds: 0,
1485 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1486 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1487 }),
1488 });
1489
1490 await flushAsyncWork(window, 8);
1491
1492 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1493 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1494 expect(requestedMarker).toBeTruthy();
1495 expect(receivedMarker).toBeTruthy();
1496 expect(requestedMarker.style.display).toBe('block');
1497 expect(receivedMarker.style.display).toBe('block');
1498 expect(requestedMarker.style.left).toBe('100.0000%');
1499 expect(receivedMarker.style.left).toBe('25.0000%');
1500 expect(requestedMarker.textContent).toBe(']');
1501 expect(receivedMarker.textContent).toBe('[');
1502
1503 controller.detach();
1504 await new Promise((resolve) => window.setTimeout(resolve, 300));
1505 await flushAsyncWork(window, 2);
1506
1507 window.close();
1508 });
1509
1510 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
1511 {
1512 const window = createWindow();
1513 const helper = loadSharedVideoPlayer(window);
1514 const { player, videojs } = buildPlayerHarness(window);
1515
1516 player.duration(10);
1517 player.setCurrentTime(4);
1518 window.fetch = jest.fn(async () =>
1519 {
1520 return new Response(null, {
1521 status: 204,
1522 headers: {
1523 'X-Subtitle-Frame-Status': 'none',
1524 'X-Subtitle-Request-Received-At-Ms': '1000',
1525 'X-Subtitle-Response-Sent-At-Ms': '1010',
1526 },
1527 });
1528 });
1529
1530 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1531 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1532 }, {
1533 lookaheadSeconds: 0,
1534 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1535 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1536 }),
1537 });
1538
1539 await flushAsyncWork(window, 8);
1540
1541 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1542 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1543 expect(requestedMarker).toBeTruthy();
1544 expect(receivedMarker).toBeTruthy();
1545 expect(requestedMarker.style.display).toBe('block');
1546 expect(receivedMarker.style.display).toBe('block');
1547 expect(requestedMarker.style.left).toBe('100.0000%');
1548 expect(receivedMarker.style.left).toBe('100.0000%');
1549 expect(requestedMarker.textContent).toBe(']');
1550 expect(receivedMarker.textContent).toBe('[');
1551
1552 controller.detach();
1553 await flushAsyncWork(window, 2);
1554 window.close();
1555 });
1556
1557 test('advances seek markers to the end of an empty prefetch tail window', async () =>
1558 {
1559 const window = createWindow();
1560 const helper = loadSharedVideoPlayer(window);
1561 const { player, videojs } = buildPlayerHarness(window);
1562
1563 player.duration(120);
1564 player.setCurrentTime(110);
1565
1566 window.fetch = jest.fn(async () =>
1567 {
1568 return new Response(null, {
1569 status: 204,
1570 headers: {
1571 'X-Subtitle-Frame-Status': 'none',
1572 'X-Subtitle-Request-Received-At-Ms': '1000',
1573 'X-Subtitle-Response-Sent-At-Ms': '1010',
1574 },
1575 });
1576 });
1577
1578 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1579 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1580 }, {
1581 lookaheadSeconds: 0,
1582 initialPrefetchSeconds: 0,
1583 currentFetchEnabled: false,
1584 cacheMissFallbackEnabled: false,
1585 prefetchAdaptiveStepEnabled: true,
1586 prefetchStepSecondsMin: 10,
1587 prefetchStepSecondsMax: 10,
1588 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1589 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1590 }),
1591 buildPrefetchRequest: ({ currentTime, endTime, streamIndex }) => ({
1592 url: `/subtitle-range?streamIndex=${streamIndex}&startTimeSeconds=${currentTime}&endTimeSeconds=${endTime}`,
1593 }),
1594 });
1595
1596 player.trigger('timeupdate');
1597 await flushAsyncWork(window, 8);
1598
1599 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1600 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1601 expect(requestedMarker).toBeTruthy();
1602 expect(receivedMarker).toBeTruthy();
1603 expect(requestedMarker.style.left).toBe('100.0000%');
1604 expect(receivedMarker.style.left).toBe('100.0000%');
1605
1606 controller.detach();
1607 await flushAsyncWork(window, 2);
1608 window.close();
1609 });
1610
1611 test('keeps existing marker positions while the next request is still in flight', async () =>
1612 {
1613 const window = createWindow();
1614 const helper = loadSharedVideoPlayer(window);
1615 const { player, videojs } = buildPlayerHarness(window);
1616 let pendingResolve = null;
1617
1618 player.duration(10);
1619 window.fetch = jest.fn((url) =>
1620 {
1621 const parsed = new URL(url, 'http://localhost/');
1622 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1623
1624 if (timeSeconds === 0)
1625 {
1626 return Promise.resolve(new Response('png-data', {
1627 status: 200,
1628 headers: {
1629 'Content-Type': 'image/png',
1630 'X-Subtitle-Frame-Status': 'ok',
1631 'X-Subtitle-Frame-Start-Time': '2',
1632 'X-Subtitle-Frame-End-Time': '3',
1633 'X-Subtitle-Frame-Width': '320',
1634 'X-Subtitle-Frame-Height': '180',
1635 'X-Subtitle-Frame-Canvas-Width': '640',
1636 'X-Subtitle-Frame-Canvas-Height': '360',
1637 },
1638 }));
1639 }
1640
1641 return new Promise((resolve) =>
1642 {
1643 pendingResolve = resolve;
1644 });
1645 });
1646
1647 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1648 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1649 }, {
1650 lookaheadSeconds: 0,
1651 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1652 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1653 }),
1654 });
1655
1656 await flushAsyncWork(window, 8);
1657
1658 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1659 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1660 expect(requestedMarker).toBeTruthy();
1661 expect(receivedMarker).toBeTruthy();
1662 expect(requestedMarker.style.left).toBe('0.0000%');
1663 expect(receivedMarker.style.left).toBe('20.0000%');
1664
1665 player.setCurrentTime(1.5);
1666 player.trigger('timeupdate');
1667 await flushAsyncWork(window, 2);
1668
1669 expect(requestedMarker.style.left).toBe('0.0000%');
1670 expect(receivedMarker.style.left).toBe('20.0000%');
1671
1672 pendingResolve(new Response(null, {
1673 status: 204,
1674 headers: {
1675 'X-Subtitle-Frame-Status': 'none',
1676 },
1677 }));
1678
1679 await flushAsyncWork(window, 8);
1680 expect(requestedMarker.style.display).toBe('block');
1681 expect(receivedMarker.style.display).toBe('block');
1682 expect(requestedMarker.style.left).toBe('15.0000%');
1683 expect(receivedMarker.style.left).toBe('20.0000%');
1684
1685 controller.detach();
1686 await flushAsyncWork(window, 2);
1687 window.close();
1688 });
1689
1690 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
1691 {
1692 const window = createWindow();
1693 const helper = loadSharedVideoPlayer(window);
1694 const { player, videojs } = buildPlayerHarness(window);
1695 const requestedTimes = [];
1696
1697 player.duration(12);
1698 window.fetch = jest.fn(async (url) =>
1699 {
1700 const parsed = new URL(url, 'http://localhost/');
1701 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1702 requestedTimes.push(timeSeconds);
1703
1704 if (requestedTimes.length === 1)
1705 {
1706 return new Response('png-data', {
1707 status: 200,
1708 headers: {
1709 'Content-Type': 'image/png',
1710 'X-Subtitle-Frame-Status': 'ok',
1711 'X-Subtitle-Frame-Start-Time': '4',
1712 'X-Subtitle-Frame-End-Time': '5',
1713 'X-Subtitle-Frame-Width': '320',
1714 'X-Subtitle-Frame-Height': '180',
1715 'X-Subtitle-Frame-Canvas-Width': '640',
1716 'X-Subtitle-Frame-Canvas-Height': '360',
1717 },
1718 });
1719 }
1720
1721 return new Response('png-data', {
1722 status: 200,
1723 headers: {
1724 'Content-Type': 'image/png',
1725 'X-Subtitle-Frame-Status': 'ok',
1726 'X-Subtitle-Frame-Start-Time': '2',
1727 'X-Subtitle-Frame-End-Time': '3',
1728 'X-Subtitle-Frame-Width': '320',
1729 'X-Subtitle-Frame-Height': '180',
1730 'X-Subtitle-Frame-Canvas-Width': '640',
1731 'X-Subtitle-Frame-Canvas-Height': '360',
1732 },
1733 });
1734 });
1735
1736 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1737 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1738 }, {
1739 lookaheadSeconds: 0,
1740 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1741 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1742 }),
1743 });
1744
1745 await flushAsyncWork(window, 8);
1746
1747 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
1748 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
1749 expect(requestedMarker).toBeTruthy();
1750 expect(receivedMarker).toBeTruthy();
1751 expect(requestedMarker.style.left).toBe('100.0000%');
1752 expect(receivedMarker.style.left).toBe('33.3333%');
1753
1754 player.setCurrentTime(1.5);
1755 player.trigger('timeupdate');
1756 await flushAsyncWork(window, 8);
1757
1758 // Second response reports an older start time, but markers stay monotonic.
1759 expect(requestedMarker.style.left).toBe('100.0000%');
1760 expect(receivedMarker.style.left).toBe('33.3333%');
1761
1762 controller.detach();
1763 await flushAsyncWork(window, 2);
1764 window.close();
1765 });
1766
1767 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
1768 {
1769 const window = createWindow();
1770 const helper = loadSharedVideoPlayer(window);
1771 const { player, videojs } = buildPlayerHarness(window);
1772 const requestedTimes = [];
1773
1774 window.fetch = jest.fn((url, init = {}) =>
1775 {
1776 const parsed = new URL(url, 'http://localhost/');
1777 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1778 requestedTimes.push(timeSeconds);
1779
1780 if (requestedTimes.length === 1)
1781 {
1782 return new Promise((resolve, reject) =>
1783 {
1784 if (init.signal && typeof init.signal.addEventListener === 'function')
1785 {
1786 init.signal.addEventListener('abort', () =>
1787 {
1788 reject(new window.DOMException('Aborted', 'AbortError'));
1789 }, { once: true });
1790 }
1791 });
1792 }
1793
1794 return Promise.resolve(new Response(null, {
1795 status: 204,
1796 headers: {
1797 'X-Subtitle-Frame-Status': 'none',
1798 },
1799 }));
1800 });
1801
1802 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1803 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1804 }, {
1805 lookaheadSeconds: 0,
1806 currentRequestTimeoutMs: 300,
1807 logToConsole: false,
1808 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1809 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1810 }),
1811 });
1812
1813 await flushAsyncWork(window, 4);
1814 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1815 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1816
1817 player.setCurrentTime(5);
1818 player.trigger('seeking');
1819 await flushAsyncWork(window, 20);
1820
1821 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1822 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
1823
1824 controller.detach();
1825 await flushAsyncWork(window, 2);
1826 window.close();
1827 });
1828
1829 test('recovers when a current subtitle request hangs and times out', async () =>
1830 {
1831 const window = createWindow();
1832 const helper = loadSharedVideoPlayer(window);
1833 const { player, videojs } = buildPlayerHarness(window);
1834 const requestedTimes = [];
1835
1836 window.fetch = jest.fn((url, init = {}) =>
1837 {
1838 const parsed = new URL(url, 'http://localhost/');
1839 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1840 requestedTimes.push(timeSeconds);
1841
1842 if (requestedTimes.length === 1)
1843 {
1844 return new Promise((resolve, reject) =>
1845 {
1846 if (init.signal && typeof init.signal.addEventListener === 'function')
1847 {
1848 init.signal.addEventListener('abort', () =>
1849 {
1850 reject(new window.DOMException('Aborted', 'AbortError'));
1851 }, { once: true });
1852 }
1853 });
1854 }
1855
1856 return Promise.resolve(new Response(null, {
1857 status: 204,
1858 headers: { 'X-Subtitle-Frame-Status': 'none' },
1859 }));
1860 });
1861
1862 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1863 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1864 }, {
1865 lookaheadSeconds: 0,
1866 currentRequestTimeoutMs: 250,
1867 logToConsole: false,
1868 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1869 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1870 }),
1871 });
1872
1873 await flushAsyncWork(window, 3);
1874
1875 player.setCurrentTime(1.5);
1876 player.trigger('timeupdate');
1877
1878 await new Promise((resolve) => window.setTimeout(resolve, 320));
1879 player.trigger('timeupdate');
1880 await new Promise((resolve) => window.setTimeout(resolve, 220));
1881 await flushAsyncWork(window, 20);
1882
1883 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
1884 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
1885
1886 controller.detach();
1887 await new Promise((resolve) => window.setTimeout(resolve, 200));
1888 await flushAsyncWork(window, 20);
1889 window.close();
1890 });
1891
1892 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
1893 {
1894 const window = createWindow();
1895 const helper = loadSharedVideoPlayer(window);
1896 const { player, videojs } = buildPlayerHarness(window);
1897
1898 player.duration(10);
1899 player.setCurrentTime(2);
1900 window.fetch = jest.fn(async (url) =>
1901 {
1902 const parsed = new URL(url, 'http://localhost/');
1903 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
1904
1905 if (Math.abs(timeSeconds - 2) < 1e-6)
1906 {
1907 return new Response('png-data', {
1908 status: 200,
1909 headers: {
1910 'Content-Type': 'image/png',
1911 'X-Subtitle-Frame-Status': 'ok',
1912 'X-Subtitle-Frame-Start-Time': '2',
1913 'X-Subtitle-Frame-End-Time': '3',
1914 'X-Subtitle-Frame-Width': '320',
1915 'X-Subtitle-Frame-Height': '180',
1916 'X-Subtitle-Frame-Canvas-Width': '640',
1917 'X-Subtitle-Frame-Canvas-Height': '360',
1918 },
1919 });
1920 }
1921
1922 return new Response(null, {
1923 status: 204,
1924 headers: {
1925 'X-Subtitle-Frame-Status': 'none',
1926 },
1927 });
1928 });
1929
1930 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
1931 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
1932 }, {
1933 lookaheadSeconds: 0,
1934 buildFrameRequest: ({ currentTime, streamIndex }) => ({
1935 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
1936 }),
1937 });
1938
1939 await flushAsyncWork(window, 8);
1940 const afterInitialLoadCalls = window.fetch.mock.calls.length;
1941 expect(afterInitialLoadCalls).toBeGreaterThan(0);
1942
1943 player.setCurrentTime(4);
1944 player.trigger('timeupdate');
1945 await flushAsyncWork(window, 8);
1946 const afterForwardSeekCalls = window.fetch.mock.calls.length;
1947 expect(afterForwardSeekCalls).toBeGreaterThanOrEqual(afterInitialLoadCalls);
1948
1949 const overlay = player.el().querySelector('.video-subtitle-overlay');
1950 expect(overlay).toBeTruthy();
1951 expect(overlay.style.display).toBe('none');
1952
1953 player.setCurrentTime(2.5);
1954 player.trigger('timeupdate');
1955 await flushAsyncWork(window, 8);
1956
1957 expect(window.fetch.mock.calls.length).toBe(afterForwardSeekCalls);
1958 expect(overlay.style.display).toBe('block');
1959
1960 controller.detach();
1961 await flushAsyncWork(window, 2);
1962 window.close();
1963 });
1964
1965 test('registers stream cache service worker once when supported', async () =>
1966 {
1967 const window = createWindow();
1968 const helper = loadSharedVideoPlayer(window);
1969 const register = jest.fn(async () => ({}));
1970 window.navigator.serviceWorker = { register };
1971
1972 const first = await helper.enableVideoStreamClientCache();
1973 const second = await helper.enableVideoStreamClientCache();
1974
1975 expect(first).toBe(true);
1976 expect(second).toBe(true);
1977 expect(register).toHaveBeenCalledTimes(1);
1978 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
1979 scope: '/',
1980 updateViaCache: 'none',
1981 });
1982
1983 window.close();
1984 });
1985
1986 test('stream-ahead prefetch follows playlists and fetches segment assets', async () =>
1987 {
1988 const window = createWindow();
1989 const helper = loadSharedVideoPlayer(window);
1990 const requestedUrls = [];
1991
1992 window.fetch = jest.fn(async (input) =>
1993 {
1994 const url = String(input && input.url ? input.url : input);
1995 requestedUrls.push(url);
1996
1997 if (url === 'http://localhost/master.m3u8')
1998 {
1999 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2000 status: 200,
2001 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2002 });
2003 }
2004
2005 if (url === 'http://localhost/stream_0.m3u8')
2006 {
2007 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
2008 status: 200,
2009 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2010 });
2011 }
2012
2013 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
2014 {
2015 return new Response(new Uint8Array([1, 2, 3, 4]), {
2016 status: 200,
2017 headers: { 'Content-Type': 'video/mp2t' },
2018 });
2019 }
2020
2021 return new Response(null, { status: 404 });
2022 });
2023
2024 const controller = helper.bindStreamAheadPrefetch({
2025 playlistUrl: 'http://localhost/master.m3u8',
2026 pollIntervalMs: 0,
2027 credentials: 'same-origin',
2028 });
2029
2030 expect(controller).toBeTruthy();
2031 await controller.done();
2032
2033 expect(requestedUrls).toEqual(expect.arrayContaining([
2034 'http://localhost/master.m3u8',
2035 'http://localhost/stream_0.m3u8',
2036 'http://localhost/seg0.ts',
2037 'http://localhost/seg1.ts',
2038 ]));
2039
2040 controller.stop();
2041 window.close();
2042 });
2043
2044 test('stream-ahead prefetch reports cached-through progress for fetched segments', async () =>
2045 {
2046 const window = createWindow();
2047 const helper = loadSharedVideoPlayer(window);
2048 const progressSamples = [];
2049
2050 window.fetch = jest.fn(async (input) =>
2051 {
2052 const url = String(input && input.url ? input.url : input);
2053
2054 if (url === 'http://localhost/master.m3u8')
2055 {
2056 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2057 status: 200,
2058 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2059 });
2060 }
2061
2062 if (url === 'http://localhost/stream_0.m3u8')
2063 {
2064 return new Response('#EXTM3U\n#EXTINF:4,\nseg0.ts\n#EXTINF:4,\nseg1.ts\n#EXT-X-ENDLIST\n', {
2065 status: 200,
2066 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2067 });
2068 }
2069
2070 if (url === 'http://localhost/seg0.ts' || url === 'http://localhost/seg1.ts')
2071 {
2072 return new Response(new Uint8Array([1, 2, 3, 4]), {
2073 status: 200,
2074 headers: { 'Content-Type': 'video/mp2t' },
2075 });
2076 }
2077
2078 return new Response(null, { status: 404 });
2079 });
2080
2081 const controller = helper.bindStreamAheadPrefetch({
2082 playlistUrl: 'http://localhost/master.m3u8',
2083 pollIntervalMs: 0,
2084 credentials: 'same-origin',
2085 });
2086
2087 expect(controller).toBeTruthy();
2088 const unsubscribe = controller.subscribe((status) =>
2089 {
2090 progressSamples.push(status && status.cachedThroughSeconds);
2091 });
2092
2093 await controller.done();
2094 unsubscribe();
2095
2096 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2097
2098 controller.stop();
2099 window.close();
2100 });
2101
2102 test('stream-ahead prefetch infers cached-through progress from segment filenames', async () =>
2103 {
2104 const window = createWindow();
2105 const helper = loadSharedVideoPlayer(window);
2106 const progressSamples = [];
2107
2108 window.fetch = jest.fn(async (input) =>
2109 {
2110 const url = String(input && input.url ? input.url : input);
2111
2112 if (url === 'http://localhost/master.m3u8')
2113 {
2114 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2115 status: 200,
2116 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2117 });
2118 }
2119
2120 if (url === 'http://localhost/stream_0.m3u8')
2121 {
2122 return new Response('#EXTM3U\nstream_0_segment_000000.ts\nstream_0_segment_000001.ts\n#EXT-X-ENDLIST\n', {
2123 status: 200,
2124 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2125 });
2126 }
2127
2128 if (url === 'http://localhost/stream_0_segment_000000.ts' || url === 'http://localhost/stream_0_segment_000001.ts')
2129 {
2130 return new Response(new Uint8Array([1, 2, 3, 4]), {
2131 status: 200,
2132 headers: { 'Content-Type': 'video/mp2t' },
2133 });
2134 }
2135
2136 return new Response(null, { status: 404 });
2137 });
2138
2139 const controller = helper.bindStreamAheadPrefetch({
2140 playlistUrl: 'http://localhost/master.m3u8',
2141 pollIntervalMs: 0,
2142 credentials: 'same-origin',
2143 });
2144
2145 expect(controller).toBeTruthy();
2146 const unsubscribe = controller.subscribe((status) =>
2147 {
2148 progressSamples.push(status && status.cachedThroughSeconds);
2149 });
2150
2151 await controller.done();
2152 unsubscribe();
2153
2154 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2155
2156 controller.stop();
2157 window.close();
2158 });
2159
2160 test('stream-ahead prefetch infers cached-through progress for m4s segment filenames', async () =>
2161 {
2162 const window = createWindow();
2163 const helper = loadSharedVideoPlayer(window);
2164 const progressSamples = [];
2165
2166 window.fetch = jest.fn(async (input) =>
2167 {
2168 const url = String(input && input.url ? input.url : input);
2169
2170 if (url === 'http://localhost/master.m3u8')
2171 {
2172 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2173 status: 200,
2174 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2175 });
2176 }
2177
2178 if (url === 'http://localhost/stream_0.m3u8')
2179 {
2180 return new Response('#EXTM3U\nstream_0_segment_000000.m4s\nstream_0_segment_000001.m4s\n#EXT-X-ENDLIST\n', {
2181 status: 200,
2182 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2183 });
2184 }
2185
2186 if (url === 'http://localhost/stream_0_segment_000000.m4s' || url === 'http://localhost/stream_0_segment_000001.m4s')
2187 {
2188 return new Response(new Uint8Array([1, 2, 3, 4]), {
2189 status: 200,
2190 headers: { 'Content-Type': 'video/mp4' },
2191 });
2192 }
2193
2194 return new Response(null, { status: 404 });
2195 });
2196
2197 const controller = helper.bindStreamAheadPrefetch({
2198 playlistUrl: 'http://localhost/master.m3u8',
2199 pollIntervalMs: 0,
2200 credentials: 'same-origin',
2201 });
2202
2203 expect(controller).toBeTruthy();
2204 const unsubscribe = controller.subscribe((status) =>
2205 {
2206 progressSamples.push(status && status.cachedThroughSeconds);
2207 });
2208
2209 await controller.done();
2210 unsubscribe();
2211
2212 expect(progressSamples.some((value) => Number.isFinite(value) && value >= 8)).toBe(true);
2213
2214 controller.stop();
2215 window.close();
2216 });
2217
2218 test('stream-ahead prefetch reports ratio progress from fetched sections when timing is unknown', async () =>
2219 {
2220 const window = createWindow();
2221 const helper = loadSharedVideoPlayer(window);
2222 const statusSamples = [];
2223
2224 window.fetch = jest.fn(async (input) =>
2225 {
2226 const url = String(input && input.url ? input.url : input);
2227
2228 if (url === 'http://localhost/master.m3u8')
2229 {
2230 return new Response('#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=100000\nstream_0.m3u8\n#EXT-X-ENDLIST\n', {
2231 status: 200,
2232 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2233 });
2234 }
2235
2236 if (url === 'http://localhost/stream_0.m3u8')
2237 {
2238 return new Response('#EXTM3U\nchunk-alpha.bin\nchunk-beta.bin\n#EXT-X-ENDLIST\n', {
2239 status: 200,
2240 headers: { 'Content-Type': 'application/vnd.apple.mpegurl' },
2241 });
2242 }
2243
2244 if (url === 'http://localhost/chunk-alpha.bin' || url === 'http://localhost/chunk-beta.bin')
2245 {
2246 return new Response(new Uint8Array([1, 2, 3, 4]), {
2247 status: 200,
2248 headers: { 'Content-Type': 'application/octet-stream' },
2249 });
2250 }
2251
2252 return new Response(null, { status: 404 });
2253 });
2254
2255 const controller = helper.bindStreamAheadPrefetch({
2256 playlistUrl: 'http://localhost/master.m3u8',
2257 pollIntervalMs: 0,
2258 credentials: 'same-origin',
2259 });
2260
2261 expect(controller).toBeTruthy();
2262 const unsubscribe = controller.subscribe((status) =>
2263 {
2264 statusSamples.push(status || {});
2265 });
2266
2267 await controller.done();
2268 unsubscribe();
2269
2270 const finalStatus = statusSamples[statusSamples.length - 1] || {};
2271 expect(finalStatus.totalSegmentCount).toBe(2);
2272 expect(finalStatus.fetchedSegmentCount).toBe(2);
2273 expect(finalStatus.cachedThroughRatio).toBe(1);
2274
2275 controller.stop();
2276 window.close();
2277 });
2278
2279 test('clears cached stream assets for a finished playlist session', async () =>
2280 {
2281 const window = createWindow();
2282 const helper = loadSharedVideoPlayer(window);
2283 const requests = [
2284 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
2285 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
2286 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
2287 ];
2288 const deleteCalls = [];
2289 const cache = {
2290 keys: jest.fn(async () => requests),
2291 delete: jest.fn(async (request) =>
2292 {
2293 deleteCalls.push(request.url);
2294 return true;
2295 }),
2296 };
2297 window.caches = {
2298 open: jest.fn(async () => cache),
2299 };
2300
2301 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
2302
2303 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
2304 expect(cache.keys).toHaveBeenCalledTimes(1);
2305 expect(deleteCalls).toEqual(expect.arrayContaining([
2306 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
2307 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
2308 ]));
2309 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
2310
2311 window.close();
2312 });
2313});