@amazon/vinyl 3.1.0 → 3.2.0

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

@@ -7,7 +7,7 @@ import { createMockDashDependencies, } from '@amazon/vinyl/vinylTestUtil';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
 import { flushPromises } from '@amazon/vinyl-util/browserTestUtil';
 import { externalDependencies } from '@amazon/vinyl-di';
-import { Abort, MediaUnsupportedError } from '@amazon/vinyl-util';
+import { Abort } from '@amazon/vinyl-util';
 var any = jasmine.any;
 describe('MseTrack', () => {
     useMockLogger();
@@ -585,11 +585,12 @@ describe('MseTrack', () => {
             expect(track.qualities).toEqual([qualityMetadata]);
             expect(track.qualitiesUnfiltered).toEqual([qualityMetadata]);
         });
-        it('fails fast when a required content type is entirely filtered out', async () => {
-            // contentTypes (from the manifest) is {audio, video}, but the
-            // transformed timeline has only a video quality — audio was fully
-            // filtered. The audio stream could never create a source buffer, so
-            // the track must fail rather than stall on the readyToAppend wait.
+        it('plays the surviving content type when another is entirely filtered out', async () => {
+            // The content types now come from the FILTERED timeline: with every
+            // audio rendition filtered, only 'video' is required. No audio stream
+            // is created, so the load is never stranded waiting for an audio
+            // source buffer that will never arrive, and the track does not error.
+            deps.contentTypesValue.value = Promise.resolve(new Set(['video']));
             const videoQuality = {
                 ...createEmptyMediaQualityMetadata(),
                 contentType: 'video',
@@ -614,8 +615,10 @@ describe('MseTrack', () => {
             });
             track = createTrack();
             await flushPromises();
-            expect(track.error).toEqual(any(MediaUnsupportedError));
-            expect(track.error.code).toBe('no-playable-audio');
+            expect(track.error).toBeNull();
+            expect(track.contentTypes).toEqual(new Set(['video']));
+            expect(getStream('video')).not.toBeNull();
+            expect(getStream('audio')).toBeNull();
         });
         it('reads qualities from the filtered timeline but qualitiesUnfiltered from the raw one', async () => {
             // The transformed timeline is filtered (e.g. by preferred audio

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

@@ -13,81 +13,87 @@ function createQuality(contentType, bandwidth) {
         getSegment: () => Promise.resolve(null),
     };
 }
-describe('filterTimelineQualities', () => {
-    const timeline = {
-        periods: [
-            {
-                startTime: 0,
-                endTime: 10,
-                qualities: [
-                    createQuality('audio', 128000),
-                    createQuality('audio', 256000),
-                    createQuality('video', 500000),
-                ],
-            },
-        ],
+function timelineOf(qualities) {
+    return {
+        periods: [{ startTime: 0, endTime: 10, qualities: [...qualities] }],
         minBufferTime: 2,
         getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(Infinity),
     };
+}
+function contentTypesOf(timeline) {
+    return new Set(timeline.periods[0].qualities.map((q) => q.metadata.contentType));
+}
+function throwEmpty() {
+    throw new Error('no qualities');
+}
+describe('filterTimelineQualities', () => {
+    const timeline = timelineOf([
+        createQuality('audio', 128000),
+        createQuality('audio', 256000),
+        createQuality('video', 500000),
+    ]);
     it('returns the timeline unchanged when the filter is null', () => {
         // A null predicate (e.g. no language preference) is a no-op.
-        const result = filterTimelineQualities(null, () => {
-            throw new Error('empty');
-        }, timeline);
+        const result = filterTimelineQualities(null, throwEmpty, timeline);
         expect(result).toBe(timeline);
     });
-    it('filters qualities by predicate', () => {
-        const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
-            throw new Error('empty');
-        }, timeline);
+    it('filters qualities by predicate while keeping every present stream', () => {
+        const result = filterTimelineQualities((q) => q.bandwidth !== 256000, throwEmpty, timeline);
         expect(result.periods[0].qualities.length).toBe(2);
-        expect(result.periods[0].qualities.every((q) => q.metadata.contentType === 'audio')).toBeTrue();
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
     it('preserves minBufferTime', () => {
-        const result = filterTimelineQualities(() => true, () => {
-            throw new Error('empty');
-        }, timeline);
+        const result = filterTimelineQualities(() => true, throwEmpty, timeline);
         expect(result.minBufferTime).toBe(2);
     });
     it('throws when filtering removes all qualities', () => {
-        expect(() => filterTimelineQualities(() => false, () => {
-            throw new Error('no qualities');
-        }, timeline)).toThrowError('no qualities');
+        expect(() => filterTimelineQualities(() => false, throwEmpty, timeline)).toThrowError('no qualities');
+    });
+    it('throws when filtering drops a present video stream to zero', () => {
+        expect(() => filterTimelineQualities((q) => q.contentType === 'audio', throwEmpty, timeline)).toThrowError('no qualities');
+    });
+    it('throws when filtering drops a present audio stream to zero', () => {
+        expect(() => filterTimelineQualities((q) => q.contentType === 'video', throwEmpty, timeline)).toThrowError('no qualities');
+    });
+    it('does not throw when losing only an optional text sidecar stream', () => {
+        const withText = timelineOf([
+            createQuality('audio', 128000),
+            createQuality('video', 500000),
+            createQuality('text', 1000),
+        ]);
+        const result = filterTimelineQualities((q) => q.contentType !== 'text', throwEmpty, withText);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
 });
 describe('filterTimelineQualitiesAsync', () => {
-    const timeline = {
-        periods: [
-            {
-                startTime: 0,
-                endTime: 10,
-                qualities: [
-                    createQuality('audio', 128000),
-                    createQuality('video', 500000),
-                ],
-            },
-        ],
-        minBufferTime: 2,
-        getAdBreaks: () => Promise.resolve([]),
-        getDuration: () => Promise.resolve(Infinity),
-    };
-    it('filters qualities by async predicate', async () => {
-        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType === 'audio'), () => {
-            throw new Error('empty');
-        }, timeline);
-        expect(result.periods[0].qualities.length).toBe(1);
-        expect(result.periods[0].qualities[0].metadata.contentType).toBe('audio');
+    const timeline = timelineOf([
+        createQuality('audio', 128000),
+        createQuality('audio', 256000),
+        createQuality('video', 500000),
+    ]);
+    it('filters qualities by async predicate while keeping every present stream', async () => {
+        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.bandwidth !== 256000), throwEmpty, timeline);
+        expect(result.periods[0].qualities.length).toBe(2);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
     it('preserves minBufferTime', async () => {
-        const result = await filterTimelineQualitiesAsync(() => Promise.resolve(true), () => {
-            throw new Error('empty');
-        }, timeline);
+        const result = await filterTimelineQualitiesAsync(() => Promise.resolve(true), throwEmpty, timeline);
         expect(result.minBufferTime).toBe(2);
     });
     it('throws when filtering removes all qualities', async () => {
-        await expectAsync(filterTimelineQualitiesAsync(() => Promise.resolve(false), () => {
-            throw new Error('no qualities');
-        }, timeline)).toBeRejectedWithError('no qualities');
+        await expectAsync(filterTimelineQualitiesAsync(() => Promise.resolve(false), throwEmpty, timeline)).toBeRejectedWithError('no qualities');
+    });
+    it('throws when filtering drops a present video stream to zero', async () => {
+        await expectAsync(filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType === 'audio'), throwEmpty, timeline)).toBeRejectedWithError('no qualities');
+    });
+    it('does not throw when losing only an optional text sidecar stream', async () => {
+        const withText = timelineOf([
+            createQuality('audio', 128000),
+            createQuality('video', 500000),
+            createQuality('text', 1000),
+        ]);
+        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType !== 'text'), throwEmpty, withText);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
 });

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

@@ -192,6 +192,27 @@ describe('withinAudioSampleRateRange minSampleRate floor', () => {
         expect(withinMin(mid, 1, [low, mid])).toBe(true);
         expect(withinMin(low, 0, [low, mid])).toBe(false);
     });
+    it('keeps the highest when every rate (of three) is below the floor', () => {
+        const low = audioQuality([16_000]);
+        const mid = audioQuality([24_000]);
+        const high = audioQuality([32_000]);
+        expect(withinMin(high, 2, [low, mid, high])).toBe(true);
+        expect(withinMin(mid, 1, [low, mid, high])).toBe(false);
+        expect(withinMin(low, 0, [low, mid, high])).toBe(false);
+    });
+    it('keeps the highest below-floor rate when no platform max is reported', () => {
+        // No AudioContext rate, so the floor is the only bound; with every rate
+        // below it, the highest is kept as the fallback.
+        capabilities.sampleRate = null;
+        const low = audioQuality([16_000]);
+        const high = audioQuality([32_000]);
+        expect(withinMin(high, 1, [low, high])).toBe(true);
+        expect(withinMin(low, 0, [low, high])).toBe(false);
+    });
+    it('keeps a single audio rendition below the floor', () => {
+        const only = audioQuality([24_000]);
+        expect(withinMin(only, 0, [only])).toBe(true);
+    });
     it('ignores non-audio qualities in the floor fallback', () => {
         const audio = audioQuality([24_000]); // below the floor
         const video = createEmptyMediaQualityMetadata();
@@ -202,3 +223,57 @@ describe('withinAudioSampleRateRange minSampleRate floor', () => {
         expect(withinMin(video, 1, [audio, video])).toBe(true);
     });
 });
+// The floor and ceiling are soft together: when renditions straddle an empty
+// band (some below the floor, some above the ceiling, none in between) neither
+// bound alone must strand audio.
+describe('withinAudioSampleRateRange straddling an empty band', () => {
+    let capabilities;
+    beforeEach(() => {
+        // The soft ceiling is a non-Firefox behavior; Firefox's 48kHz cap is
+        // hard (covered above), so pin a non-Firefox UA to exercise the fallback.
+        setUserAgent('Chrome');
+        capabilities = new MockCapabilities();
+        // Ceiling at 48kHz; floor at 44.1kHz → acceptable band is [44.1k, 48k].
+        capabilities.sampleRate = 48_000;
+    });
+    function audioQuality(rate) {
+        const quality = createEmptyMediaQualityMetadata();
+        quality.contentType = 'audio';
+        quality.audioSamplingRate = rate;
+        return quality;
+    }
+    function within(metadata, index, array) {
+        return withinAudioSampleRateRange({ capabilities, minSampleRate: 44_100 }, metadata, index, array);
+    }
+    it('keeps the highest decodable rate when one is below the floor and one above the ceiling', () => {
+        const low = audioQuality([22_050]); // below the 44.1kHz floor
+        const high = audioQuality([96_000]); // above the 48kHz ceiling
+        // Empty band → the below-floor rate is decodable and kept; the
+        // above-ceiling rate is dropped, so audio is never stranded.
+        expect(within(low, 0, [low, high])).toBe(true);
+        expect(within(high, 1, [low, high])).toBe(false);
+    });
+    it('keeps the below-floor rate when the ceiling matches the output device rate', () => {
+        // Output device runs at 44.1kHz, so a 48kHz rendition is above the
+        // ceiling while a 22.05kHz rendition is below the floor.
+        capabilities.sampleRate = 44_100;
+        const low = audioQuality([22_050]);
+        const high = audioQuality([48_000]);
+        expect(within(low, 0, [low, high])).toBe(true);
+        expect(within(high, 1, [low, high])).toBe(false);
+    });
+    it('still prefers an in-band rate over the straddle fallback', () => {
+        const low = audioQuality([22_050]); // below floor
+        const mid = audioQuality([44_100]); // in band
+        const high = audioQuality([96_000]); // above ceiling
+        expect(within(mid, 1, [low, mid, high])).toBe(true);
+        expect(within(low, 0, [low, mid, high])).toBe(false);
+        expect(within(high, 2, [low, mid, high])).toBe(false);
+    });
+    it('keeps the lowest when every rate is above the ceiling', () => {
+        const low = audioQuality([88_200]);
+        const high = audioQuality([96_000]);
+        expect(within(low, 0, [low, high])).toBe(true);
+        expect(within(high, 1, [low, high])).toBe(false);
+    });
+});