BlueGit

timfa filemanager

Files

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

shared-video-player.test.js

sub cache
timfa Tim Falken · pushed by timfa · 5 months ago
b9425887 History
shared-video-player.test.js 25.5 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('recovers when a current subtitle request hangs and times out', 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: { 'X-Subtitle-Frame-Status': 'none' },
738 }));
739 });
740
741 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
742 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
743 }, {
744 lookaheadSeconds: 0,
745 currentRequestTimeoutMs: 250,
746 logToConsole: false,
747 buildFrameRequest: ({ currentTime, streamIndex }) => ({
748 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
749 }),
750 });
751
752 await flushAsyncWork(window, 3);
753
754 player.setCurrentTime(1.5);
755 player.trigger('timeupdate');
756
757 await new Promise((resolve) => window.setTimeout(resolve, 320));
758 player.trigger('timeupdate');
759 await new Promise((resolve) => window.setTimeout(resolve, 220));
760 await flushAsyncWork(window, 20);
761
762 expect(window.fetch.mock.calls.length).toBeGreaterThanOrEqual(2);
763 expect(requestedTimes).toEqual(expect.arrayContaining([0, 1.5]));
764
765 controller.detach();
766 await new Promise((resolve) => window.setTimeout(resolve, 200));
767 await flushAsyncWork(window, 20);
768 window.close();
769 });
770
771 test('reuses cached subtitle frames after rewinding when server no longer has older frames', async () =>
772 {
773 const window = createWindow();
774 const helper = loadSharedVideoPlayer(window);
775 const { player, videojs } = buildPlayerHarness(window);
776
777 player.duration(10);
778 player.setCurrentTime(2);
779 window.fetch = jest.fn(async (url) =>
780 {
781 const parsed = new URL(url, 'http://localhost/');
782 const timeSeconds = Number(parsed.searchParams.get('timeSeconds'));
783
784 if (Math.abs(timeSeconds - 2) < 1e-6)
785 {
786 return new Response('png-data', {
787 status: 200,
788 headers: {
789 'Content-Type': 'image/png',
790 'X-Subtitle-Frame-Status': 'ok',
791 'X-Subtitle-Frame-Start-Time': '2',
792 'X-Subtitle-Frame-End-Time': '3',
793 'X-Subtitle-Frame-Width': '320',
794 'X-Subtitle-Frame-Height': '180',
795 'X-Subtitle-Frame-Canvas-Width': '640',
796 'X-Subtitle-Frame-Canvas-Height': '360',
797 },
798 });
799 }
800
801 return new Response(null, {
802 status: 204,
803 headers: {
804 'X-Subtitle-Frame-Status': 'none',
805 },
806 });
807 });
808
809 const controller = helper.bindImageSubtitleOverlay(player, videojs, {}, {
810 imageSubtitleTracks: [{ label: 'PGS English', streamIndex: 0, default: true }],
811 }, {
812 lookaheadSeconds: 0,
813 buildFrameRequest: ({ currentTime, streamIndex }) => ({
814 url: `/subtitle-frame?streamIndex=${streamIndex}&timeSeconds=${currentTime}`,
815 }),
816 });
817
818 await flushAsyncWork(window, 8);
819 expect(window.fetch).toHaveBeenCalledTimes(1);
820
821 player.setCurrentTime(4);
822 player.trigger('timeupdate');
823 await flushAsyncWork(window, 8);
824 expect(window.fetch).toHaveBeenCalledTimes(2);
825
826 const overlay = player.el().querySelector('.video-subtitle-overlay');
827 expect(overlay).toBeTruthy();
828 expect(overlay.style.display).toBe('none');
829
830 player.setCurrentTime(2.5);
831 player.trigger('timeupdate');
832 await flushAsyncWork(window, 8);
833
834 expect(window.fetch).toHaveBeenCalledTimes(2);
835 expect(overlay.style.display).toBe('block');
836
837 controller.detach();
838 await flushAsyncWork(window, 2);
839 window.close();
840 });
841});