@amazon/vinyl 1.0.0

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * RFC 6381 codec prefixes for video content.
+ */
+const VIDEO_CODEC_PREFIXES = [
+    'avc1',
+    'avc3',
+    'hvc1',
+    'hev1',
+    'vp09',
+    'av01',
+    'dvh1',
+    'dvhe',
+];
+/**
+ * RFC 6381 codec prefixes for audio content.
+ */
+const AUDIO_CODEC_PREFIXES = ['mp4a', 'ac-3', 'ec-3', 'opus', 'flac'];
+/**
+ * RFC 6381 codec prefixes for text/subtitle content.
+ */
+const TEXT_CODEC_PREFIXES = ['stpp', 'wvtt'];
+/**
+ * Returns the ContentType for a single RFC 6381 codec string, or null if
+ * unrecognized.
+ */
+export function codecToContentType(codec) {
+    const lower = codec.trim().toLowerCase();
+    for (const p of VIDEO_CODEC_PREFIXES) {
+        if (lower.startsWith(p))
+            return 'video';
+    }
+    for (const p of AUDIO_CODEC_PREFIXES) {
+        if (lower.startsWith(p))
+            return 'audio';
+    }
+    for (const p of TEXT_CODEC_PREFIXES) {
+        if (lower.startsWith(p))
+            return 'text';
+    }
+    return null;
+}
+/**
+ * Splits a comma-separated CODECS attribute value and returns the set of
+ * ContentType values present.
+ */
+export function codecsToContentTypes(codecs) {
+    const types = new Set();
+    for (const codec of codecs.split(',')) {
+        const type = codecToContentType(codec);
+        if (type)
+            types.add(type);
+    }
+    return types;
+}
+/**
+ * Returns the full MIME type string for a content type, optionally with codecs.
+ */
+export function contentTypeToMimeType(contentType, codecs) {
+    const base = contentType === 'video' ? 'video/mp4' : 'audio/mp4';
+    return codecs ? `${base}; codecs="${codecs}"` : base;
+}

package/dist/types/current/track/source/FixedPlaybackQuality.d.ts

@@ -0,0 +1,38 @@
+import type { TrackEventMap } from '../../track/Track';
+import { EventHostImpl, type ReadonlySet } from '@amazon/vinyl-util';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+/**
+ * FixedPlaybackQuality has a singular quality for selection.
+ *
+ * streamingQuality will always be the fixed quality.
+ *
+ * bufferingQuality will be the fixed quality when active, otherwise null.
+ *
+ * playbackQuality will be the fixed quality when active and data is buffered, otherwise null.
+ */
+export declare class FixedPlaybackQuality extends EventHostImpl<Pick<TrackEventMap, 'streamingQualityChange' | 'bufferingQualityChange' | 'playbackQualityChange'>> {
+    private readonly deps;
+    private _fixedQuality;
+    private _contentTypes;
+    private _isActive;
+    get active(): boolean;
+    constructor(fixedQuality: MediaQualityMetadata, deps: {
+        readonly playbackController: PlaybackController;
+    });
+    get contentTypes(): ReadonlySet<ContentType>;
+    get fixedQuality(): MediaQualityMetadata;
+    set fixedQuality(value: MediaQualityMetadata);
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private _bufferingQuality;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set bufferingQuality(value);
+    private _playbackQuality;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set playbackQuality(value);
+    private readyStateChangeSub;
+    activate(): void;
+    deactivate(): void;
+    private onReadyStateChange;
+}
+//# sourceMappingURL=FixedPlaybackQuality.d.ts.map

package/dist/types/current/track/source/FixedPlaybackQuality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixedPlaybackQuality.d.ts","sourceRoot":"","sources":["../../../../../src/track/source/FixedPlaybackQuality.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAEvE,OAAO,KAAK,EACR,WAAW,EACX,oBAAoB,EACvB,MAAM,kCAAkC,CAAA;AAEzC;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,aAAa,CACnD,IAAI,CACA,aAAa,EACX,wBAAwB,GACxB,wBAAwB,GACxB,uBAAuB,CAC5B,CACJ;IAWO,OAAO,CAAC,QAAQ,CAAC,IAAI;IAVzB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAyB;IAE9C,OAAO,CAAC,SAAS,CAAQ;IACzB,IAAI,MAAM,IAAI,OAAO,CAEpB;gBAGG,YAAY,EAAE,oBAAoB,EACjB,IAAI,EAAE;QACnB,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;KAClD;IAML,IAAI,YAAY,IAAI,WAAW,CAAC,WAAW,CAAC,CAE3C;IAED,IAAI,YAAY,IAAI,oBAAoB,CAEvC;IAED,IAAI,YAAY,CAAC,KAAK,EAAE,oBAAoB,EAkB3C;IAED,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAK1E,OAAO,CAAC,iBAAiB,CAAoC;IAC7D,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAK1E,OAAO,KAAK,gBAAgB,QAQ3B;IAED,OAAO,CAAC,gBAAgB,CAAoC;IAC5D,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,oBAAoB,GAAG,IAAI;IAKzE,OAAO,KAAK,eAAe,QAQ1B;IAED,OAAO,CAAC,mBAAmB,CAA2B;IACtD,QAAQ;IAcR,UAAU;IASV,OAAO,CAAC,kBAAkB,CAGzB;CACJ"}

