@amazon/vinyl 1.1.1 → 1.2.1

package/dist/unit/types/current/drm/DrmControllerImpl.test.js

@@ -4,7 +4,7 @@
  */
 import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
-import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, utf16ToUint16Array, } from '@amazon/vinyl-util';
+import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, setUserAgent, utf16ToUint16Array, } from '@amazon/vinyl-util';
 import { flushPromises, implementEventFakes, MockHTMLAudioElement, MockMediaError, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
 import { MockCommonEme, MockCommonMediaKeys, MockCommonMediaKeySession, MockCommonMediaKeySystemAccess, } from '@amazon/vinyl/vinylTestUtil';
 var createSpy = jasmine.createSpy;
@@ -1275,6 +1275,71 @@ describe('DrmControllerImpl', () => {
             ]);
         });
     });
+    describe('ChromeOS verified media path', () => {
+        // ChromeOS only enables the verified media path (VMP) when a video
+        // capability is present, so audio-only content must advertise a dummy
+        // avc1 video capability alongside its audio capability.
+        const chromeOsUserAgent = 'Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        const chromeUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        it('adds avc1 video capabilities for audio content on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            expect(commonEme.requestMediaKeySystemAccess).toHaveBeenCalledOnceWith(DrmKeySystem.WIDEVINE, [
+                {
+                    initDataTypes: ['cenc'],
+                    audioCapabilities: [
+                        {
+                            contentType: 'audio/mp4',
+                            encryptionScheme: 'cenc',
+                            robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                        },
+                    ],
+                    videoCapabilities: [
+                        {
+                            contentType: 'video/mp4; codecs="avc1.4d401f"',
+                            robustness: DrmRobustness.SW_SECURE_DECODE,
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('does not add video capabilities for audio content off ChromeOS', async () => {
+            setUserAgent(chromeUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toBeUndefined();
+        });
+        it('does not alter video content capabilities on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'video',
+                mimeType: 'video/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toEqual([
+                {
+                    contentType: 'video/mp4',
+                    encryptionScheme: 'cenc',
+                    robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                },
+            ]);
+            expect(config.audioCapabilities).toBeUndefined();
+        });
+    });
     describe('when a session has been created', () => {
         beforeEach(async () => {
             drmController.setBufferingDrmInfo(drmInfo);

package/dist/unit/types/current/streaming/ManifestControllerImpl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ManifestControllerImpl.test.d.ts.map

package/dist/unit/types/current/streaming/ManifestControllerImpl.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifestControllerImpl.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/streaming/ManifestControllerImpl.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,197 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from '@amazon/vinyl-util';
+import { ManifestControllerImpl } from '@amazon/vinyl';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+describe('ManifestControllerImpl', () => {
+    let manifestProvider;
+    beforeEach(() => {
+        manifestProvider = createSpy('manifestProvider');
+        manifestProvider.and.resolveTo(mockHlsManifestData);
+    });
+    function createManifestController() {
+        return new ManifestControllerImpl({ manifestProvider });
+    }
+    it('has a toStringTag', () => {
+        const controller = createManifestController();
+        expect(String(controller)).toContain('ManifestControllerImpl');
+    });
+    it('has a logPrefix', () => {
+        const controller = createManifestController();
+        expect(controller.logPrefix).toBe('ManifestControllerImpl');
+    });
+    describe('refresh', () => {
+        it('reloads the manifest', () => {
+            const controller = createManifestController();
+            controller.refresh();
+            expect(manifestProvider).toHaveBeenCalledTimes(2);
+        });
+        it('notifies observers', () => {
+            const controller = createManifestController();
+            const observer = createSpy('observer');
+            controller.onData(observer);
+            observer.calls.reset();
+            controller.refresh();
+            expect(observer).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('value', () => {
+        it('resolves to the manifest data', async () => {
+            const controller = createManifestController();
+            const result = await controller.value;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+            expect(result.baseUrl).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('getValue', () => {
+        it('returns the same as value', () => {
+            const controller = createManifestController();
+            expect(controller.getValue()).toBe(controller.value);
+        });
+    });
+    describe('changeId', () => {
+        it('increments when manifest is refreshed', () => {
+            const controller = createManifestController();
+            const initial = controller.changeId;
+            controller.refresh();
+            expect(controller.changeId).toBe(initial + 1);
+        });
+    });
+    describe('pick', () => {
+        it('returns a sub-observable', () => {
+            const controller = createManifestController();
+            const thenPick = controller.pick('then');
+            expect(thenPick.value).toEqual(jasmine.any(Function));
+        });
+    });
+    describe('map', () => {
+        it('returns a mapped observable', async () => {
+            const controller = createManifestController();
+            const mapped = controller.map(async (promise) => {
+                const data = await promise;
+                return data.baseUrl;
+            });
+            expect(await mapped.value).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('disposed', () => {
+        it('returns false before dispose', () => {
+            const controller = createManifestController();
+            expect(controller.disposed).toBe(false);
+        });
+        it('returns true after dispose', () => {
+            const controller = createManifestController();
+            controller.dispose();
+            expect(controller.disposed).toBe(true);
+        });
+    });
+    describe('value - pending', () => {
+        it('resolves pending manifest', async () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const valuePromise = controller.value;
+            deferred.resolve(mockHlsManifestData);
+            const result = await valuePromise;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+        });
+    });
+    describe('when manifest provider rejects', () => {
+        it('does not cause an unhandled rejection', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            createManifestController();
+            await flushPromises();
+            expectNothing();
+        });
+        it('rejects the value', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejectedWithError('expected');
+        });
+    });
+    describe('error', () => {
+        it('is null when manifest loads successfully', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            expect(controller.error).toBeNull();
+        });
+        it('is set when manifest provider rejects', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).toEqual(jasmine.objectContaining({ message: 'test error' }));
+        });
+        it('is cleared after refresh', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).not.toBeNull();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.refresh();
+            expect(controller.error).toBeNull();
+        });
+    });
+    describe('reset', () => {
+        it('refreshes manifest when there was an error', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(2);
+        });
+        it('does nothing when no error occurred', () => {
+            const controller = createManifestController();
+            const initialCallCount = manifestProvider.calls.count();
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(initialCallCount);
+        });
+    });
+    describe('load span metrics', () => {
+        it('dispatches loadSpanMeasured on the initial manifest fetch', async () => {
+            const controller = createManifestController();
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            await controller.value;
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({
+                kind: 'manifest',
+                startTime: jasmine.any(Number),
+                endTime: jasmine.any(Number),
+            }));
+        });
+        it('does not re-measure on refresh', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            controller.refresh();
+            await controller.value;
+            await flushPromises();
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('reports listeners', () => {
+            const controller = createManifestController();
+            expect(controller.hasAnyListeners()).toBeFalse();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeFalse();
+            controller.on('loadSpanMeasured', createSpy('loadSpanMeasured'));
+            expect(controller.hasAnyListeners()).toBeTrue();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeTrue();
+        });
+    });
+    describe('dispose', () => {
+        it('aborts current request', () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const abort = manifestProvider.calls.first()
+                .args[0];
+            controller.dispose();
+            expect(abort.aborted()).toBeTrue();
+        });
+    });
+});

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

@@ -22,6 +22,7 @@ describe('getMediaPeriodAtTime', () => {
     const timeline = {
         periods: [period1, period2, period3],
         minBufferTime: 2,
+        getDuration: () => Promise.resolve(30),
     };
     it('returns the first period for time 0', () => {
         expect(getMediaPeriodAtTime(timeline, 0)).toBe(period1);
@@ -42,7 +43,11 @@ describe('getMediaPeriodAtTime', () => {
         expect(getMediaPeriodAtTime(timeline, -1)).toBeNull();
     });
     it('returns null for empty timeline', () => {
-        const empty = { periods: [], minBufferTime: 0 };
+        const empty = {
+            periods: [],
+            minBufferTime: 0,
+            getDuration: () => Promise.resolve(0),
+        };
         expect(getMediaPeriodAtTime(empty, 5)).toBeNull();
     });
 });

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

@@ -500,6 +500,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();
@@ -521,6 +522,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             const spy = createEventSpy(track, 'qualitiesChange');
@@ -555,6 +557,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             };
             setTimeline(timeline);
             track = createTrack();
@@ -587,6 +590,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();

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

@@ -76,6 +76,7 @@ describe('SegmentControllerImpl', () => {
                 },
             ],
             minBufferTime: 10,
+            getDuration: () => Promise.resolve(100),
         };
         const mockQualitySelector = {
             selectQuality: () => 0,
@@ -230,6 +231,7 @@ describe('SegmentControllerImpl', () => {
                         },
                     ],
                     minBufferTime: 10,
+                    getDuration: () => Promise.resolve(110),
                 };
                 timelineData.value = Promise.resolve(extendedTimeline);
                 await fillPrefetch();
@@ -330,6 +332,7 @@ describe('SegmentControllerImpl', () => {
                     },
                 ],
                 minBufferTime: 10,
+                getDuration: () => Promise.resolve(100),
             });
             // segmentController is for 'audio', but only 'video' qualities exist
             expect(await segmentController.getSegment(5)).toBeNull();
@@ -582,39 +585,6 @@ describe('SegmentControllerImpl', () => {
             expect(segmentController.startTime).toBe(4);
         });
     });
-    describe('duration', () => {
-        it('delegates to the media timeline', async () => {
-            expect(await segmentController.getDuration()).toBe(100);
-        });
-        it('returns null for empty timeline', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('returns null when last period has Infinity endTime', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [
-                    {
-                        startTime: 0,
-                        endTime: Infinity,
-                        qualities: [],
-                    },
-                ],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('uses getDuration from timeline when provided', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-                getDuration: () => Promise.resolve(42),
-            });
-            expect(await segmentController.getDuration()).toBe(42);
-        });
-    });
     describe('fetchedTime', () => {
         it('returns the number of seconds currently prefetched', async () => {
             segmentController.configure(defaultConfigOptions);

package/dist/unit/types/current/streaming/abr/QualitySelectorImpl.test.js

@@ -566,6 +566,79 @@ describe('QualitySelectorImpl', () => {
             expect(selector.selectQuality(videoQualities, videoState)).toEqual(0);
         });
     });
+    describe('maxBandwidth', () => {
+        const qualities = [
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 1000,
+                bandwidthTotal: 1000,
+                qualityId: '0',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 500,
+                bandwidthTotal: 500,
+                qualityId: '1',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 100,
+                bandwidthTotal: 100,
+                qualityId: '2',
+            },
+        ];
+        const prefetchState = {
+            fetchedTime: 0,
+            previousQuality: null,
+            active: false,
+        };
+        beforeEach(() => {
+            // Plenty of bandwidth for the highest quality.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 5000;
+        });
+        it('caps the selectable quality to the configured bandwidth', () => {
+            options.value = { ...options.value, maxBandwidth: 500 };
+            // Highest quality at or below the cap is index 1 (500).
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('falls back to the lowest quality when all exceed the cap', () => {
+            options.value = { ...options.value, maxBandwidth: 50 };
+            // No quality fits — selectQuality falls back to the last (lowest) entry.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('pins to the lowest quality when set to 0', () => {
+            options.value = { ...options.value, maxBandwidth: 0 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('treats null as no cap', () => {
+            options.value = { ...options.value, maxBandwidth: null };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+        it('does not raise the bandwidth budget above the network estimate', () => {
+            // Network estimate is well below the cap; cap should not raise it.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 600;
+            options.value = { ...options.value, maxBandwidth: 100_000 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('has no effect when strategy is LOWEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.LOWEST,
+                maxBandwidth: 100_000,
+            };
+            // LOWEST always returns the last index, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(qualities.length - 1);
+        });
+        it('has no effect when strategy is HIGHEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.HIGHEST,
+                maxBandwidth: 50,
+            };
+            // HIGHEST always returns 0, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+    });
     describe('toString', () => {
         it('returns a string', () => {
             expect(selector.toString()).toContain('QualitySelectorImpl');

package/dist/unit/types/current/streaming/buffering/BufferingController.test.js

@@ -4,7 +4,7 @@
  */
 import { flushPromises, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
 import { MockMediaSourceController, MockPlaybackController, MockSegmentController, MockSourceBufferController, } from '@amazon/vinyl/vinylTestUtil';
-import { BufferingControllerImpl, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, DURATION_PADDING, getSourceBufferQuota, LIVE_DURATION, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, } from '@amazon/vinyl';
+import { BufferingControllerImpl, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, getSourceBufferQuota, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, } from '@amazon/vinyl';
 import { Abort, AbortError, Deferred, floorToNearest, LogLevel, } from '@amazon/vinyl-util';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
 var any = jasmine.any;
@@ -86,7 +86,6 @@ describe('BufferingControllerImpl', () => {
     }
     beforeEach(() => {
         mediaSourceController = new MockMediaSourceController();
-        mediaSourceController.duration = Number.NaN;
         playbackController = new MockPlaybackController();
         segmentController = new MockSegmentController();
         segmentController.getSegment.and.callFake((time) => {
@@ -512,45 +511,6 @@ describe('BufferingControllerImpl', () => {
             expect(bufferingController.getBufferedTime()).toBe(10);
         });
     });
-    describe('duration', () => {
-        beforeEach(() => {
-            bufferingController = createBufferingController();
-            bufferingController.activate();
-        });
-        describe('when the media source is open and the segment controller is not updating', () => {
-            it('is set to the segment controller provided value', async () => {
-                segmentController.getDuration.and.resolveTo(33);
-                await open();
-                expect(mediaSourceController.duration).toEqual(33 + DURATION_PADDING);
-            });
-            describe('when segment controller duration resolves to null', () => {
-                it('sets mediaSource duration to LIVE_DURATION', async () => {
-                    segmentController.getDuration.and.resolveTo(null);
-                    await open();
-                    expect(mediaSourceController.duration).toEqual(LIVE_DURATION);
-                });
-            });
-        });
-        describe('when segment controller emits a change event', () => {
-            it('refreshes duration', async () => {
-                segmentController.getDuration.and.resolveTo(42);
-                await open();
-                expect(mediaSourceController.duration).toEqual(42 + DURATION_PADDING);
-                segmentController.getDuration.and.resolveTo(54);
-                segmentController.dispatch('change', {});
-                await nextPollImmediate();
-                expect(mediaSourceController.duration).toEqual(54 + DURATION_PADDING);
-            });
-            describe('and mediaSource is not open', () => {
-                it('does nothing', () => {
-                    // Closed
-                    segmentController.getDuration.and.resolveTo(52);
-                    segmentController.dispatch('change', {});
-                    expect(mediaSourceController.duration).toBeNaN();
-                });
-            });
-        });
-    });
     describe('playbackQuality', () => {
         // The time to simulate a quality change from q1 to q2:
         let changeTime;