@amazon/vinyl 1.0.0

package/dist/types/current/track/hls/createHlsFactories.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createMediaSource } from '../../util/media/mediaSource';
+import { createDefaultHlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
+import { MediaSourceControllerImpl, } from '../../streaming/buffering/MediaSourceController';
+import { HlsManifestControllerImpl } from './HlsManifestController';
+import { externalDependencies, validateFactories, } from '@amazon/vinyl-di';
+import { createUrlHlsManifestProvider } from './createUrlHlsManifestProvider';
+import { createHlsContentTypesValue } from './createHlsContentTypesValue';
+import { createHlsContentStreamFactories } from './createHlsContentStreamFactories';
+import { createContentStreamFactory } from '../../streaming/ContentStream';
+import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
+import { createDefaultHlsManifestTransformer } from './createDefaultHlsManifestTransformer';
+import { buildHlsMediaTimeline, } from './buildHlsMediaTimeline';
+import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
+export function createHlsFactories(options) {
+    return (deps) => {
+        return (loadOptions) => {
+            const manifestProvider = loadOptions.manifestProvider ||
+                createUrlHlsManifestProvider(loadOptions.uri, loadOptions.requestInit || undefined);
+            return validateFactories({
+                ...externalDependencies(deps),
+                contentTypesValue: createHlsContentTypesValue,
+                manifestController: () => new HlsManifestControllerImpl(manifestProvider),
+                manifestTransformed: createDefaultHlsManifestTransformer,
+                mediaQualityMetadataResolver: () => createDefaultHlsMediaQualityMetadataResolver(),
+                mediaSourceFactory: () => createMediaSource,
+                mediaSourceController: (deps) => new MediaSourceControllerImpl(deps),
+                segmentRequestInit: () => loadOptions.segmentRequestInit,
+                createContentStreamFactories: createHlsContentStreamFactories(options?.streaming),
+                contentStreamFactory: createContentStreamFactory,
+                qualitySelector: (deps) => new QualitySelectorImpl({
+                    options: deps.options.pick('abr'),
+                }),
+                mediaTimeline: (deps) => deps.manifestTransformed.map(async (manifestPromise) => {
+                    const data = await manifestPromise;
+                    return buildHlsMediaTimeline(deps, data);
+                }),
+                mediaTimelineTransformed: createDefaultMediaTimelineTransformer,
+            });
+        };
+    };
+}

package/dist/types/current/track/hls/createUrlHlsManifestProvider.d.ts

@@ -0,0 +1,21 @@
+import type { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import type { Maybe, ReadonlyAbort, RequestInitOptions } from '@amazon/vinyl-util';
+import type { HlsManifestProvider } from './HlsManifestProvider';
+export declare function createUrlHlsManifestProvider(url: string, requestInit?: RequestInitOptions): HlsManifestProvider;
+export interface FetchMediaPlaylistOptions {
+    /** The variant URI to resolve against the base URL. */
+    readonly uri: string;
+    /** The base URL for resolving relative URIs. */
+    readonly baseUrl: string;
+    /** Variable definitions from the main playlist. */
+    readonly defines: MainPlaylist['defines'];
+    /** Optional request configuration. */
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    /** Optional abort signal. */
+    readonly abort?: Maybe<ReadonlyAbort>;
+}
+/**
+ * Fetches and parses an HLS media playlist from a variant URI.
+ */
+export declare function fetchMediaPlaylist(options: FetchMediaPlaylistOptions): Promise<MediaPlaylist>;
+//# sourceMappingURL=createUrlHlsManifestProvider.d.ts.map

package/dist/types/current/track/hls/createUrlHlsManifestProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUrlHlsManifestProvider.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/createUrlHlsManifestProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE3E,OAAO,KAAK,EACR,KAAK,EACL,aAAa,EACb,kBAAkB,EACrB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,EAER,mBAAmB,EACtB,MAAM,uBAAuB,CAAA;AAE9B,wBAAgB,4BAA4B,CACxC,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,kBAAkB,GACjC,mBAAmB,CA8BrB;AAED,MAAM,WAAW,yBAAyB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAA;IACzC,sCAAsC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAChD,6BAA6B;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;CACxC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACpC,OAAO,EAAE,yBAAyB,GACnC,OAAO,CAAC,aAAa,CAAC,CAMxB"}

package/dist/types/current/track/hls/createUrlHlsManifestProvider.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { parseMainPlaylist, parseMediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { memoize, requestWithRetry, resolveUrl } from '@amazon/vinyl-util';
+export function createUrlHlsManifestProvider(url, requestInit) {
+    return async (abort) => {
+        const mainResponse = await requestWithRetry(url, requestInit, {
+            abort,
+        });
+        const mainText = await mainResponse.text();
+        const mainPlaylist = parseMainPlaylist(mainText);
+        // Use the response URL (after redirects) as the base for resolving
+        // relative URIs in the manifest.
+        const baseUrl = mainResponse.url || url;
+        const getMediaPlaylist = memoize((uri) => fetchMediaPlaylist({
+            uri,
+            baseUrl,
+            defines: mainPlaylist.defines,
+            requestInit,
+            abort,
+        }), (uri) => uri);
+        return {
+            mainPlaylist,
+            baseUrl,
+            getMediaPlaylist,
+        };
+    };
+}
+/**
+ * Fetches and parses an HLS media playlist from a variant URI.
+ */
+export async function fetchMediaPlaylist(options) {
+    const { uri, baseUrl, defines, requestInit, abort } = options;
+    const variantUrl = resolveUrl(uri, baseUrl);
+    const response = await requestWithRetry(variantUrl, requestInit, { abort });
+    const text = await response.text();
+    return parseMediaPlaylist(text, defines);
+}

package/dist/types/current/track/hls/index.d.ts

@@ -0,0 +1,10 @@
+export * from './HlsManifestProvider';
+export * from './createUrlHlsManifestProvider';
+export * from './HlsManifestController';
+export * from './HlsMediaQualityMetadataResolver';
+export * from './createHlsContentTypesValue';
+export * from './createHlsFactories';
+export * from './createHlsContentStreamFactories';
+export * from './HlsTrack';
+export * from './util/hlsSegmentTime';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/current/track/hls/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/index.ts"],"names":[],"mappings":"AAIA,cAAc,uBAAuB,CAAA;AACrC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,yBAAyB,CAAA;AACvC,cAAc,mCAAmC,CAAA;AACjD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,mCAAmC,CAAA;AACjD,cAAc,YAAY,CAAA;AAC1B,cAAc,uBAAuB,CAAA"}

package/dist/types/current/track/hls/index.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2026. Amazon.com, Inc. or its affiliates. All rights reserved.
+ */
+export * from './HlsManifestProvider';
+export * from './createUrlHlsManifestProvider';
+export * from './HlsManifestController';
+export * from './HlsMediaQualityMetadataResolver';
+export * from './createHlsContentTypesValue';
+export * from './createHlsFactories';
+export * from './createHlsContentStreamFactories';
+export * from './HlsTrack';
+export * from './util/hlsSegmentTime';

package/dist/types/current/track/hls/util/hlsByteRangeToMediaRange.d.ts

@@ -0,0 +1,5 @@
+import type { ByteRange } from '@amazon/vinyl-mpd-parser';
+import type { HlsByteRange } from '@amazon/vinyl-hls-parser';
+/** Converts an HLS byte range (`{offset, length}`) to a `ByteRange` (`[start, end]`). */
+export declare function hlsByteRangeToMediaRange(byteRange: HlsByteRange): ByteRange;
+//# sourceMappingURL=hlsByteRangeToMediaRange.d.ts.map

package/dist/types/current/track/hls/util/hlsByteRangeToMediaRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hlsByteRangeToMediaRange.d.ts","sourceRoot":"","sources":["../../../../../../src/track/hls/util/hlsByteRangeToMediaRange.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,yFAAyF;AACzF,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,YAAY,GAAG,SAAS,CAE3E"}

package/dist/types/current/track/hls/util/hlsByteRangeToMediaRange.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Converts an HLS byte range (`{offset, length}`) to a `ByteRange` (`[start, end]`). */
+export function hlsByteRangeToMediaRange(byteRange) {
+    return [byteRange.offset, byteRange.offset + byteRange.length - 1];
+}

package/dist/types/current/track/hls/util/hlsSegmentTime.d.ts

@@ -0,0 +1,10 @@
+import type { HlsSegment } from '@amazon/vinyl-hls-parser';
+import type { MediaSegmentReference } from '../../../streaming/SegmentReference';
+import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
+import { type CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+/**
+ * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
+ * segment list. Cumulative durations are used to compute start/end times.
+ */
+export declare function buildSegmentTimeline(deps: CreateSegmentDataProviderDeps, baseUrl: string, segments: readonly HlsSegment[]): readonly MediaSegmentReference<SegmentDataProvider>[];
+//# sourceMappingURL=hlsSegmentTime.d.ts.map

package/dist/types/current/track/hls/util/hlsSegmentTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hlsSegmentTime.d.ts","sourceRoot":"","sources":["../../../../../../src/track/hls/util/hlsSegmentTime.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAA;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,EAEH,KAAK,6BAA6B,EACrC,MAAM,mCAAmC,CAAA;AAI1C;;;GAGG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,6BAA6B,EACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,SAAS,UAAU,EAAE,GAChC,SAAS,qBAAqB,CAAC,mBAAmB,CAAC,EAAE,CAyBvD"}

package/dist/types/current/track/hls/util/hlsSegmentTime.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSegmentDataProvider, } from '../../../track/createSegmentDataProvider';
+import { hlsByteRangeToMediaRange } from './hlsByteRangeToMediaRange';
+import { resolveUrl } from '@amazon/vinyl-util';
+/**
+ * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
+ * segment list. Cumulative durations are used to compute start/end times.
+ */
+export function buildSegmentTimeline(deps, baseUrl, segments) {
+    const out = new Array(segments.length);
+    let time = 0;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const startTime = time;
+        const endTime = time + seg.duration;
+        const url = resolveUrl(seg.uri, baseUrl);
+        out[i] = {
+            timestampOffset: startTime,
+            startTime,
+            endTime,
+            data: createSegmentDataProvider(deps, {
+                url,
+                mediaRange: seg.byteRange
+                    ? hlsByteRangeToMediaRange(seg.byteRange)
+                    : undefined,
+                reportDownlinkMetrics: true,
+            }),
+        };
+        time = endTime;
+    }
+    return out;
+}

package/dist/types/current/track/mse/MseTrack.d.ts

@@ -0,0 +1,85 @@
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
+import { type ReadonlyRanges, type ReadonlySet } from '@amazon/vinyl-util';
+import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { type Factories } from '@amazon/vinyl-di';
+import type { ContentStream } from '../../streaming/ContentStream';
+import type { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import type { ManifestController } from '../../streaming/ManifestController';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+export type MseTrackDeps = TrackBaseDeps & {
+    readonly contentTypesValue: ContentTypesValue;
+    readonly contentStreamFactory: (contentType: ContentType) => ContentStream;
+    readonly manifestController: ManifestController<unknown>;
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackSource: PlaybackSource;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+};
+/**
+ * An MseTrack uses media source extensions for streaming.
+ */
+export declare class MseTrack extends TrackBase {
+    get [Symbol.toStringTag](): string;
+    protected readonly deps: MseTrackDeps;
+    private readonly streams;
+    private readonly disposeAbort;
+    private lastPreloadOptions;
+    private activateOptions;
+    private readonly allFetchedRanges;
+    private readonly _fetchedRanges;
+    private _contentTypes;
+    private _qualities;
+    private _qualitiesUnfiltered;
+    private timeUpdateSub;
+    private _cachedPeriod;
+    constructor(uri: TrackUri, type: TrackTypeId, dependencyFactories: Factories<MseTrackDeps>);
+    /**
+     * Updates the cached qualities list from the transformed timeline for the current period.
+     */
+    private updateQualities;
+    /**
+     * Updates the cached unfiltered qualities list from the raw timeline for the current period.
+     */
+    private updateQualitiesUnfiltered;
+    /**
+     * Creates and adds a content stream for the given content type.
+     *
+     * @param contentType
+     */
+    protected createStream(contentType: ContentType): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: TrackBaseOptions): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    set contentTypes(value: ReadonlySet<ContentType>);
+    get qualities(): readonly MediaQualityMetadata[] | null;
+    get qualitiesUnfiltered(): readonly MediaQualityMetadata[] | null;
+    get fetchedRanges(): ReadonlyRanges;
+    /**
+     * Clears all fetched fragments and source buffers. Streaming will resume.
+     * This should be called if a change has been made where the user would expect an immediate change,
+     * for example, changing streaming quality from SD to HD.
+     */
+    clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
+     */
+    reset(): void;
+    onActivated(loadOptions: TrackBaseOptions): void;
+    onDeactivated(): void;
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * Calls the specified method on all streams with the provided arguments.
+     */
+    private callOnStreams;
+    private getStream;
+    private clearStreams;
+    get bufferingEnded(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=MseTrack.d.ts.map

package/dist/types/current/track/mse/MseTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MseTrack.d.ts","sourceRoot":"","sources":["../../../../../src/track/mse/MseTrack.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACxB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAMH,KAAK,cAAc,EACnB,KAAK,WAAW,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC/E,OAAO,KAAK,EACR,WAAW,EACX,oBAAoB,EACvB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAClE,OAAO,KAAK,EACR,aAAa,EAGhB,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAA;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAM9D,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG;IACvC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;IAC7C,QAAQ,CAAC,oBAAoB,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,aAAa,CAAA;IAC1E,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAA;IACxD,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB,CAAA;IACrD,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;IACvC,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAC/D,QAAQ,CAAC,wBAAwB,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;CAC7E,CAAA;AAMD;;GAEG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACnC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,mBAA2B,IAAI,EAAE,YAAY,CAAA;IAE7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,kBAAkB,CAA2C;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuB;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAG9B;IACD,OAAO,CAAC,aAAa,CAAsC;IAE3D,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,oBAAoB,CAA+C;IAC3E,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,aAAa,CAA2B;gBAG5C,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,WAAW,EACjB,mBAAmB,EAAE,SAAS,CAAC,YAAY,CAAC;IA2DhD;;OAEG;IACH,OAAO,CAAC,eAAe;IAwBvB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAuBjC;;;;OAIG;IACH,SAAS,CAAC,YAAY,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAsCtD,OAAO,CAAC,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,gBAAgB;IASxE,IAAI,YAAY,IAAI,WAAW,CAAC,WAAW,CAAC,CAE3C;IAED,IAAI,YAAY,CAAC,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,EAO/C;IAED,IAAI,SAAS,IAAI,SAAS,oBAAoB,EAAE,GAAG,IAAI,CAEtD;IAED,IAAI,mBAAmB,IAAI,SAAS,oBAAoB,EAAE,GAAG,IAAI,CAEhE;IAED,IAAI,aAAa,IAAI,cAAc,CAElC;IAED;;;;OAIG;IACH,aAAa;IAKb;;;OAGG;IACH,KAAK,IAAI,IAAI;IAUb,WAAW,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI;IAkChD,aAAa,IAAI,IAAI;IAUrB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAI1E,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAI1E,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAIzE;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,YAAY;IAOpB,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED,OAAO,IAAI,IAAI;CAOlB"}

package/dist/types/current/track/mse/MseTrack.js

@@ -0,0 +1,281 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TrackBase, } from '../../track/TrackBase';
+import { Abort, equalDeep, IntersectionRanges, logDebug, redispatchEvents, } from '@amazon/vinyl-util';
+import { createContainer } from '@amazon/vinyl-di';
+import { getMediaPeriodAtTime, } from '../../streaming/MediaTimeline';
+/**
+ * An MseTrack uses media source extensions for streaming.
+ */
+export class MseTrack extends TrackBase {
+    get [Symbol.toStringTag]() {
+        return 'MseTrack';
+    }
+    streams = [];
+    disposeAbort = new Abort();
+    lastPreloadOptions = null;
+    activateOptions = null;
+    allFetchedRanges = [];
+    _fetchedRanges = new IntersectionRanges(this.allFetchedRanges, { useCache: true });
+    _contentTypes = new Set();
+    _qualities = null;
+    _qualitiesUnfiltered = null;
+    timeUpdateSub = null;
+    _cachedPeriod = null;
+    constructor(uri, type, dependencyFactories) {
+        const depsContainer = createContainer(dependencyFactories);
+        const deps = depsContainer.dependencies;
+        super(uri, type, deps);
+        logDebug(this, 'constructed');
+        const { add } = this.disposer;
+        add(depsContainer);
+        this.deps = deps;
+        add(deps.contentTypesValue.onData((contentTypesPromise) => {
+            contentTypesPromise
+                .then((contentTypes) => {
+                if (this.disposer.disposed)
+                    return;
+                if (equalDeep(this.contentTypes, contentTypes))
+                    return; // no-op
+                this.clearStreams();
+                for (const contentType of contentTypes) {
+                    this.createStream(contentType);
+                }
+                // Sets the content types and dispatches a change event:
+                this.contentTypes = contentTypes;
+            })
+                .catch(this.errorHandler);
+        }));
+        // DRM
+        this.on('streamingQualityChange', (event) => {
+            if (this.activateOptions) {
+                this.deps.drmController.initializeForPlayback(event.current, this.disposeAbort);
+            }
+        });
+        this.on('bufferingQualityChange', (event) => {
+            this.deps.drmController.setBufferingDrmInfo(event.current, this.disposeAbort);
+        });
+        // Listen for timeline changes to update qualities.
+        add(deps.mediaTimelineTransformed.onData(() => {
+            this._cachedPeriod = null;
+            this.updateQualities();
+        }));
+        add(deps.mediaTimeline.onData(() => {
+            this._cachedPeriod = null;
+            this.updateQualitiesUnfiltered();
+        }));
+    }
+    /**
+     * Updates the cached qualities list from the transformed timeline for the current period.
+     */
+    updateQualities() {
+        const time = this.deps.playbackController.currentTime;
+        this.deps.mediaTimelineTransformed.value
+            .then((timeline) => {
+            if (this.disposer.disposed)
+                return;
+            const period = getMediaPeriodAtTime(timeline, time);
+            this._cachedPeriod = period;
+            const newQualities = period
+                ? period.qualities.map((q) => q.metadata)
+                : null;
+            if (!equalDeep(newQualities, this._qualities)) {
+                const previous = this._qualities;
+                this._qualities = newQualities;
+                if (newQualities) {
+                    this.dispatch('qualitiesChange', {
+                        previous: previous ?? [],
+                        current: newQualities,
+                    });
+                }
+            }
+        })
+            .catch(this.errorHandler);
+    }
+    /**
+     * Updates the cached unfiltered qualities list from the raw timeline for the current period.
+     */
+    updateQualitiesUnfiltered() {
+        const time = this.deps.playbackController.currentTime;
+        this.deps.mediaTimeline.value
+            .then((timeline) => {
+            if (this.disposer.disposed)
+                return;
+            const period = getMediaPeriodAtTime(timeline, time);
+            const newQualities = period
+                ? period.qualities.map((q) => q.metadata)
+                : null;
+            if (!equalDeep(newQualities, this._qualitiesUnfiltered)) {
+                const previous = this._qualitiesUnfiltered;
+                this._qualitiesUnfiltered = newQualities;
+                if (newQualities) {
+                    this.dispatch('qualitiesUnfilteredChange', {
+                        previous: previous ?? [],
+                        current: newQualities,
+                    });
+                }
+            }
+        })
+            .catch(this.errorHandler);
+    }
+    /**
+     * Creates and adds a content stream for the given content type.
+     *
+     * @param contentType
+     */
+    createStream(contentType) {
+        const stream = this.deps.contentStreamFactory(contentType);
+        redispatchEvents(this, stream, [
+            'fetchedRangesChange',
+            'streamingQualityChange',
+            'bufferingQualityChange',
+            'playbackQualityChange',
+        ]);
+        stream.on('bufferingEnded', () => {
+            if (this.bufferingEnded) {
+                this.deps.mediaSourceController.endOfStream();
+                this.dispatch('bufferingEnded', {});
+            }
+        });
+        stream.on('fetchedRangesChange', () => {
+            this._fetchedRanges.invalidate();
+        });
+        stream.on('error', (event) => {
+            if (!this._error) {
+                // Set error state and bubble event
+                this._error = event.error;
+                this.dispatch('error', event);
+            }
+        });
+        // The fetched ranges of the track is the intersection of all content stream fetched ranges.
+        this.allFetchedRanges.push(stream.fetchedRanges);
+        this._fetchedRanges.invalidate();
+        this.streams.push(stream);
+        if (this.lastPreloadOptions) {
+            stream.preload(this.lastPreloadOptions);
+        }
+        if (this.activateOptions) {
+            stream.activate(this.activateOptions);
+        }
+    }
+    preload(trackOptions, loadOptions) {
+        const options = {
+            startTime: loadOptions.startTime,
+            prefetchPriority: trackOptions.prefetchPriority,
+        };
+        this.lastPreloadOptions = options;
+        this.callOnStreams('preload', options);
+    }
+    get contentTypes() {
+        return this._contentTypes;
+    }
+    set contentTypes(value) {
+        const previous = this._contentTypes;
+        this._contentTypes = value;
+        this.dispatch('contentTypesChange', {
+            previous,
+            current: value,
+        });
+    }
+    get qualities() {
+        return this._qualities;
+    }
+    get qualitiesUnfiltered() {
+        return this._qualitiesUnfiltered;
+    }
+    get fetchedRanges() {
+        return this._fetchedRanges;
+    }
+    /**
+     * Clears all fetched fragments and source buffers. Streaming will resume.
+     * This should be called if a change has been made where the user would expect an immediate change,
+     * for example, changing streaming quality from SD to HD.
+     */
+    clearPrefetch() {
+        logDebug(this, 'clearPrefetch');
+        this.callOnStreams('clearPrefetch');
+    }
+    /**
+     * Resets the track to recover from error states.
+     * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
+     */
+    reset() {
+        if (!this.error) {
+            logDebug(this, 'reset no-op');
+            return;
+        }
+        this.deps.manifestController.reset();
+        this.callOnStreams('reset');
+        super.reset();
+    }
+    onActivated(loadOptions) {
+        this.activateOptions = loadOptions;
+        // AirPlay not supported using managed media sources
+        this.deps.playbackSource.disableRemotePlayback = true;
+        this.streams.forEach((stream) => {
+            this.deps.drmController.initializeForPlayback(stream.streamingQuality, this.disposeAbort);
+        });
+        this.deps.playbackSource.src =
+            this.deps.mediaSourceController.createUrl();
+        this.callOnStreams('activate', loadOptions);
+        // Listen for timeUpdate to detect period changes.
+        this.timeUpdateSub = this.deps.playbackController.on('timeUpdate', () => {
+            const time = this.deps.playbackController.currentTime;
+            const cached = this._cachedPeriod;
+            if (cached &&
+                time >= cached.startTime &&
+                time < cached.endTime) {
+                return;
+            }
+            this.updateQualities();
+            this.updateQualitiesUnfiltered();
+        });
+    }
+    onDeactivated() {
+        this.activateOptions = null;
+        this.timeUpdateSub?.();
+        this.timeUpdateSub = null;
+        this.callOnStreams('deactivate');
+        this.deps.playbackSource.src = null;
+        this.deps.playbackSource.load();
+    }
+    getStreamingQuality(contentType) {
+        return this.getStream(contentType)?.streamingQuality ?? null;
+    }
+    getBufferingQuality(contentType) {
+        return this.getStream(contentType)?.bufferingQuality ?? null;
+    }
+    getPlaybackQuality(contentType) {
+        return this.getStream(contentType)?.playbackQuality ?? null;
+    }
+    /**
+     * Calls the specified method on all streams with the provided arguments.
+     */
+    callOnStreams(functionName, ...args) {
+        this.streams.forEach((stream) => {
+            ;
+            stream[functionName](...args);
+        });
+    }
+    getStream(contentType) {
+        return this.streams.find((s) => s.contentType === contentType);
+    }
+    clearStreams() {
+        this.callOnStreams('dispose');
+        this.streams.length = 0;
+        this.allFetchedRanges.length = 0;
+        this._fetchedRanges.invalidate();
+    }
+    get bufferingEnded() {
+        return this.streams.every((stream) => stream.bufferingEnded);
+    }
+    dispose() {
+        logDebug(this, 'dispose');
+        this.timeUpdateSub?.();
+        this.timeUpdateSub = null;
+        this.clearStreams();
+        super.dispose();
+    }
+}

package/dist/types/current/track/mse/codec.d.ts

@@ -0,0 +1,16 @@
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+/**
+ * Returns the ContentType for a single RFC 6381 codec string, or null if
+ * unrecognized.
+ */
+export declare function codecToContentType(codec: string): ContentType | null;
+/**
+ * Splits a comma-separated CODECS attribute value and returns the set of
+ * ContentType values present.
+ */
+export declare function codecsToContentTypes(codecs: string): Set<ContentType>;
+/**
+ * Returns the full MIME type string for a content type, optionally with codecs.
+ */
+export declare function contentTypeToMimeType(contentType: ContentType, codecs: string | null): string;
+//# sourceMappingURL=codec.d.ts.map

package/dist/types/current/track/mse/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../../../src/track/mse/codec.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AA0BnE;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAYpE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,WAAW,CAAC,CAOrE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACjC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,GAAG,IAAI,GACtB,MAAM,CAGR"}