package/dist/types/current/track/source/FixedPlaybackQuality.js

@@ -0,0 +1,115 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { PlaybackReadyState } from '../../playback/ReadonlyPlaybackController';
+/**
+ * FixedPlaybackQuality has a singular quality for selection.
+ *
+ * streamingQuality will always be the fixed quality.
+ *
+ * bufferingQuality will be the fixed quality when active, otherwise null.
+ *
+ * playbackQuality will be the fixed quality when active and data is buffered, otherwise null.
+ */
+export class FixedPlaybackQuality extends EventHostImpl {
+    deps;
+    _fixedQuality;
+    _contentTypes = new Set();
+    _isActive = false;
+    get active() {
+        return this._isActive;
+    }
+    constructor(fixedQuality, deps) {
+        super();
+        this.deps = deps;
+        this.fixedQuality = fixedQuality;
+    }
+    get contentTypes() {
+        return this._contentTypes;
+    }
+    get fixedQuality() {
+        return this._fixedQuality;
+    }
+    set fixedQuality(value) {
+        const previous = this._fixedQuality;
+        this._fixedQuality = value;
+        this._contentTypes = new Set();
+        if (value.contentType)
+            this._contentTypes.add(value.contentType);
+        this.dispatch('streamingQualityChange', {
+            previous,
+            current: this._fixedQuality,
+        });
+        if (this.active) {
+            this.bufferingQuality = value;
+            if (this.deps.playbackController.readyState >=
+                PlaybackReadyState.HAVE_CURRENT_DATA) {
+                this.playbackQuality = value;
+            }
+        }
+    }
+    getStreamingQuality(contentType) {
+        if (contentType !== this._fixedQuality.contentType)
+            return null;
+        return this._fixedQuality;
+    }
+    _bufferingQuality = null;
+    getBufferingQuality(contentType) {
+        if (contentType !== this._bufferingQuality?.contentType)
+            return null;
+        return this._bufferingQuality;
+    }
+    set bufferingQuality(value) {
+        const previous = this._bufferingQuality;
+        if (previous === value)
+            return;
+        this._bufferingQuality = value;
+        this.dispatch('bufferingQualityChange', {
+            previous,
+            current: this._bufferingQuality,
+        });
+    }
+    _playbackQuality = null;
+    getPlaybackQuality(contentType) {
+        if (contentType !== this._playbackQuality?.contentType)
+            return null;
+        return this._playbackQuality;
+    }
+    set playbackQuality(value) {
+        const previous = this._playbackQuality;
+        if (previous === value)
+            return;
+        this._playbackQuality = value;
+        this.dispatch('playbackQualityChange', {
+            previous,
+            current: this._playbackQuality,
+        });
+    }
+    readyStateChangeSub = null;
+    activate() {
+        if (this._isActive)
+            return;
+        this._isActive = true;
+        this.bufferingQuality = this._fixedQuality;
+        const pC = this.deps.playbackController;
+        this.readyStateChangeSub = pC.on('readyStateChange', this.onReadyStateChange);
+        if (pC.readyState >= PlaybackReadyState.HAVE_CURRENT_DATA) {
+            this.playbackQuality = this._fixedQuality;
+        }
+    }
+    deactivate() {
+        if (!this._isActive)
+            return;
+        this._isActive = false;
+        this.readyStateChangeSub();
+        this.readyStateChangeSub = null;
+        this.bufferingQuality = null;
+        this.playbackQuality = null;
+    }
+    onReadyStateChange = (event) => {
+        const hasData = event.current >= PlaybackReadyState.HAVE_CURRENT_DATA;
+        this.playbackQuality = hasData ? this._fixedQuality : null;
+    };
+}

package/dist/types/current/track/source/SourceObjectTrack.d.ts

