@amazon/vinyl 1.1.1 → 2.0.0

package/dist/unit/types/current/streaming/MseTrack.test.js

@@ -2,13 +2,12 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, MseTrack, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, MseTrack, PLAYHEAD_NUDGE, SEEKING_STALL_TIME_CHECK, } from '@amazon/vinyl';
 import { createMockDashDependencies, } from '@amazon/vinyl/vinylTestUtil';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
-import { flushPromises } from '@amazon/vinyl-util/browserTestUtil';
+import { flushPromises, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
 import { externalDependencies } from '@amazon/vinyl-di';
 import { Abort } from '@amazon/vinyl-util';
-import { data } from '@amazon/vinyl-observable';
 var any = jasmine.any;
 describe('MseTrack', () => {
     useMockLogger();
@@ -41,6 +40,7 @@ describe('MseTrack', () => {
         track = null;
         deps = createMockDashDependencies();
         deps.contentTypesValue.value = Promise.resolve(new Set(['audio', 'video']));
+        deps.playbackController.play.and.resolveTo(void 0);
     });
     afterEach(() => {
         if (!track?.disposed)
@@ -175,7 +175,7 @@ describe('MseTrack', () => {
             expect(deps.playbackSource.disableRemotePlayback).toBeTrue();
         });
         it('sets the src', async () => {
-            deps.mediaSourceController.createUrl.and.returnValue('test1');
+            deps.mediaSourceController.activate.and.returnValue('test1');
             track = createTrack();
             await awaitContentTypes();
             expect(deps.playbackSource.src).toBeNull();
@@ -193,8 +193,14 @@ describe('MseTrack', () => {
             getVideoStream().streamingQuality = videoMetadata;
             track.activate({});
             expect(deps.drmController.initializeForPlayback).toHaveBeenCalledTimes(2);
-            expect(deps.drmController.initializeForPlayback).toHaveBeenCalledWith(audioMetadata, any(Abort));
-            expect(deps.drmController.initializeForPlayback).toHaveBeenCalledWith(videoMetadata, any(Abort));
+            expect(deps.drmController.initializeForPlayback).toHaveBeenCalledWith(audioMetadata, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
+            expect(deps.drmController.initializeForPlayback).toHaveBeenCalledWith(videoMetadata, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
         });
     });
     describe('deactivate', () => {
@@ -207,6 +213,17 @@ describe('MseTrack', () => {
             expect(deps.playbackSource.load).toHaveBeenCalledOnceWith();
             expect(deps.playbackController.pause).toHaveBeenCalledOnceWith();
         });
+        it('clears the drm buffering info', async () => {
+            track = createTrack();
+            await awaitContentTypes();
+            track.activate({});
+            deps.drmController.setBufferingDrmInfo.calls.reset();
+            track.deactivate();
+            expect(deps.drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(null, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
+        });
     });
     describe('error', () => {
         it('returns the first emitted error', async () => {
@@ -255,14 +272,20 @@ describe('MseTrack', () => {
                 previous: null,
                 current: metadata1,
             });
-            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata1, any(Abort));
+            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata1, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
             drmController.initializeForPlayback.calls.reset();
             const metadata2 = createEmptyMediaQualityMetadata();
             getVideoStream().dispatch('streamingQualityChange', {
                 previous: null,
                 current: metadata2,
             });
-            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata2, any(Abort));
+            expect(drmController.initializeForPlayback).toHaveBeenCalledOnceWith(metadata2, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
         });
     });
     describe('when bufferingQualityChange is emitted', () => {
@@ -274,13 +297,65 @@ describe('MseTrack', () => {
                 previous: null,
                 current: metadata,
             });
-            expect(deps.drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, any(Abort));
+            expect(deps.drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
             deps.drmController.setBufferingDrmInfo.calls.reset();
             getVideoStream().dispatch('bufferingQualityChange', {
                 previous: null,
                 current: metadata,
             });
-            expect(deps.drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, any(Abort));
+            expect(deps.drmController.setBufferingDrmInfo).toHaveBeenCalledOnceWith(metadata, {
+                trackUri: 'uri',
+                abort: any(Abort),
+            });
+        });
+        it('keeps the drm info when a stream transiently clears its buffering quality', async () => {
+            // A seek/clear nulls a stream's buffering quality; the DRM info must
+            // be kept so another still-appending stream's `encrypted` event can
+            // resolve it. It is cleared on deactivation instead.
+            track = createTrack();
+            await awaitContentTypes();
+            getAudioStream().dispatch('bufferingQualityChange', {
+                previous: createEmptyMediaQualityMetadata(),
+                current: null,
+            });
+            expect(deps.drmController.setBufferingDrmInfo).not.toHaveBeenCalled();
+        });
+    });
+    describe('load span attribution', () => {
+        it('stamps its own uri onto a manifest load span at the source', async () => {
+            track = createTrack('track-a');
+            await awaitContentTypes();
+            const spy = createEventSpy(track, 'loadSpanMeasured');
+            deps.manifestController.dispatch('loadSpanMeasured', {
+                kind: 'manifest',
+                startTime: 1,
+                endTime: 2,
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'manifest',
+                startTime: 1,
+                endTime: 2,
+                trackUri: 'track-a',
+            });
+        });
+        it('stamps its own uri onto a segment load span at the source', async () => {
+            track = createTrack('track-a');
+            await awaitContentTypes();
+            const spy = createEventSpy(track, 'loadSpanMeasured');
+            getAudioStream().dispatch('loadSpanMeasured', {
+                kind: 'initSegment',
+                startTime: 3,
+                endTime: 4,
+            });
+            expect(spy).toHaveBeenCalledOnceWith({
+                kind: 'initSegment',
+                startTime: 3,
+                endTime: 4,
+                trackUri: 'track-a',
+            });
         });
     });
     describe('getStreamingQuality', () => {
@@ -338,6 +413,73 @@ describe('MseTrack', () => {
             expect(track.bufferingEnded).toBe(false);
         });
     });
+    describe('stalled-seek recovery nudge', () => {
+        const clock = useMockTime();
+        function fillStream(stream) {
+            stream.hasData = true;
+            stream.dispatch('hasDataChange', { previous: false, current: true });
+        }
+        async function setup() {
+            deps.playbackController.seekTo.and.resolveTo(void 0);
+            track = createTrack();
+            await awaitContentTypes();
+            return { audio: getAudioStream(), video: getVideoStream() };
+        }
+        it('nudges the playhead when all streams have data but the seek is still stuck', async () => {
+            const { audio, video } = await setup();
+            deps.playbackController.seeking = true;
+            deps.playbackController.currentTime = 30;
+            fillStream(audio);
+            // Only one stream has data — nothing scheduled yet.
+            fillStream(video);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).toHaveBeenCalledOnceWith(30 + PLAYHEAD_NUDGE, 0);
+        });
+        it('does not nudge if the seek completes before the check fires', async () => {
+            const { audio, video } = await setup();
+            deps.playbackController.seeking = true;
+            fillStream(audio);
+            fillStream(video);
+            deps.playbackController.seeking = false;
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+        });
+        it('does not nudge until every stream has data', async () => {
+            const { audio } = await setup();
+            deps.playbackController.seeking = true;
+            fillStream(audio);
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+        });
+        it('does not nudge if a stream loses its data before the check fires', async () => {
+            const { audio, video } = await setup();
+            deps.playbackController.seeking = true;
+            fillStream(audio);
+            fillStream(video);
+            // A stream's buffer was cleared during the wait window.
+            video.hasData = false;
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+        });
+        it('does not nudge when not seeking', async () => {
+            const { audio, video } = await setup();
+            deps.playbackController.seeking = false;
+            fillStream(audio);
+            fillStream(video);
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+        });
+        it('does not nudge after the track is disposed', async () => {
+            const { audio, video } = await setup();
+            deps.playbackController.seeking = true;
+            fillStream(audio);
+            fillStream(video);
+            track.dispose();
+            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
+            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
+        });
+    });
     describe('checkBufferingEnded', () => {
         it('calls endOfStream and dispatches bufferingEnded when all streams are done', async () => {
             track = createTrack();
@@ -475,10 +617,12 @@ describe('MseTrack', () => {
             contentType: 'audio',
             qualityId: 'q2',
         };
-        function setTimeline(timeline) {
-            ;
-            deps.mediaTimeline = data(Promise.resolve(timeline));
-            deps.mediaTimelineTransformed = data(Promise.resolve(timeline));
+        // Sets the raw and (optionally) the filtered/transformed timelines. They
+        // default to the same timeline; pass a distinct `transformed` to model
+        // the language/codec filter narrowing the playable set.
+        function setTimeline(timeline, transformed = timeline) {
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            deps.mediaTimelineTransformed.value = Promise.resolve(transformed);
         }
         it('returns null when timeline has no periods', () => {
             track = createTrack();
@@ -500,12 +644,43 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();
             expect(track.qualities).toEqual([qualityMetadata]);
             expect(track.qualitiesUnfiltered).toEqual([qualityMetadata]);
         });
+        it('reads qualities from the filtered timeline but qualitiesUnfiltered from the raw one', async () => {
+            // The transformed timeline is filtered (e.g. by preferred audio
+            // language) down to one quality; the raw timeline keeps them all.
+            // `qualitiesUnfiltered` must reflect the RAW timeline so consumers
+            // (e.g. a language picker) still see every option.
+            const makeTimeline = (qualities) => ({
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: 100,
+                        qualities: qualities.map((metadata) => ({
+                            metadata,
+                            getSegment: () => Promise.resolve(null),
+                        })),
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
+            });
+            setTimeline(makeTimeline([qualityMetadata, qualityMetadata2]), makeTimeline([qualityMetadata]));
+            track = createTrack();
+            await flushPromises();
+            expect(track.qualities).toEqual([qualityMetadata]);
+            expect(track.qualitiesUnfiltered).toEqual([
+                qualityMetadata,
+                qualityMetadata2,
+            ]);
+        });
         it('dispatches qualitiesChange event', async () => {
             setTimeline({
                 periods: [
@@ -521,6 +696,8 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             const spy = createEventSpy(track, 'qualitiesChange');
@@ -555,6 +732,8 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
             };
             setTimeline(timeline);
             track = createTrack();
@@ -587,6 +766,8 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();
@@ -603,4 +784,291 @@ describe('MseTrack', () => {
             expect(spy).not.toHaveBeenCalled();
         });
     });
+    describe('textTrackController', () => {
+        it('returns null when no controller is provided', () => {
+            track = new MseTrack('uri', 'mse', externalDependencies({ ...deps, textTrackController: null }));
+            expect(track.textTrackController).toBeNull();
+        });
+        it('returns the dependency-provided controller', () => {
+            track = createTrack();
+            expect(track.textTrackController).toBe(deps.textTrackController);
+        });
+        it('suspends the controller on deactivate and resumes it on activate', () => {
+            track = createTrack();
+            track.activate({});
+            expect(deps.textTrackController.resume).toHaveBeenCalled();
+            track.deactivate();
+            expect(deps.textTrackController.suspend).toHaveBeenCalled();
+        });
+        // Regression: reading a disposed track's controller threw DisposedError
+        // (disposed DI-container lazy). An ad track evicted mid-break is still
+        // the outgoing track on the track change that resumes content, and
+        // the player reads its textTrackController — the throw stalled the ad.
+        it('returns null (not throw) when read after disposal', () => {
+            const t = (track = createTrack());
+            expect(t.textTrackController).toBe(deps.textTrackController);
+            t.dispose();
+            expect(() => t.textTrackController).not.toThrow();
+            expect(t.textTrackController).toBeNull();
+        });
+        it('does not throw when its activate/deactivate hooks run after disposal', () => {
+            const t = (track = createTrack());
+            t.dispose();
+            expect(() => t.onDeactivated()).not.toThrow();
+            expect(() => t.onActivated({})).not.toThrow();
+        });
+    });
+    describe('seekRange', () => {
+        // Sets the raw and (optionally) the filtered/transformed timelines. They
+        // default to the same timeline; pass a distinct `transformed` to model
+        // the language/codec filter narrowing the playable set.
+        function setTimeline(timeline, transformed = timeline) {
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            deps.mediaTimelineTransformed.value = Promise.resolve(transformed);
+        }
+        it('is null initially', () => {
+            track = createTrack();
+            expect(track.seekRange).toBeNull();
+        });
+        it('resolves from the media timeline duration', async () => {
+            setTimeline({
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: 120,
+                        qualities: [],
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(120),
+            });
+            track = createTrack();
+            await flushPromises();
+            expect(track.seekRange).toEqual({ start: 0, end: 120 });
+        });
+        it('dispatches seekRangeChange when the range resolves', async () => {
+            setTimeline({
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: 60,
+                        qualities: [],
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(60),
+            });
+            track = createTrack();
+            const spy = createEventSpy(track, 'seekRangeChange');
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({
+                previous: null,
+                current: { start: 0, end: 60 },
+            }));
+        });
+        it('returns Infinity end for live streams', async () => {
+            setTimeline({
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: Infinity,
+                        qualities: [],
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
+            });
+            track = createTrack();
+            await flushPromises();
+            expect(track.seekRange).toEqual({ start: 0, end: Infinity });
+        });
+        it('does not dispatch when range is unchanged', async () => {
+            const timeline = {
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: 60,
+                        qualities: [],
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(60),
+            };
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            deps.mediaTimelineTransformed.value = Promise.resolve(timeline);
+            track = createTrack();
+            await flushPromises();
+            expect(track.seekRange).toEqual({ start: 0, end: 60 });
+            const spy = createEventSpy(track, 'seekRangeChange');
+            // Re-emit the same timeline
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            await flushPromises();
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('does not update seekRange if disposed during getDuration', async () => {
+            let resolveDuration;
+            const timeline = {
+                periods: [{ startTime: 0, endTime: 60, qualities: [] }],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => new Promise((r) => {
+                    resolveDuration = r;
+                }),
+            };
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            deps.mediaTimelineTransformed.value = Promise.resolve(timeline);
+            track = createTrack();
+            await flushPromises();
+            // Dispose before getDuration resolves
+            track.dispose();
+            resolveDuration(60);
+            await flushPromises();
+            expect(track.seekRange).toBeNull();
+        });
+    });
+    describe('ads', () => {
+        // Sets the raw and (optionally) the filtered/transformed timelines. They
+        // default to the same timeline; pass a distinct `transformed` to model
+        // the language/codec filter narrowing the playable set.
+        function setTimeline(timeline, transformed = timeline) {
+            deps.mediaTimeline.value = Promise.resolve(timeline);
+            deps.mediaTimelineTransformed.value = Promise.resolve(transformed);
+        }
+        function makeTimeline(adBreaks) {
+            return {
+                periods: [],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve(adBreaks),
+                getDuration: () => Promise.resolve(Infinity),
+            };
+        }
+        const sampleAdBreaks = [
+            {
+                id: 'b1',
+                startTime: 10,
+                duration: 5,
+                placement: 'midroll',
+                restrict: {},
+                once: false,
+                resumeOffset: null,
+                playoutLimit: null,
+                resolutionTimeOffset: null,
+                skipControl: () => null,
+                ads: () => Promise.resolve([
+                    {
+                        id: 'a1',
+                        startTime: 10,
+                        duration: 5,
+                        uri: 'ad.m3u8',
+                    },
+                ]),
+            },
+        ];
+        it('resolves discovered ad breaks from the current timeline', async () => {
+            setTimeline(makeTimeline(sampleAdBreaks));
+            track = createTrack();
+            expect(await track.getAds()).toEqual({
+                trackUri: track.uri,
+                adBreaks: sampleAdBreaks,
+            });
+        });
+        it('resolves an empty ad break list when the timeline has none', async () => {
+            setTimeline(makeTimeline([]));
+            track = createTrack();
+            expect((await track.getAds()).adBreaks).toEqual([]);
+        });
+        it('dispatches adsChange when the transformed timeline updates', async () => {
+            setTimeline(makeTimeline(sampleAdBreaks));
+            track = createTrack();
+            const spy = createEventSpy(track, 'adsChange');
+            // A subsequent transformed-timeline emission re-signals that the
+            // track's ads may have changed; consumers re-read via getAds().
+            deps.mediaTimelineTransformed.value = Promise.resolve(makeTimeline(sampleAdBreaks));
+            await flushPromises();
+            expect(spy).toHaveBeenCalled();
+        });
+        it('reflects the current timeline on each getAds call (no stale cache)', async () => {
+            setTimeline(makeTimeline([]));
+            track = createTrack();
+            expect((await track.getAds()).adBreaks).toEqual([]);
+            // The timeline changes; getAds() awaits the current value, so a
+            // later call reflects the new breaks rather than a cached result.
+            deps.mediaTimeline.value = Promise.resolve(makeTimeline(sampleAdBreaks));
+            expect((await track.getAds()).adBreaks).toEqual(sampleAdBreaks);
+        });
+    });
+    describe('option-driven stream effects', () => {
+        beforeEach(async () => {
+            track = createTrack();
+            await awaitContentTypes();
+        });
+        it('does not react to the initial option values on construction', () => {
+            // Each binding is guarded on previous === undefined, so the initial
+            // emission during construction must not rebuild the track.
+            expect(deps.manifestController.reset).not.toHaveBeenCalled();
+            expect(getAudioStream().reset).not.toHaveBeenCalled();
+        });
+        // A shared array reference so re-applying it reads as unchanged.
+        const allowed = ['audio'];
+        for (const scenario of [
+            {
+                name: 'preferredAudioLanguage',
+                apply: () => (deps.preferredAudioLanguage.value = 'ja'),
+            },
+            {
+                name: 'allowedContentTypes',
+                apply: () => (deps.allowedContentTypes.value = allowed),
+            },
+            {
+                name: 'preferDescriptiveAudio',
+                apply: () => (deps.preferDescriptiveAudio.value = true),
+            },
+        ]) {
+            describe(`when ${scenario.name} changes`, () => {
+                it('clears prefetch and hard-resets this track', () => {
+                    const clearSpy = spyOn(track, 'clearPrefetch');
+                    const resetSpy = spyOn(track, 'reset');
+                    scenario.apply();
+                    expect(clearSpy).toHaveBeenCalledOnceWith();
+                    expect(resetSpy).toHaveBeenCalledOnceWith(true);
+                });
+                it('does not react when the value is unchanged', () => {
+                    scenario.apply();
+                    const clearSpy = spyOn(track, 'clearPrefetch');
+                    const resetSpy = spyOn(track, 'reset');
+                    // Re-applying the identical value is not a change.
+                    scenario.apply();
+                    expect(clearSpy).not.toHaveBeenCalled();
+                    expect(resetSpy).not.toHaveBeenCalled();
+                });
+            });
+        }
+        describe('when abr resolution restrictions change', () => {
+            it('clears prefetch (without a rebuild) when maxHeight changes', () => {
+                const clearSpy = spyOn(track, 'clearPrefetch');
+                const resetSpy = spyOn(track, 'reset');
+                deps.abr.value = { ...deps.abr.value, maxHeight: 480 };
+                expect(clearSpy).toHaveBeenCalledOnceWith();
+                // The same streams just re-select a quality — no stream rebuild.
+                expect(resetSpy).not.toHaveBeenCalled();
+            });
+            it('clears prefetch when maxWidth changes', () => {
+                const clearSpy = spyOn(track, 'clearPrefetch');
+                deps.abr.value = { ...deps.abr.value, maxWidth: 640 };
+                expect(clearSpy).toHaveBeenCalledOnceWith();
+            });
+            it('does not clear prefetch for a non-restriction abr change', () => {
+                const clearSpy = spyOn(track, 'clearPrefetch');
+                deps.abr.value = {
+                    ...deps.abr.value,
+                    highBufferThreshold: 42,
+                };
+                expect(clearSpy).not.toHaveBeenCalled();
+            });
+        });
+    });
 });