@amazon/vinyl 3.0.1 → 3.2.0

package/dist/unit/types/current/track/TrackController.test.js

@@ -480,6 +480,66 @@ describe('TrackControllerImpl', () => {
             });
         });
     });
+    describe('guards async ad continuations after dispose', () => {
+        it('does not dispatch trackEnded when disposed before the postroll resolves', async () => {
+            let resolvePostroll = () => { };
+            deps.adController.enterPostroll.and.returnValue(new Promise((res) => {
+                resolvePostroll = res;
+            }));
+            trackController.load(...createLoadOptionsList(2));
+            await clock.tick(); // activate the first track
+            const endedSpy = jasmine.createSpy('trackEnded');
+            trackController.on('trackEnded', endedSpy);
+            deps.playbackController.dispatch('ended', {}); // onEnded → enterPostroll pending
+            trackController.dispose();
+            disposed = true;
+            resolvePostroll(null); // .then guarded by interrupted()
+            await clock.tick();
+            expect(endedSpy).not.toHaveBeenCalled();
+        });
+        it('does not advance the queue when disposed within the trackEnded handler', async () => {
+            trackController.load(...createLoadOptionsList(2));
+            await clock.tick(); // activate the first track
+            trackController.on('trackEnded', () => {
+                trackController.dispose(); // interrupt before the queued next()
+                disposed = true;
+            });
+            const activatedSpy = jasmine.createSpy('trackActivated');
+            trackController.on('trackActivated', activatedSpy);
+            deps.playbackController.dispatch('ended', {});
+            await clock.tick();
+            // The queued next() is skipped: interrupted() is true in the microtask.
+            expect(activatedSpy).not.toHaveBeenCalled();
+        });
+        it('swallows a postroll rejection after dispose', async () => {
+            let rejectPostroll = () => { };
+            deps.adController.enterPostroll.and.returnValue(new Promise((_res, rej) => {
+                rejectPostroll = rej;
+            }));
+            trackController.load(...createLoadOptionsList(1));
+            await clock.tick();
+            deps.playbackController.dispatch('ended', {});
+            trackController.dispose();
+            disposed = true;
+            rejectPostroll(new Error('late')); // .catch guarded by interrupted()
+            await clock.tick();
+            expect(trackController.disposed).toBeTrue();
+        });
+        it('does not activate when disposed before the preroll rejects', async () => {
+            let rejectPreroll = () => { };
+            deps.adController.enterPreroll.and.returnValue(new Promise((_res, rej) => {
+                rejectPreroll = rej;
+            }));
+            const activatedSpy = jasmine.createSpy('trackActivated');
+            trackController.on('trackActivated', activatedSpy);
+            trackController.load(...createLoadOptionsList(1)); // activation deferred behind enterPreroll
+            trackController.dispose();
+            disposed = true;
+            rejectPreroll(new Error('late')); // .catch guarded by interrupted()
+            await clock.tick();
+            expect(activatedSpy).not.toHaveBeenCalled();
+        });
+    });
     describe('unload', () => {
         it('unloads the active track and clears the queue', () => {
             trackController.load(...createLoadOptionsList(3));
@@ -813,7 +873,7 @@ describe('TrackControllerImpl', () => {
             expect(() => trackController.reset()).not.toThrow();
         });
     });
-    describe('reset', () => {
+    describe('reset (hard)', () => {
         it('delegates a hard reset to the current track', async () => {
             trackController.load(...createLoadOptionsList(1));
             await clock.tick();

package/dist/unit/types/current/track/createSegmentDataProvider.test.js

@@ -208,6 +208,24 @@ describe('createSegmentDataProvider', () => {
                 serviceId: 'example.com',
             }));
         });
+        it('does not report transfer entry when aborted before the metrics read', async () => {
+            const abort = new Abort();
+            const response = new Response(new ArrayBuffer(10));
+            spyOn(response, 'arrayBuffer').and.callFake(() => {
+                // Abort after the fetch resolves, before the metrics read.
+                abort.abort();
+                return Promise.resolve(new ArrayBuffer(10));
+            });
+            mockRequester.request.and.resolveTo(response);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            const promise = provider(abort);
+            await clock.tick(2);
+            await promise;
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).not.toHaveBeenCalled();
+        });
     });
     describe('when reportDownlinkMetrics is false', () => {
         it('does not report transfer entry', async () => {

package/dist/unit/types/current/track/dash/DashMediaQualityMetadataResolver.test.js

@@ -422,7 +422,7 @@ describe('getPeriodSortedBandwidths', () => {
     });
 });
 describe('estimatePeakBandwidth', () => {
-    it('pairs proportionally when video has more qualities than audio', () => {
+    it('pairs each tier with the cheapest peer in its bucket', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
             <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
@@ -441,20 +441,51 @@ describe('estimatePeakBandwidth', () => {
             </MPD>`);
         const as0 = m.MPD.Period[0].AdaptationSet[0];
         const as1 = m.MPD.Period[0].AdaptationSet[1];
-        // video sorted: [4000, 3000, 2000, 1000], audio sorted: [200, 100]
-        // v1 pos=0/3=0.00 → audio index round(0.00*1)=0 → 200. total=4200
+        // video sorted: [4000, 3000, 2000, 1000], audio sorted: [200, 100].
+        // Video's two audio buckets: v1,v2 → a1(200); v3,v4 → a2(100).
         expect(estimatePeakBandwidth(as0.Representation[0], 'video')).toBe(4200);
-        // v2 pos=1/3=0.33 → audio index round(0.33*1)=0 → 200. total=3200
         expect(estimatePeakBandwidth(as0.Representation[1], 'video')).toBe(3200);
-        // v3 pos=2/3=0.67 → audio index round(0.67*1)=1 → 100. total=2100
         expect(estimatePeakBandwidth(as0.Representation[2], 'video')).toBe(2100);
-        // v4 pos=3/3=1.00 → audio index round(1.00*1)=1 → 100. total=1100
         expect(estimatePeakBandwidth(as0.Representation[3], 'video')).toBe(1100);
-        // a1 pos=0/1=0 → video index round(0*3)=0 → 4000. total=4200
-        expect(estimatePeakBandwidth(as1.Representation[0], 'audio')).toBe(4200);
-        // a2 pos=1/1=1 → video index round(1*3)=3 → 1000. total=1100
+        // Audio's two video buckets: a1's bucket is v1,v2 so it pairs with the
+        // cheapest of those (v2=3000); a2's bucket is v3,v4 (cheapest v4=1000).
+        expect(estimatePeakBandwidth(as1.Representation[0], 'audio')).toBe(3200);
         expect(estimatePeakBandwidth(as1.Representation[1], 'audio')).toBe(1100);
     });
+    it('does not pin a small stream to its lowest tier across a finer peer', () => {
+        // 2 audio tiers alongside 10 video tiers: the top audio must stay
+        // affordable across the whole top half of video, not only at the very
+        // top. (Regression: it was priced with the single top video.)
+        // language=XML
+        const m = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period>
+                    <AdaptationSet mimeType="video/mp4" codecs="avc1.640015">
+                        <Representation bandwidth="10000" id="v1"/>
+                        <Representation bandwidth="9000" id="v2"/>
+                        <Representation bandwidth="8000" id="v3"/>
+                        <Representation bandwidth="7000" id="v4"/>
+                        <Representation bandwidth="6000" id="v5"/>
+                        <Representation bandwidth="5000" id="v6"/>
+                        <Representation bandwidth="4000" id="v7"/>
+                        <Representation bandwidth="3000" id="v8"/>
+                        <Representation bandwidth="2000" id="v9"/>
+                        <Representation bandwidth="1000" id="v10"/>
+                    </AdaptationSet>
+                    <AdaptationSet mimeType="audio/mp4" codecs="mp4a.40.2">
+                        <Representation bandwidth="200" id="a1"/>
+                        <Representation bandwidth="100" id="a2"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const audio = m.MPD.Period[0].AdaptationSet[1];
+        // Top audio's bucket is video[0..4]; it pairs with the cheapest of those
+        // (video[4]=6000), NOT video[0]=10000. So its total is 6200, keeping it
+        // affordable for the top half of video tiers.
+        expect(estimatePeakBandwidth(audio.Representation[0], 'audio')).toBe(6200);
+        // Bottom audio's bucket is video[5..9]; cheapest video[9]=1000 → 1100.
+        expect(estimatePeakBandwidth(audio.Representation[1], 'audio')).toBe(1100);
+    });
     it('returns bandwidth as-is for single content type periods', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
@@ -482,7 +513,7 @@ describe('estimatePeakBandwidth', () => {
             </MPD>`);
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[0], 'text')).toBe(50000);
     });
-    it('pairs proportionally with three content types', () => {
+    it('pairs with the cheapest peer bucket across three content types', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
             <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
@@ -500,12 +531,13 @@ describe('estimatePeakBandwidth', () => {
                     </AdaptationSet>
                 </Period>
             </MPD>`);
-        // v1 pos=0 → audio[0]=200, text[0]=10. total=2210
+        // v1 → cheapest audio in its bucket (200) + cheapest text (10). total=2210
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[0], 'video')).toBe(2210);
-        // v2 pos=1 → audio[1]=100, text[0]=10. total=1110
+        // v2 → audio bucket cheapest (100) + text (10). total=1110
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[1], 'video')).toBe(1110);
-        // t1 pos=0 (only 1 text) → video[0]=2000, audio[0]=200. total=2210
-        expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[2].Representation[0], 'text')).toBe(2210);
+        // t1 is the only text tier, so its bucket spans every peer — it pairs
+        // with the cheapest video (1000) and cheapest audio (100). total=1110
+        expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[2].Representation[0], 'text')).toBe(1110);
     });
     it('handles single quality per content type', () => {
         // language=XML

package/dist/unit/types/current/track/dash/createSegmentControllerFactory.test.js

@@ -22,5 +22,6 @@ describe('createSegmentControllerFactory', () => {
         });
         expect(controller).toEqual(jasmine.any(Object));
         expect(controller.options).toEqual(objectContaining({ prefetchActive: 100 }));
+        controller.dispose();
     });
 });

package/dist/unit/types/current/track/dash/timeline/DashRepresentationSegmentProvider.test.js

@@ -277,6 +277,120 @@ describe('createDashRepresentationSegmentProvider', () => {
             });
         });
     });
+    describe('when SegmentBase is a WebM stream', () => {
+        // Minimal EBML builders for a synthetic WebM init + Cues.
+        const vintSize = (n) => n < 0x80 ? [0x80 | n] : [0x40 | (n >> 8), n & 0xff];
+        const el = (id, content) => [
+            ...id,
+            ...vintSize(content.length),
+            ...content,
+        ];
+        const bytesToArrayBuffer = (bytes) => new Uint8Array(bytes).buffer;
+        // EBML header (5 bytes) then Segment(Info > TimecodeScale=1_000_000);
+        // the Segment data starts at offset 10, so cue positions are + 10.
+        const initBuffer = bytesToArrayBuffer([
+            ...el([0x1a, 0x45, 0xdf, 0xa3], []),
+            ...el([0x18, 0x53, 0x80, 0x67], el([0x15, 0x49, 0xa9, 0x66], el([0x2a, 0xd7, 0xb1], [0x0f, 0x42, 0x40]))),
+        ]);
+        const cuePoint = (time, pos) => el([0xbb], [
+            ...el([0xb3], time),
+            ...el([0xb7], [...el([0xf7], [0x01]), ...el([0xf1], pos)]),
+        ]);
+        // Cue 0 @ t=0 → cluster pos 100; cue 1 @ t=2000ms → cluster pos 200.
+        const cuesBuffer = bytesToArrayBuffer(el([0x1c, 0x53, 0xbb, 0x6b], [
+            ...cuePoint([0x00], [0x00, 0x64]),
+            ...cuePoint([0x07, 0xd0], [0x00, 0xc8]),
+        ]));
+        beforeEach(() => {
+            // WebM Cues don't carry the last segment's end, so a period end is
+            // required (VOD defines one).
+            manifest.MPD.mediaPresentationDuration = 60;
+            representation.BaseURL = [
+                { _content: 'https://example.com/v.webm' },
+            ];
+            representation.mimeType = 'video/webm';
+            representation.codecs = 'vp9';
+            representation.SegmentBase = {
+                indexRangeExact: false,
+                indexRange: [100, 199],
+                timescale: 1000000,
+                Initialization: { range: [0, 99] },
+            };
+            // The provider fetches the init and Cues ranges in parallel; return
+            // the matching buffer per Range header.
+            mockRequesterRef.value.request.and.callFake(((_input, init) => {
+                const range = init?.headers?.['Range'];
+                const body = range === 'bytes=0-99'
+                    ? initBuffer
+                    : range === 'bytes=100-199'
+                        ? cuesBuffer
+                        : new ArrayBuffer(0);
+                return Promise.resolve(new Response(body));
+            }));
+        });
+        it('creates a timeline from the WebM Cues', async () => {
+            const timeline = createTimeline();
+            // Prime the timeline (fetch init + Cues), then assert the segments.
+            await timeline.getSegment(0);
+            clearRequestCalls();
+            const info = await getSegmentRequestData(timeline);
+            expect(info).toEqual({
+                init: {
+                    qualityId: any(String),
+                    decoderId: any(String),
+                    mimeType: 'video/webm; codecs="vp9"',
+                    href: 'https://example.com/v.webm',
+                    serviceId: 'example.com',
+                    range: 'bytes=0-99',
+                },
+                segments: [
+                    {
+                        startTime: 0,
+                        endTime: 2,
+                        timestampOffset: 0,
+                        href: 'https://example.com/v.webm',
+                        serviceId: 'example.com',
+                        // segmentDataStart(10) + cue positions 100..200.
+                        range: 'bytes=110-209',
+                    },
+                    {
+                        startTime: 2,
+                        endTime: 60,
+                        timestampOffset: 2,
+                        href: 'https://example.com/v.webm',
+                        serviceId: 'example.com',
+                        // Last cluster runs open-ended to end of file.
+                        range: 'bytes=210-',
+                    },
+                ],
+            });
+        });
+        it('indexes WebM without an explicit SegmentBase timescale', async () => {
+            delete representation.SegmentBase
+                .timescale;
+            const timeline = createTimeline();
+            const segment = await timeline.getSegment(0);
+            expect(segment).not.toBeNull();
+            // Cue 0 at ticks 0 → 0s (TimecodeScale-derived ticks-per-second).
+            expect(segment.startTime).toBe(0);
+        });
+        it('throws when the period has no determinable end', () => {
+            delete manifest.MPD
+                .mediaPresentationDuration;
+            const timeline = createTimeline();
+            return expectAsync(timeline.getSegment(0)).toBeRejectedWithError(/mediaPresentationDuration or Period\.duration required/);
+        });
+        it('throws when the Cues contain no cue points', () => {
+            // A Cues element whose only CuePoint lacks a cluster position.
+            const emptyCues = bytesToArrayBuffer(el([0x1c, 0x53, 0xbb, 0x6b], el([0xbb], el([0xb3], [0x00]))));
+            mockRequesterRef.value.request.and.callFake(((_input, init) => {
+                const range = init?.headers?.['Range'];
+                return Promise.resolve(new Response(range === 'bytes=0-99' ? initBuffer : emptyCues));
+            }));
+            const timeline = createTimeline();
+            return expectAsync(timeline.getSegment(0)).toBeRejectedWithError(/Cues contained no cue points/);
+        });
+    });
     describe('when SegmentList is defined', () => {
         let segmentList;
         beforeEach(() => {

package/dist/unit/types/current/track/dash/util/mpd.test.js

@@ -146,6 +146,31 @@ describe('mpd utils', () => {
                 expect(calculatePeriodStart(manifest.MPD.Period[0])).toEqual(0);
             });
         });
+        describe('when period.start is absent but periods have durations', () => {
+            it('derives the start from the preceding period durations', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+</MPD>`);
+                expect(manifest.MPD.Period.map(calculatePeriodStart)).toEqual([
+                    0, 888.053, 1776.106,
+                ]);
+            });
+            it('inherits the previous start when the previous period has no duration', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+  <Period/>
+</MPD>`);
+                // The first period has neither start nor duration, so the
+                // second period cannot advance and inherits start 0.
+                expect(calculatePeriodStart(manifest.MPD.Period[1])).toEqual(0);
+            });
+        });
     });
     describe('getPeriodAtTime', () => {
         it('returns the period spanning the given presentation time', () => {
@@ -331,6 +356,18 @@ describe('mpd utils', () => {
                 expect(calculateDuration(manifest)).toBe(50);
             });
         });
+        describe('when only per-period durations are present', () => {
+            it('sums the period durations across the presentation', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+</MPD>`);
+                expect(calculateDuration(manifest)).toBeCloseTo(2664.159, 3);
+            });
+        });
         describe('when MPD type is dynamic', () => {
             it('returns Infinity for live presentations', () => {
                 // language=XML

package/dist/unit/types/current/track/filters/resourceTypeFilter.test.js

@@ -22,6 +22,13 @@ describe('canPlayMimeType', () => {
         expect(canPlayMimeType({ capabilities }, metadata)).toBe(true);
         expect(capabilities.canPlayTypeMse).toHaveBeenCalledWith('audio/mp4; codecs="opus"');
     });
+    it('supports WebM when the browser reports support', () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.mimeType = 'video/webm; codecs="vp9"';
+        expect(canPlayMimeType({ capabilities }, metadata)).toBe(true);
+        expect(capabilities.canPlayTypeMse).toHaveBeenCalledWith('video/webm; codecs="vp9"');
+    });
     it('returns false for null mime type', () => {
         capabilities.canPlayTypeMse.and.returnValue(true);
         const metadata = createEmptyMediaQualityMetadata();