@@ -0,0 +1,33 @@
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+import type { TrackTypeId, TrackUri } from '../../track/Track';
+import { type TrackBaseDeps } from '../../track/TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import { type Maybe } from '@amazon/vinyl-util';
+import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+/**
+ * Dependencies for a SourceObjectTrack.
+ */
+export interface SourceObjectTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceObjectTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'srcObject';
+    /**
+     * A function to produce a MediaStream, or Promise<MediaStream>.
+     */
+    readonly srcObjectProvider: (uri: TrackUri) => Promise<MediaStream> | MediaStream;
+    /**
+     * Configuration options for the SourceObjectTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceObjectTrackFactory(deps: SourceObjectTrackDeps): TrackFactory<SourceObjectTrackLoadOptions>;
+export declare class SourceObjectTrack extends SourceTrackBase<MediaStream> {
+    protected readonly deps: SourceObjectTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, srcObject: Promise<MediaStream>, deps: SourceObjectTrackDeps);
+    protected setSrc(src: MediaStream): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceObjectTrack.d.ts.map

package/dist/types/current/track/source/SourceObjectTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceObjectTrack.d.ts","sourceRoot":"","sources":["../../../../../src/track/source/SourceObjectTrack.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,KAAK,EAAS,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACjE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAExB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE5D,OAAO,EACH,eAAe,EACf,KAAK,sBAAsB,EAE9B,MAAM,gCAAgC,CAAA;AAEvC;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IACxD,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;CAC1C;AAED,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IAClE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CACxB,GAAG,EAAE,QAAQ,KACZ,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAA;IAEvC;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;CAClD;AASD,wBAAgB,8BAA8B,CAC1C,IAAI,EAAE,qBAAqB,GAC5B,YAAY,CAAC,4BAA4B,CAAC,CAe5C;AAGD,qBAAa,iBAAkB,SAAQ,eAAe,CAAC,WAAW,CAAC;IAS3D,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,qBAAqB;IARlD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,EACZ,IAAI,EAAE,qBAAqB;IAKlD,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,WAAW;IAIjC,SAAS,CAAC,QAAQ,IAAI,IAAI;CAI7B"}

package/dist/types/current/track/source/SourceObjectTrack.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { trackLoadOptionsValidator, } from '../../track/TrackFactory';
+import { ErrorOrigin } from '@amazon/vinyl-util';
+import { func, isOneOf } from '@amazon/vinyl-validation';
+import { SourceTrackBase, sourceTrackBaseOptionsValidator, } from '../../track/source/SourceTrackBase';
+const loadOptionsValidator = trackLoadOptionsValidator.extend({
+    srcObjectProvider: func(),
+    type: isOneOf('srcObject'),
+    config: sourceTrackBaseOptionsValidator.maybe().optional(),
+});
+export function createSourceObjectTrackFactory(deps) {
+    return {
+        validate(options) {
+            loadOptionsValidator.assert(options, ErrorOrigin.API);
+        },
+        createTrack(options) {
+            return new SourceObjectTrack(options.uri, options.type, Promise.resolve(options.srcObjectProvider(options.uri)), deps);
+        },
+    };
+}
+// TODO: Accept a provider function instead of a Promise for srcObject to support reset.
+export class SourceObjectTrack extends SourceTrackBase {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'SourceObjectTrack';
+    }
+    constructor(uri, type, srcObject, deps) {
+        super(uri, type, srcObject, deps);
+        this.deps = deps;
+    }
+    setSrc(src) {
+        this.deps.playbackSource.srcObject = src;
+    }
+    clearSrc() {
+        this.deps.playbackSource.srcObject = null;
+        this.deps.playbackSource.load();
+    }
+}

package/dist/types/current/track/source/SourceTrack.d.ts

@@ -0,0 +1,34 @@
+import type { TrackTypeId, TrackUri } from '../../track/Track';
+import { type TrackBaseDeps } from '../../track/TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import { type Maybe } from '@amazon/vinyl-util';
+import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+/**
+ * Dependencies for a SourceTrack.
+ */
+export interface SourceTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'src';
+    /**
+     * If set, will be called to provide the track src.
+     * Otherwise, the uri will be used.
+     */
+    readonly srcProvider?: Maybe<(uri: TrackUri) => Promise<string> | string>;
+    /**
+     * Configuration options for the SourceTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceTrackFactory(deps: SourceTrackDeps): TrackFactory<SourceTrackLoadOptions>;
+export declare class SourceTrack extends SourceTrackBase<string> {
+    protected readonly deps: SourceTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, src: Promise<string>, deps: SourceTrackDeps);
+    protected setSrc(src: string): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceTrack.d.ts.map

package/dist/types/current/track/source/SourceTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceTrack.d.ts","sourceRoot":"","sources":["../../../../../src/track/source/SourceTrack.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAS,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACjE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAExB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAO5D,OAAO,EACH,eAAe,EACf,KAAK,sBAAsB,EAE9B,MAAM,gCAAgC,CAAA;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,aAAa;IAClD,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;CAC1C;AAED,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IAEpB;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;IAEzE;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAA;CAClD;AAUD,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,eAAe,GACtB,YAAY,CAAC,sBAAsB,CAAC,CAiBtC;AAGD,qBAAa,WAAY,SAAQ,eAAe,CAAC,MAAM,CAAC;IAShD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe;IAR5C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,EACD,IAAI,EAAE,eAAe;IAK5C,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM;IAI5B,SAAS,CAAC,QAAQ;CAIrB"}

package/dist/types/current/track/source/SourceTrack.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { trackLoadOptionsValidator, } from '../../track/TrackFactory';
+import { ErrorOrigin } from '@amazon/vinyl-util';
+import { func, isOneOf, string, } from '@amazon/vinyl-validation';
+import { SourceTrackBase, sourceTrackBaseOptionsValidator, } from '../../track/source/SourceTrackBase';
+const loadOptionsValidator = trackLoadOptionsValidator.extend({
+    config: sourceTrackBaseOptionsValidator.maybe().optional(),
+    srcProvider: func().maybe().optional(),
+    type: isOneOf('src'),
+    uri: string().notEmpty(),
+});
+export function createSourceTrackFactory(deps) {
+    return {
+        validate(options) {
+            loadOptionsValidator.assert(options, ErrorOrigin.API);
+        },
+        createTrack(options) {
+            return new SourceTrack(options.uri, options.type, options.srcProvider
+                ? Promise.resolve(options.srcProvider(options.uri))
+                : Promise.resolve(options.uri), deps);
+        },
+    };
+}
+// TODO: Accept a provider function instead of a Promise for src to support reset.
+export class SourceTrack extends SourceTrackBase {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'SourceTrack';
+    }
+    constructor(uri, type, src, deps) {
+        super(uri, type, src, deps);
+        this.deps = deps;
+    }
+    setSrc(src) {
+        this.deps.playbackSource.src = src;
+    }
+    clearSrc() {
+        this.deps.playbackSource.src = null;
+        this.deps.playbackSource.load();
+    }
+}

package/dist/types/current/track/source/SourceTrackBase.d.ts

@@ -0,0 +1,33 @@
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
+import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import { type Maybe, type ReadonlySet } from '@amazon/vinyl-util';
+import { type ContentType, type MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+export interface SourceTrackBaseOptions extends TrackBaseOptions {
+    /**
+     * Quality metadata.
+     * May be used to configure DRM (for native HLS), codec, or other track metadata.
+     */
+    readonly qualityMetadata?: Maybe<Partial<MediaQualityMetadata>>;
+}
+export declare const sourceTrackBaseOptionsValidator: ObjectSchema<SourceTrackBaseOptions>;
+export declare abstract class SourceTrackBase<SrcType, EventMap extends TrackEventMap = TrackEventMap, LoadOptionsType extends SourceTrackBaseOptions = SourceTrackBaseOptions> extends TrackBase<EventMap, LoadOptionsType> {
+    readonly src: Promise<SrcType>;
+    protected readonly deps: TrackBaseDeps;
+    private readonly fixedPlaybackQuality;
+    private _resolvedSrc;
+    protected constructor(uri: TrackUri, type: TrackTypeId, src: Promise<SrcType>, deps: TrackBaseDeps);
+    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    get qualities(): readonly MediaQualityMetadata[] | null;
+    get qualitiesUnfiltered(): readonly MediaQualityMetadata[] | null;
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    onActivated(): void;
+    protected abstract setSrc(src: SrcType): void;
+    protected abstract clearSrc(): void;
+    onDeactivated(): void;
+    clearPrefetch(): void;
+}
+//# sourceMappingURL=SourceTrackBase.d.ts.map

