@amazon/vinyl 1.0.0

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

@@ -0,0 +1,204 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDefaultMediaTimelineTransformer, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+import { MockCapabilities, MockDrmController, } from '@amazon/vinyl/vinylTestUtil';
+function createQuality(overrides) {
+    return {
+        metadata: { ...createEmptyMediaQualityMetadata(), ...overrides },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+describe('createDefaultMediaTimelineTransformer', () => {
+    let capabilities;
+    let drmController;
+    beforeEach(() => {
+        capabilities = new MockCapabilities();
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        capabilities.sampleRate = 192_000;
+        drmController = new MockDrmController();
+        drmController.isSupported.and.resolveTo({
+            supported: true,
+            persistentState: false,
+        });
+    });
+    function createDeps(timeline, preferredAudioLanguage = null) {
+        return {
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options: data({ preferredAudioLanguage }),
+        };
+    }
+    it('passes through playable qualities', async () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'q1',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
+        expect(result.periods[0].qualities.length).toBe(1);
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('q1');
+    });
+    it('filters out unsupported mime types', async () => {
+        capabilities.canPlayTypeMse.and.callFake((type) => type.includes('mp4a'));
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4; codecs="mp4a.40.2"',
+                            qualityId: 'aac',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4; codecs="flac"',
+                            qualityId: 'flac',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
+        expect(result.periods[0].qualities.length).toBe(1);
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('aac');
+    });
+    it('filters out unsupported key systems', async () => {
+        drmController.isSupported.and.callFake((metadata) => Promise.resolve(metadata.contentProtections.length === 0
+            ? { supported: true, persistentState: false }
+            : { supported: false, persistentState: false }));
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'unprotected',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'protected',
+                            contentProtections: [
+                                { keySystem: 'com.widevine.alpha' },
+                            ],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
+        expect(result.periods[0].qualities.length).toBe(1);
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('unprotected');
+    });
+    it('filters by preferred language', async () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            lang: 'en',
+                            qualityId: 'en',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            lang: 'ja',
+                            qualityId: 'ja',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline, 'en')).value;
+        expect(result.periods[0].qualities.length).toBe(1);
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('en');
+    });
+    it('re-evaluates when language preference changes', async () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            lang: 'en',
+                            qualityId: 'en',
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            lang: 'ja',
+                            qualityId: 'ja',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const options = data({
+            preferredAudioLanguage: 'en',
+        });
+        const deps = {
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options,
+        };
+        const transformed = createDefaultMediaTimelineTransformer(deps);
+        const unsub = transformed.onData(() => { });
+        let result = await transformed.value;
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('en');
+        options.value = { preferredAudioLanguage: 'ja' };
+        result = await transformed.value;
+        expect(result.periods[0].qualities[0].metadata.qualityId).toBe('ja');
+        unsub();
+    });
+    it('preserves minBufferTime', async () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 5,
+        };
+        const result = await createDefaultMediaTimelineTransformer(createDeps(timeline)).value;
+        expect(result.minBufferTime).toBe(5);
+    });
+});

package/dist/unit/types/current/streaming/loudness/LoudnessNormalizationControllerImpl.test.d.ts

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

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

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

package/dist/unit/types/current/streaming/loudness/LoudnessNormalizationControllerImpl.test.js

