BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

Fix subtitle seek-back deadlock
timfa Tim Falken · pushed by timfa · 5 months ago
afd05e40 History
shared-video-player.test.js 29.3 KiB Download Raw
1'use strict';
2
3const fs = require('fs');
4const path = require('path');
5const { JSDOM } = require('jsdom');
6
7function flushAsyncWork (window, rounds = 6)
8{
9 let chain = Promise.resolve();
10 for (let i = 0; i < rounds; i++)
11 {
12 chain = chain.then(() => new Promise((resolve) => window.setTimeout(resolve, 0)));
13 }
14 return chain;
15}
16
17function buildPlayerHarness (window)
18{
19 const registeredComponents = new Map();
20
21 class MockButton
22 {
23 constructor(player)
24 {
25 this._player = player;
26 this._el = null;
27 }
28
29 player ()
30 {
31 return this._player;
32 }
33
34 buildCSSClass ()
35 {
36 return 'vjs-control';
37 }
38
39 createEl ()
40 {
41 const el = window.document.createElement('button');
42 el.className = this.buildCSSClass();
43 return el;
44 }
45
46 el ()
47 {
48 if (!this._el) this._el = this.createEl();
49 return this._el;
50 }
51 }
52
53 registeredComponents.set('Button', MockButton);
54
55 const videojs = {
56 getComponent: (name) => registeredComponents.get(name),
57 registerComponent: (name, component) =>
58 {
59 registeredComponents.set(name, component);
60 },
61 };
62
63 const events = new Map();
64 const playerEl = window.document.createElement('div');
65 const progressControlEl = window.document.createElement('div');
66 progressControlEl.className = 'vjs-progress-control';
67 playerEl.appendChild(progressControlEl);
68 let currentTime = 0;
69 let durationSeconds = 10;
70 let bufferedEndSeconds = null;
71
72 const player = {
73 ready (cb)
74 {
75 if (typeof cb === 'function') cb();
76 },
77 on (type, fn)
78 {
79 if (!events.has(type)) events.set(type, new Set());
80 events.get(type).add(fn);
81 },
82 trigger (type)
83 {
84 const listeners = events.get(type);
85 if (!listeners) return;
86 for (const fn of Array.from(listeners)) fn();
87 },
88 currentTime ()
89 {
90 return currentTime;
91 },
92 setCurrentTime (next)
93 {
94 currentTime = Number(next);
95 },
96 duration (nextValue)
97 {
98 if (typeof nextValue === 'number')
99 {
100 durationSeconds = nextValue;
101 }
102 return durationSeconds;
103 },
104 bufferedEnd ()
105 {
106 return bufferedEndSeconds;
107 },
108 setBufferedEnd (next)
109 {
110 bufferedEndSeconds = Number.isFinite(next) ? Number(next) : null;
111 },
112 el ()
113 {
114 return playerEl;
115 },
116 getChild (name)
117 {
118 if (name !== 'controlBar') return null;
119 return {
120 addChild (componentName)
121 {
122 const Component = registeredComponents.get(componentName);
123 if (!Component) return null;
124 const instance = new Component(player);
125 playerEl.appendChild(instance.el());
126 return instance;
127 },
128 };
129 },
130 };
131
132 return { player, videojs };
133}
134
135function loadSharedVideoPlayer (window)
136{
137 const script = fs.readFileSync(path.join(__dirname, '../public/shared-video-player.js'), 'utf8');
138 window.eval(script);
139 return window.FilemanagerSharedVideoPlayer;
140}
141
142describe('shared image subtitle prefetching', () =>
143{
144 function createWindow ()
145 {
146 const dom = new JSDOM('<!doctype html><html><body></body></html>', {
147 url: 'http://localhost/',
148 runScripts: 'dangerously',
149 pretendToBeVisual: true,
150 });
151
152 dom.window.AbortController = AbortController;
153 dom.window.Response = Response;
154 dom.window.Headers = Headers;
155 dom.window.Request = Request;
156 dom.window.URL.createObjectURL = () => 'blob:subtitle';
157 dom.window.URL.revokeObjectURL = () => { };
158
159 return dom.window;
160 }
161
162 test('prefetches lookahead frames even when no subtitle is currently active', async () =>
163 {
164 const window = createWindow();
165 const helper = loadSharedVideoPlayer(window);
166 const { player, videojs } = buildPlayerHarness(window);
167 const requestedTimes = [];
168
169 window.fetch = jest.fn(async (url) =>
170 {
171 const parsed = new URL(url, 'http://localhost/');
172 requestedTimes.push(Number(parsed.searchParams.get('timeSeconds')));
173 return new Response(null, {
174 status: 204,
175 headers: { 'X-Subtitle-Frame-Status': 'none' },
176 });
177 });
178
179 helper.bindImageSubtitleOverlay(player, videojs, {}, {
180 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
181 }, {
182 lookaheadSeconds: 1,
183 buildFrameRequest: ({ currentTime, streamIndex }) => ({
184 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
185 }),
186 });
187
188 await flushAsyncWork(window);
189
190 expect(requestedTimes).toEqual(expect.arrayContaining([0, 0.5, 1]));
191
192 window.close();
193 });
194
195 test('prefetches at least through the buffered video end', async () =>
196 {
197 const window = createWindow();
198 const helper = loadSharedVideoPlayer(window);
199 const { player, videojs } = buildPlayerHarness(window);
200 const requestedTimes = [];
201
202 player.setBufferedEnd(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, 12);
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('does not restart current subtitle request while one is in flight', async () =>
231 {
232 const window = createWindow();
233 const helper = loadSharedVideoPlayer(window);
234 const { player, videojs } = buildPlayerHarness(window);
235 const pendingResolvers = [];
236 const requestTimes = [];
237
238 window.fetch = jest.fn((url, init = {}) =>
239 {
240 const parsed = new URL(url, 'http://localhost/');
241 requestTimes.push(Number(parsed.searchParams.get('timeSeconds')));
242
243 if (pendingResolvers.length === 0)
244 {
245 return new Promise((resolve) =>
246 {
247 pendingResolvers.push(() => resolve(new Response(null, {
248 status: 204,
249 headers: { 'X-Subtitle-Frame-Status': 'none' },
250 })));
251 });
252 }
253
254 expect(init.signal && init.signal.aborted).toBe(false);
255 return Promise.resolve(new Response(null, {
256 status: 204,
257 headers: { 'X-Subtitle-Frame-Status': 'none' },
258 }));
259 });
260
261 helper.bindImageSubtitleOverlay(player, videojs, {}, {
262 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
263 }, {
264 lookaheadSeconds: 0,
265 buildFrameRequest: ({ currentTime, streamIndex }) => ({
266 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
267 }),
268 });
269
270 await flushAsyncWork(window, 3);
271 expect(window.fetch).toHaveBeenCalledTimes(1);
272
273 player.setCurrentTime(1.5);
274 player.trigger('timeupdate');
275 player.setCurrentTime(2.25);
276 player.trigger('timeupdate');
277 await flushAsyncWork(window, 2);
278
279 expect(window.fetch).toHaveBeenCalledTimes(1);
280
281 pendingResolvers[0]();
282 await flushAsyncWork(window, 5);
283
284 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
285 expect(requestTimes).toEqual(expect.arrayContaining([0, 2.25]));
286
287 window.close();
288 });
289
290 test('aborts in-flight prefetch requests when the overlay is detached', async () =>
291 {
292 const window = createWindow();
293 const helper = loadSharedVideoPlayer(window);
294 const { player, videojs } = buildPlayerHarness(window);
295 const activeSignals = [];
296
297 window.fetch = jest.fn((url, init = {}) =>
298 {
299 const parsed = new URL(url, 'http://localhost/');
300 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
301
302 if (timeSeconds === 0)
303 {
304 return Promise.resolve(new Response(null, {
305 status: 204,
306 headers: { 'X-Subtitle-Frame-Status': 'none' },
307 }));
308 }
309
310 activeSignals.push(init.signal || null);
311
312 return new Promise((resolve, reject) =>
313 {
314 if (init.signal && typeof init.signal.addEventListener === 'function')
315 {
316 init.signal.addEventListener('abort', () =>
317 {
318 reject(new DOMException('Aborted', 'AbortError'));
319 }, { once: true });
320 }
321 });
322 });
323
324 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
325 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
326 }, {
327 lookaheadSeconds: 1,
328 buildFrameRequest: ({ currentTime, streamIndex }) => ({
329 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
330 }),
331 });
332
333 await flushAsyncWork(window, 3);
334 expect(activeSignals.length).toBeGreaterThan(0);
335
336 controller.detach();
337 await flushAsyncWork(window, 2);
338
339 expect(activeSignals.every(signal => signal && signal.aborted)).toBe(true);
340
341 window.close();
342 });
343
344 test('logs current subtitle request lifecycle events and flushes them on detach', async () =>
345 {
346 const window = createWindow();
347 const helper = loadSharedVideoPlayer(window);
348 const { player, videojs } = buildPlayerHarness(window);
349 const sentBatches = [];
350
351 window.fetch = jest.fn(async () =>
352 {
353 return new Response('png-data', {
354 status: 200,
355 headers: {
356 'Content-Type': 'image/png',
357 'X-Subtitle-Frame-Status': 'ok',
358 'X-Subtitle-Request-Received-At-Ms': '1000',
359 'X-Subtitle-Response-Sent-At-Ms': '1012',
360 'X-Subtitle-Frame-Start-Time': '1.5',
361 'X-Subtitle-Frame-End-Time': '3.2',
362 'X-Subtitle-Frame-Width': '320',
363 'X-Subtitle-Frame-Height': '180',
364 'X-Subtitle-Frame-Canvas-Width': '640',
365 'X-Subtitle-Frame-Canvas-Height': '360',
366 },
367 });
368 });
369
370 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
371 sessionId: 'sess-1',
372 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
373 }, {
374 lookaheadSeconds: 0,
375 sendSubtitleLogBatch: (entries) =>
376 {
377 sentBatches.push(entries);
378 return Promise.resolve();
379 },
380 buildFrameRequest: ({ currentTime, streamIndex }) => ({
381 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
382 }),
383 });
384
385 await flushAsyncWork(window, 8);
386 controller.detach();
387 await flushAsyncWork(window, 4);
388
389 const flattened = sentBatches.flat();
390 expect(flattened.map((entry) => entry.eventType)).toEqual(expect.arrayContaining([
391 'subtitle_png_requested',
392 'subtitle_png_sent',
393 'subtitle_png_received',
394 ]));
395
396 window.close();
397 });
398
399 test('logs prefetch subtitle lifecycle events', async () =>
400 {
401 const window = createWindow();
402 const helper = loadSharedVideoPlayer(window);
403 const { player, videojs } = buildPlayerHarness(window);
404 const sentBatches = [];
405
406 window.fetch = jest.fn(async () =>
407 {
408 return new Response(null, {
409 status: 204,
410 headers: {
411 'X-Subtitle-Frame-Status': 'none',
412 'X-Subtitle-Request-Received-At-Ms': '1000',
413 'X-Subtitle-Response-Sent-At-Ms': '1010',
414 'X-Subtitle-Frame-Start-Time': '2',
415 'X-Subtitle-Frame-End-Time': '3',
416 },
417 });
418 });
419
420 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
421 sessionId: 'sess-1',
422 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
423 }, {
424 lookaheadSeconds: 1,
425 sendSubtitleLogBatch: (entries) =>
426 {
427 sentBatches.push(entries);
428 return Promise.resolve();
429 },
430 buildFrameRequest: ({ currentTime, streamIndex }) => ({
431 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
432 }),
433 });
434
435 await flushAsyncWork(window, 8);
436 controller.detach();
437 await flushAsyncWork(window, 4);
438
439 const flattened = sentBatches.flat();
440 const prefetchEvents = flattened.filter((entry) => entry.requestKind === 'prefetch').map((entry) => entry.eventType);
441 expect(prefetchEvents).toEqual(expect.arrayContaining([
442 'subtitle_png_requested',
443 'subtitle_png_sent',
444 'subtitle_png_not_available',
445 ]));
446
447 window.close();
448 });
449
450 test('renders requested and received subtitle markers on the seek bar', async () =>
451 {
452 const window = createWindow();
453 const helper = loadSharedVideoPlayer(window);
454 const { player, videojs } = buildPlayerHarness(window);
455
456 window.fetch = jest.fn(async () =>
457 {
458 return new Response('png-data', {
459 status: 200,
460 headers: {
461 'Content-Type': 'image/png',
462 'X-Subtitle-Frame-Status': 'ok',
463 'X-Subtitle-Request-Received-At-Ms': '1000',
464 'X-Subtitle-Response-Sent-At-Ms': '1012',
465 'X-Subtitle-Frame-Start-Time': '2.5',
466 'X-Subtitle-Frame-End-Time': '3.5',
467 'X-Subtitle-Frame-Width': '320',
468 'X-Subtitle-Frame-Height': '180',
469 'X-Subtitle-Frame-Canvas-Width': '640',
470 'X-Subtitle-Frame-Canvas-Height': '360',
471 },
472 });
473 });
474
475 player.duration(10);
476 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
477 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
478 }, {
479 lookaheadSeconds: 0,
480 buildFrameRequest: ({ currentTime, streamIndex }) => ({
481 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
482 }),
483 });
484
485 await flushAsyncWork(window, 8);
486
487 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
488 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
489 expect(requestedMarker).toBeTruthy();
490 expect(receivedMarker).toBeTruthy();
491 expect(requestedMarker.style.display).toBe('block');
492 expect(receivedMarker.style.display).toBe('block');
493 expect(requestedMarker.style.left).toBe('0.0000%');
494 expect(receivedMarker.style.left).toBe('25.0000%');
495 expect(requestedMarker.textContent).toBe(']');
496 expect(receivedMarker.textContent).toBe('[');
497
498 controller.detach();
499 await new Promise((resolve) => window.setTimeout(resolve, 300));
500 await flushAsyncWork(window, 2);
501
502 window.close();
503 });
504
505 test('advances both seek markers when subtitle request returns 204 without frame timing headers', async () =>
506 {
507 const window = createWindow();
508 const helper = loadSharedVideoPlayer(window);
509 const { player, videojs } = buildPlayerHarness(window);
510
511 player.duration(10);
512 player.setCurrentTime(4);
513 window.fetch = jest.fn(async () =>
514 {
515 return new Response(null, {
516 status: 204,
517 headers: {
518 'X-Subtitle-Frame-Status': 'none',
519 'X-Subtitle-Request-Received-At-Ms': '1000',
520 'X-Subtitle-Response-Sent-At-Ms': '1010',
521 },
522 });
523 });
524
525 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
526 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
527 }, {
528 lookaheadSeconds: 0,
529 buildFrameRequest: ({ currentTime, streamIndex }) => ({
530 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
531 }),
532 });
533
534 await flushAsyncWork(window, 8);
535
536 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
537 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
538 expect(requestedMarker).toBeTruthy();
539 expect(receivedMarker).toBeTruthy();
540 expect(requestedMarker.style.display).toBe('block');
541 expect(receivedMarker.style.display).toBe('block');
542 expect(requestedMarker.style.left).toBe('40.0000%');
543 expect(receivedMarker.style.left).toBe('40.0000%');
544 expect(requestedMarker.textContent).toBe(']');
545 expect(receivedMarker.textContent).toBe('[');
546
547 controller.detach();
548 await flushAsyncWork(window, 2);
549 window.close();
550 });
551
552 test('keeps existing marker positions while the next request is still in flight', async () =>
553 {
554 const window = createWindow();
555 const helper = loadSharedVideoPlayer(window);
556 const { player, videojs } = buildPlayerHarness(window);
557 let pendingResolve = null;
558
559 player.duration(10);
560 window.fetch = jest.fn((url) =>
561 {
562 const parsed = new URL(url, 'http://localhost/');
563 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
564
565 if (timeSeconds === 0)
566 {
567 return Promise.resolve(new Response('png-data', {
568 status: 200,
569 headers: {
570 'Content-Type': 'image/png',
571 'X-Subtitle-Frame-Status': 'ok',
572 'X-Subtitle-Frame-Start-Time': '2',
573 'X-Subtitle-Frame-End-Time': '3',
574 'X-Subtitle-Frame-Width': '320',
575 'X-Subtitle-Frame-Height': '180',
576 'X-Subtitle-Frame-Canvas-Width': '640',
577 'X-Subtitle-Frame-Canvas-Height': '360',
578 },
579 }));
580 }
581
582 return new Promise((resolve) =>
583 {
584 pendingResolve = resolve;
585 });
586 });
587
588 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
589 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
590 }, {
591 lookaheadSeconds: 0,
592 buildFrameRequest: ({ currentTime, streamIndex }) => ({
593 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
594 }),
595 });
596
597 await flushAsyncWork(window, 8);
598
599 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
600 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
601 expect(requestedMarker).toBeTruthy();
602 expect(receivedMarker).toBeTruthy();
603 expect(requestedMarker.style.left).toBe('0.0000%');
604 expect(receivedMarker.style.left).toBe('20.0000%');
605
606 player.setCurrentTime(1.5);
607 player.trigger('timeupdate');
608 await flushAsyncWork(window, 2);
609
610 expect(requestedMarker.style.left).toBe('0.0000%');
611 expect(receivedMarker.style.left).toBe('20.0000%');
612
613 pendingResolve(new Response(null, {
614 status: 204,
615 headers: {
616 'X-Subtitle-Frame-Status': 'none',
617 },
618 }));
619
620 await flushAsyncWork(window, 8);
621 expect(requestedMarker.style.display).toBe('block');
622 expect(receivedMarker.style.display).toBe('block');
623 expect(requestedMarker.style.left).toBe('15.0000%');
624 expect(receivedMarker.style.left).toBe('20.0000%');
625
626 controller.detach();
627 await flushAsyncWork(window, 2);
628 window.close();
629 });
630
631 test('keeps marker positions forward-only when later responses resolve with earlier times', async () =>
632 {
633 const window = createWindow();
634 const helper = loadSharedVideoPlayer(window);
635 const { player, videojs } = buildPlayerHarness(window);
636 const requestedTimes = [];
637
638 player.duration(12);
639 window.fetch = jest.fn(async (url) =>
640 {
641 const parsed = new URL(url, 'http://localhost/');
642 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
643 requestedTimes.push(timeSeconds);
644
645 if (requestedTimes.length === 1)
646 {
647 return new Response('png-data', {
648 status: 200,
649 headers: {
650 'Content-Type': 'image/png',
651 'X-Subtitle-Frame-Status': 'ok',
652 'X-Subtitle-Frame-Start-Time': '4',
653 'X-Subtitle-Frame-End-Time': '5',
654 'X-Subtitle-Frame-Width': '320',
655 'X-Subtitle-Frame-Height': '180',
656 'X-Subtitle-Frame-Canvas-Width': '640',
657 'X-Subtitle-Frame-Canvas-Height': '360',
658 },
659 });
660 }
661
662 return new Response('png-data', {
663 status: 200,
664 headers: {
665 'Content-Type': 'image/png',
666 'X-Subtitle-Frame-Status': 'ok',
667 'X-Subtitle-Frame-Start-Time': '2',
668 'X-Subtitle-Frame-End-Time': '3',
669 'X-Subtitle-Frame-Width': '320',
670 'X-Subtitle-Frame-Height': '180',
671 'X-Subtitle-Frame-Canvas-Width': '640',
672 'X-Subtitle-Frame-Canvas-Height': '360',
673 },
674 });
675 });
676
677 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
678 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
679 }, {
680 lookaheadSeconds: 0,
681 buildFrameRequest: ({ currentTime, streamIndex }) => ({
682 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
683 }),
684 });
685
686 await flushAsyncWork(window, 8);
687
688 const requestedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-right');
689 const receivedMarker = player.el().querySelector('.vjs-image-subtitle-seek-marker-left');
690 expect(requestedMarker).toBeTruthy();
691 expect(receivedMarker).toBeTruthy();
692 expect(requestedMarker.style.left).toBe('0.0000%');
693 expect(receivedMarker.style.left).toBe('33.3333%');
694
695 player.setCurrentTime(1.5);
696 player.trigger('timeupdate');
697 await flushAsyncWork(window, 8);
698
699 // Second response reports an older start time, but markers stay monotonic.
700 expect(requestedMarker.style.left).toBe('12.5000%');
701 expect(receivedMarker.style.left).toBe('33.3333%');
702
703 controller.detach();
704 await flushAsyncWork(window, 2);
705 window.close();
706 });
707
708 test('continues current subtitle refreshes after a force-seek aborts the in-flight request', async () =>
709 {
710 const window = createWindow();
711 const helper = loadSharedVideoPlayer(window);
712 const { player, videojs } = buildPlayerHarness(window);
713 const requestedTimes = [];
714
715 window.fetch = jest.fn((url, init = {}) =>
716 {
717 const parsed = new URL(url, 'http://localhost/');
718 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
719 requestedTimes.push(timeSeconds);
720
721 if (requestedTimes.length === 1)
722 {
723 return new Promise((resolve, reject) =>
724 {
725 if (init.signal && typeof init.signal.addEventListener === 'function')
726 {
727 init.signal.addEventListener('abort', () =>
728 {
729 reject(new window.DOMException('Aborted', 'AbortError'));
730 }, { once: true });
731 }
732 });
733 }
734
735 return Promise.resolve(new Response(null, {
736 status: 204,
737 headers: {
738 'X-Subtitle-Frame-Status': 'none',
739 },
740 }));
741 });
742
743 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
744 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
745 }, {
746 lookaheadSeconds: 0,
747 currentRequestTimeoutMs: 300,
748 logToConsole: false,
749 buildFrameRequest: ({ currentTime, streamIndex }) => ({
750 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
751 }),
752 });
753
754 await flushAsyncWork(window, 4);
755 expect(window.fetch).toHaveBeenCalledTimes(1);
756
757 player.setCurrentTime(5);
758 player.trigger('seeking');
759 await flushAsyncWork(window, 20);
760
761 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
762 expect(requestedTimes).toEqual(expect.arrayContaining([0, 5]));
763
764 controller.detach();
765 await flushAsyncWork(window, 2);
766 window.close();
767 });
768
769 test('recovers when a current subtitle request hangs and times out', async () =>
770 {
771 const window = createWindow();
772 const helper = loadSharedVideoPlayer(window);
773 const { player, videojs } = buildPlayerHarness(window);
774 const requestedTimes = [];
775
776 window.fetch = jest.fn((url, init = {}) =>
777 {
778 const parsed = new URL(url, 'http://localhost/');
779 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
780 requestedTimes.push(timeSeconds);
781
782 if (requestedTimes.length === 1)
783 {
784 return new Promise((resolve, reject) =>
785 {
786 if (init.signal && typeof init.signal.addEventListener === 'function')
787 {
788 init.signal.addEventListener('abort', () =>
789 {
790 reject(new window.DOMException('Aborted', 'AbortError'));
791 }, { once: true });
792 }
793 });
794 }
795
796 return Promise.resolve(new Response(null, {
797 status: 204,
798 headers: { 'X-Subtitle-Frame-Status': 'none' },
799 }));
800 });
801
802 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
803 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
804 }, {
805 lookaheadSeconds: 0,
806 currentRequestTimeoutMs: 250,
807 logToConsole: false,
808 buildFrameRequest: ({ currentTime, streamIndex }) => ({
809 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
810 }),
811 });
812
813 await flushAsyncWork(window, 3);
814
815 player.setCurrentTime(1.5);
816 player.trigger('timeupdate');
817
818 await new Promise((resolve) => window.setTimeout(resolve, 320));
819 player.trigger('timeupdate');
820 await new Promise((resolve) => window.setTimeout(resolve, 220));
821 await flushAsyncWork(window, 20);
822
823 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
824 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
825
826 controller.detach();
827 await new Promise((resolve) => window.setTimeout(resolve, 200));
828 await flushAsyncWork(window, 20);
829 window.close();
830 });
831
832 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
833 {
834 const window = createWindow();
835 const helper = loadSharedVideoPlayer(window);
836 const { player, videojs } = buildPlayerHarness(window);
837
838 player.duration(10);
839 player.setCurrentTime(2);
840 window.fetch = jest.fn(async (url) =>
841 {
842 const parsed = new URL(url, 'http://localhost/');
843 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
844
845 if (Math.abs(timeSeconds - 2) < 1e-6)
846 {
847 return new Response('png-data', {
848 status: 200,
849 headers: {
850 'Content-Type': 'image/png',
851 'X-Subtitle-Frame-Status': 'ok',
852 'X-Subtitle-Frame-Start-Time': '2',
853 'X-Subtitle-Frame-End-Time': '3',
854 'X-Subtitle-Frame-Width': '320',
855 'X-Subtitle-Frame-Height': '180',
856 'X-Subtitle-Frame-Canvas-Width': '640',
857 'X-Subtitle-Frame-Canvas-Height': '360',
858 },
859 });
860 }
861
862 return new Response(null, {
863 status: 204,
864 headers: {
865 'X-Subtitle-Frame-Status': 'none',
866 },
867 });
868 });
869
870 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
871 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
872 }, {
873 lookaheadSeconds: 0,
874 buildFrameRequest: ({ currentTime, streamIndex }) => ({
875 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
876 }),
877 });
878
879 await flushAsyncWork(window, 8);
880 expect(window.fetch).toHaveBeenCalledTimes(1);
881
882 player.setCurrentTime(4);
883 player.trigger('timeupdate');
884 await flushAsyncWork(window, 8);
885 expect(window.fetch).toHaveBeenCalledTimes(2);
886
887 const overlay = player.el().querySelector('.video-subtitle-overlay');
888 expect(overlay).toBeTruthy();
889 expect(overlay.style.display).toBe('none');
890
891 player.setCurrentTime(2.5);
892 player.trigger('timeupdate');
893 await flushAsyncWork(window, 8);
894
895 expect(window.fetch).toHaveBeenCalledTimes(2);
896 expect(overlay.style.display).toBe('block');
897
898 controller.detach();
899 await flushAsyncWork(window, 2);
900 window.close();
901 });
902
903 test('registers stream cache service worker once when supported', async () =>
904 {
905 const window = createWindow();
906 const helper = loadSharedVideoPlayer(window);
907 const register = jest.fn(async () => ({}));
908 window.navigator.serviceWorker = { register };
909
910 const first = await helper.enableVideoStreamClientCache();
911 const second = await helper.enableVideoStreamClientCache();
912
913 expect(first).toBe(true);
914 expect(second).toBe(true);
915 expect(register).toHaveBeenCalledTimes(1);
916 expect(register).toHaveBeenCalledWith('/stream-cache-sw.js', {
917 scope: '/',
918 updateViaCache: 'none',
919 });
920
921 window.close();
922 });
923
924 test('clears cached stream assets for a finished playlist session', async () =>
925 {
926 const window = createWindow();
927 const helper = loadSharedVideoPlayer(window);
928 const requests = [
929 new window.Request('http://localhost/api/files/video-stream/sess-a/master.m3u8'),
930 new window.Request('http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts'),
931 new window.Request('http://localhost/api/files/video-stream/sess-b/master.m3u8'),
932 ];
933 const deleteCalls = [];
934 const cache = {
935 keys: jest.fn(async () => requests),
936 delete: jest.fn(async (request) =>
937 {
938 deleteCalls.push(request.url);
939 return true;
940 }),
941 };
942 window.caches = {
943 open: jest.fn(async () => cache),
944 };
945
946 await helper.clearVideoStreamClientCache('http://localhost/api/files/video-stream/sess-a/master.m3u8');
947
948 expect(window.caches.open).toHaveBeenCalledWith('filemanager-stream-cache-v1');
949 expect(cache.keys).toHaveBeenCalledTimes(1);
950 expect(deleteCalls).toEqual(expect.arrayContaining([
951 'http://localhost/api/files/video-stream/sess-a/master.m3u8',
952 'http://localhost/api/files/video-stream/sess-a/stream_0_segment_000001.ts',
953 ]));
954 expect(deleteCalls).not.toContain('http://localhost/api/files/video-stream/sess-b/master.m3u8');
955
956 window.close();
957 });
958});