package/dist/types/current/track/source/SourceTrackBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceTrackBase.d.ts","sourceRoot":"","sources":["../../../../../src/track/source/SourceTrackBase.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,gBAAgB,EAExB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACR,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,QAAQ,EACX,MAAM,eAAe,CAAA;AAEtB,OAAO,EAEH,KAAK,KAAK,EACV,KAAK,WAAW,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACH,KAAK,WAAW,EAEhB,KAAK,oBAAoB,EAE5B,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAA;CAClE;AAED,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,sBAAsB,CAM3E,CAAA;AAKN,8BAAsB,eAAe,CACjC,OAAO,EACP,QAAQ,SAAS,aAAa,GAAG,aAAa,EAC9C,eAAe,SAAS,sBAAsB,GAAG,sBAAsB,CACzE,SAAQ,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAC;aAOtB,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa;IAP1C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAsB;IAC3D,OAAO,CAAC,YAAY,CAAuB;IAE3C,SAAS,aACL,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,WAAW,EACD,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,EAClB,IAAI,EAAE,aAAa;IA0B1C,OAAO,CAAC,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,eAAe;IAQvE,IAAI,YAAY,IAAI,WAAW,CAAC,WAAW,CAAC,CAE3C;IAED,IAAI,SAAS,IAAI,SAAS,oBAAoB,EAAE,GAAG,IAAI,CAEtD;IAED,IAAI,mBAAmB,IAAI,SAAS,oBAAoB,EAAE,GAAG,IAAI,CAEhE;IAED,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,WAAW,IAAI,IAAI;IASnB,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAC7C,SAAS,CAAC,QAAQ,CAAC,QAAQ,IAAI,IAAI;IAEnC,aAAa,IAAI,IAAI;IAKrB,aAAa;CAIhB"}