@@ -0,0 +1,108 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LoudnessNormalizationControllerImpl, defaultLoudnessNormalizationControllerImplOptions, } from '@amazon/vinyl';
+import { data } from '@amazon/vinyl-observable';
+describe('LoudnessNormalizationControllerImpl', () => {
+    let controller;
+    let options;
+    beforeEach(() => {
+        options = data(defaultLoudnessNormalizationControllerImplOptions);
+        controller = new LoudnessNormalizationControllerImpl({ options });
+    });
+    describe('when calculating gain values', () => {
+        it('gain is calculated correctly for tracks louder than target', () => {
+            controller.setTrackLoudness(-9); // 5dB louder than target
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            const gain = controller.gain;
+            expect(gain).toBeCloseTo(0.316, 3); // 10^(-5/10) ≈ 0.316
+        });
+        it('gain is set to 1.0 when track is quieter than target', () => {
+            controller.setTrackLoudness(-16); // 2dB quieter than target
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            const gain = controller.gain;
+            expect(gain).toBeCloseTo(1.0, 3);
+        });
+        it('gain is limited by maxGainDb setting', () => {
+            controller.setTrackLoudness(-4); // 10dB louder than target
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 6, // Limit to 6dB reduction
+            };
+            const gain = controller.gain;
+            expect(gain).toBeCloseTo(0.251, 3); // 10^(-6/10) ≈ 0.251
+        });
+        it('gain is set to 1.0 when loudness normalization is disabled', () => {
+            controller.setTrackLoudness(-9);
+            options.value = {
+                enabled: false,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            const gain = controller.gain;
+            expect(gain).toBe(1.0);
+        });
+        it('gain is set to 1.0 when track loudness is null', () => {
+            controller.setTrackLoudness(null);
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            const gain = controller.gain;
+            expect(gain).toBe(1.0);
+        });
+    });
+    describe('when handling change events', () => {
+        it('change event is emitted when gain changes', () => {
+            const changeListener = jasmine.createSpy('changeListener');
+            controller.on('change', changeListener);
+            controller.setTrackLoudness(-9);
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            expect(changeListener).toHaveBeenCalled();
+        });
+        it('change event is not emitted when gain remains the same', () => {
+            controller.setTrackLoudness(-9);
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            const changeListener = jasmine.createSpy('changeListener');
+            controller.on('change', changeListener);
+            // Update config with the same values
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            expect(changeListener).not.toHaveBeenCalled();
+        });
+        it('gain is refreshed when track loudness is set', () => {
+            // Set up config first
+            options.value = {
+                enabled: true,
+                targetLufs: -14,
+                maxGainDb: 10,
+            };
+            expect(controller.gain).toBe(1.0); // Initial gain
+            // Set track loudness - should trigger gain update
+            controller.setTrackLoudness(-9); // 5dB louder than target
+            expect(controller.gain).toBeCloseTo(0.316, 3); // Should be updated
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, filterTimelineQualities, filterTimelineQualitiesAsync, } from '@amazon/vinyl';
+function createQuality(contentType, bandwidth) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            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),
+                ],
+            },
+        ],
+        minBufferTime: 2,
+    };
+    it('filters qualities by predicate', () => {
+        const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
+            throw new Error('empty');
+        }, timeline);
+        expect(result.periods[0].qualities.length).toBe(2);
+        expect(result.periods[0].qualities.every((q) => q.metadata.contentType === 'audio')).toBeTrue();
+    });
+    it('preserves minBufferTime', () => {
+        const result = filterTimelineQualities(() => true, () => {
+            throw new Error('empty');
+        }, 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');
+    });
+});
+describe('filterTimelineQualitiesAsync', () => {
+    const timeline = {
+        periods: [
+            {
+                startTime: 0,
+                endTime: 10,
+                qualities: [
+                    createQuality('audio', 128000),
+                    createQuality('video', 500000),
+                ],
+            },
+        ],
+        minBufferTime: 2,
+    };
+    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');
+    });
+    it('preserves minBufferTime', async () => {
+        const result = await filterTimelineQualitiesAsync(() => Promise.resolve(true), () => {
+            throw new Error('empty');
+        }, 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');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,171 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, createLanguageFilter, filterTimelineQualities, } from '@amazon/vinyl';
+import { throwLanguagesUnsupported } from '@amazon/vinyl';
+function createQuality(contentType, lang) {
+    return {
+        metadata: {
+            ...createEmptyMediaQualityMetadata(),
+            contentType,
+            lang,
+        },
+        getSegment: () => Promise.resolve(null),
+    };
+}
+function applyLanguageFilter(timeline, preferredLanguage, contentType) {
+    const filter = createLanguageFilter(preferredLanguage, contentType);
+    if (!filter)
+        return timeline;
+    return filterTimelineQualities(filter, throwLanguagesUnsupported, timeline);
+}
+describe('createLanguageFilter', () => {
+    it('returns null when preferredLanguage is null', () => {
+        expect(createLanguageFilter(null, 'audio')).toBeNull();
+    });
+    it('returns a filter predicate when preferredLanguage is set', () => {
+        expect(createLanguageFilter('en', 'audio')).toEqual(jasmine.any(Function));
+    });
+    it('filters to matching language', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [
+                        createQuality('audio', 'en'),
+                        createQuality('audio', 'ja'),
+                        createQuality('video', null),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        expect(result.periods[0].qualities.length).toBe(2); // en audio + video
+    });
+    it('keeps qualities without language tag', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [
+                        createQuality('audio', 'en'),
+                        createQuality('audio', null),
+                        createQuality('audio', 'ja'),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        expect(result.periods[0].qualities.length).toBe(2); // en + null
+    });
+    it('preserves minBufferTime', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [createQuality('audio', 'en')],
+                },
+            ],
+            minBufferTime: 5,
+        };
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        expect(result.minBufferTime).toBe(5);
+    });
+    it('does not filter non-matching content types', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [
+                        createQuality('audio', 'en'),
+                        createQuality('audio', 'ja'),
+                        createQuality('video', null),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        expect(result.periods[0].qualities.some((q) => q.metadata.contentType === 'video')).toBeTrue();
+    });
+    it('keeps all when no language matches in a period', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [createQuality('audio', 'ja')],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        // 'xx' doesn't match 'ja', so all kept
+        const result = applyLanguageFilter(timeline, 'xx', 'audio');
+        expect(result.periods[0].qualities.length).toBe(1);
+    });
+    it('filters per period independently when periods have different languages', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [
+                        createQuality('audio', 'en'),
+                        createQuality('audio', 'ja'),
+                    ],
+                },
+                {
+                    startTime: 10,
+                    endTime: 20,
+                    qualities: [
+                        createQuality('audio', 'fr'),
+                        createQuality('audio', 'de'),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        // 'en' matches period 1 but not period 2
+        // Period 1: filtered to 'en' only
+        // Period 2: no match, so all kept (fr + de)
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        expect(result.periods[0].qualities.length).toBe(1);
+        expect(result.periods[0].qualities[0].metadata.lang).toBe('en');
+        expect(result.periods[1].qualities.length).toBe(2);
+    });
+    it('keeps all qualities when no quality in the period has a language', () => {
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 10,
+                    qualities: [
+                        createQuality('audio', 'en'),
+                        createQuality('audio', 'ja'),
+                    ],
+                },
+                {
+                    startTime: 10,
+                    endTime: 20,
+                    qualities: [
+                        createQuality('audio', null),
+                        createQuality('video', null),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+        };
+        const result = applyLanguageFilter(timeline, 'en', 'audio');
+        // Period 1: filtered to 'en'
+        expect(result.periods[0].qualities.length).toBe(1);
+        // Period 2: no audio qualities have lang, all kept
+        expect(result.periods[1].qualities.length).toBe(2);
+    });
+});

package/dist/unit/types/current/streaming/util/segment.test.d.ts

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

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

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