package/dist/types/current/track/source/SourceTrackBase.js

@@ -0,0 +1,83 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TrackBase, trackBaseOptionsValidator, } from '../../track/TrackBase';
+import { FixedPlaybackQuality } from '../../track/source/FixedPlaybackQuality';
+import { logDebug, redispatchEvents, } from '@amazon/vinyl-util';
+import { createEmptyMediaQualityMetadata, mediaQualityMetadataValidator, } from '../../streaming/MediaQualityMetadata';
+export const sourceTrackBaseOptionsValidator = trackBaseOptionsValidator.extend({
+    qualityMetadata: mediaQualityMetadataValidator
+        .partial()
+        .maybe()
+        .optional(),
+});
+const emptyMediaQualityMetadata = createEmptyMediaQualityMetadata();
+export class SourceTrackBase extends TrackBase {
+    src;
+    deps;
+    fixedPlaybackQuality;
+    _resolvedSrc = null;
+    constructor(uri, type, src, deps) {
+        super(uri, type, deps);
+        this.src = src;
+        this.deps = deps;
+        const add = this.disposer.add;
+        this.src
+            .then((src) => {
+            this._resolvedSrc = src;
+            if (this.active)
+                this.setSrc(src);
+        })
+            .catch(this.errorHandler);
+        this.fixedPlaybackQuality = add(new FixedPlaybackQuality(emptyMediaQualityMetadata, deps));
+        this.fixedPlaybackQuality.on('bufferingQualityChange', (event) => {
+            this.deps.drmController.setBufferingDrmInfo(event.current, this.drmSessionAbort.value);
+        });
+        redispatchEvents(this, this.fixedPlaybackQuality, [
+            'streamingQualityChange',
+            'bufferingQualityChange',
+            'playbackQualityChange',
+        ]);
+    }
+    preload(trackOptions, loadOptions) {
+        super.preload(trackOptions, loadOptions);
+        this.fixedPlaybackQuality.fixedQuality = {
+            ...emptyMediaQualityMetadata,
+            ...loadOptions.qualityMetadata,
+        };
+    }
+    get contentTypes() {
+        return this.fixedPlaybackQuality.contentTypes;
+    }
+    get qualities() {
+        return null;
+    }
+    get qualitiesUnfiltered() {
+        return null;
+    }
+    getStreamingQuality(contentType) {
+        return this.fixedPlaybackQuality.getStreamingQuality(contentType);
+    }
+    getBufferingQuality(contentType) {
+        return this.fixedPlaybackQuality.getBufferingQuality(contentType);
+    }
+    getPlaybackQuality(contentType) {
+        return this.fixedPlaybackQuality.getPlaybackQuality(contentType);
+    }
+    onActivated() {
+        this.fixedPlaybackQuality.activate();
+        this.deps.drmController.initializeForPlayback(this.fixedPlaybackQuality.fixedQuality, this.drmSessionAbort.value);
+        if (this._resolvedSrc != null)
+            this.setSrc(this._resolvedSrc);
+    }
+    onDeactivated() {
+        if (this._resolvedSrc != null)
+            this.clearSrc();
+        this.fixedPlaybackQuality.deactivate();
+    }
+    clearPrefetch() {
+        // Source tracks do not prefetch
+        logDebug(this, 'clearPrefetch no-op');
+    }
+}