@amazon/vinyl 1.0.0

package/dist/types/current/streaming/SegmentDataSlot.d.ts

@@ -0,0 +1,58 @@
+import type { Disposable, Maybe } from '@amazon/vinyl-util';
+import { type ReadonlyAbort } from '@amazon/vinyl-util';
+export declare enum SegmentStatus {
+    /**
+     * This segment has not been requested.
+     */
+    INACTIVE = "inactive",
+    /**
+     * The segment has been requested but not yet completed.
+     */
+    PENDING = "pending",
+    /**
+     * The segment has finished requesting.
+     */
+    RESOLVED = "resolved",
+    /**
+     * The segment failed to load.
+     */
+    ERRED = "erred"
+}
+/**
+ * A function that returns a promise to segment data.
+ */
+export type SegmentDataProvider = (abort?: Maybe<ReadonlyAbort>) => Promise<ArrayBuffer>;
+/**
+ * A SegmentSlot is a holder for a segment buffer. It may be requested, cleared, and its status observed.
+ */
+export declare class SegmentDataSlot implements Disposable {
+    private readonly requestSegmentData;
+    /**
+     * Called when the status has changed.
+     */
+    onStatusChange: (() => void) | null;
+    private _status;
+    private readonly abortSlot;
+    private bufferPromise;
+    constructor(requestSegmentData: SegmentDataProvider);
+    /**
+     * This segment's request status.
+     */
+    get status(): SegmentStatus;
+    private set status(value);
+    /**
+     * Aborts the request if the status is currently {@link SegmentStatus.PENDING}, and clears the cached buffer.
+     * The status will go back to {@link SegmentStatus.INACTIVE} and the segment may be requested again in the future.
+     */
+    clear(): void;
+    /**
+     * Begins the segment request now if it has not already been requested.
+     * The promise returned will settle after this slot's status has updated and onStatusChange callback invoked.
+     */
+    request(): Promise<ArrayBuffer>;
+    /**
+     * Clears this segment and removes its handler.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=SegmentDataSlot.d.ts.map

package/dist/types/current/streaming/SegmentDataSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentDataSlot.d.ts","sourceRoot":"","sources":["../../../../src/streaming/SegmentDataSlot.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAGH,KAAK,aAAa,EACrB,MAAM,oBAAoB,CAAA;AAE3B,oBAAY,aAAa;IACrB;;OAEG;IACH,QAAQ,aAAa;IAErB;;OAEG;IACH,OAAO,YAAY;IAEnB;;OAEG;IACH,QAAQ,aAAa;IAErB;;OAEG;IACH,KAAK,UAAU;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAC9B,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,KAC3B,OAAO,CAAC,WAAW,CAAC,CAAA;AAEzB;;GAEG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAWlC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAV/C;;OAEG;IACH,cAAc,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAO;IAE1C,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAE9C,OAAO,CAAC,aAAa,CAAoC;gBAE5B,kBAAkB,EAAE,mBAAmB;IAEpE;;OAEG;IACH,IAAI,MAAM,IAAI,aAAa,CAE1B;IAED,OAAO,KAAK,MAAM,QAGjB;IAED;;;OAGG;IACH,KAAK,IAAI,IAAI;IAOb;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,WAAW,CAAC;IAyB/B;;OAEG;IACH,OAAO,IAAI,IAAI;CAIlB"}

package/dist/types/current/streaming/SegmentDataSlot.js

@@ -0,0 +1,97 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAbortSlot, isSilentError, } from '@amazon/vinyl-util';
+export var SegmentStatus;
+(function (SegmentStatus) {
+    /**
+     * This segment has not been requested.
+     */
+    SegmentStatus["INACTIVE"] = "inactive";
+    /**
+     * The segment has been requested but not yet completed.
+     */
+    SegmentStatus["PENDING"] = "pending";
+    /**
+     * The segment has finished requesting.
+     */
+    SegmentStatus["RESOLVED"] = "resolved";
+    /**
+     * The segment failed to load.
+     */
+    SegmentStatus["ERRED"] = "erred";
+})(SegmentStatus || (SegmentStatus = {}));
+/**
+ * A SegmentSlot is a holder for a segment buffer. It may be requested, cleared, and its status observed.
+ */
+export class SegmentDataSlot {
+    requestSegmentData;
+    /**
+     * Called when the status has changed.
+     */
+    onStatusChange = null;
+    _status = SegmentStatus.INACTIVE;
+    abortSlot = createAbortSlot();
+    bufferPromise = null;
+    constructor(requestSegmentData) {
+        this.requestSegmentData = requestSegmentData;
+    }
+    /**
+     * This segment's request status.
+     */
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+        if (this.onStatusChange)
+            this.onStatusChange();
+    }
+    /**
+     * Aborts the request if the status is currently {@link SegmentStatus.PENDING}, and clears the cached buffer.
+     * The status will go back to {@link SegmentStatus.INACTIVE} and the segment may be requested again in the future.
+     */
+    clear() {
+        if (this.status === SegmentStatus.INACTIVE)
+            return;
+        this.abortSlot.abort();
+        this.bufferPromise = null;
+        this.status = SegmentStatus.INACTIVE;
+    }
+    /**
+     * Begins the segment request now if it has not already been requested.
+     * The promise returned will settle after this slot's status has updated and onStatusChange callback invoked.
+     */
+    request() {
+        if (!this.bufferPromise) {
+            this.status = SegmentStatus.PENDING;
+            // Chains status handling to the promise returned by requestSegment.
+            this.bufferPromise = this.requestSegmentData(this.abortSlot.value)
+                .then((result) => {
+                this.status = SegmentStatus.RESOLVED;
+                return result;
+            })
+                .catch((error) => {
+                if (isSilentError(error)) {
+                    // Allows this data slot to be requested again.
+                    this.bufferPromise = null;
+                    this.status = SegmentStatus.INACTIVE;
+                }
+                else {
+                    // A higher severity error, do not try again.
+                    this.status = SegmentStatus.ERRED;
+                }
+                throw error;
+            });
+        }
+        return this.bufferPromise;
+    }
+    /**
+     * Clears this segment and removes its handler.
+     */
+    dispose() {
+        this.clear();
+        this.onStatusChange = null;
+    }
+}

package/dist/types/current/streaming/SegmentPrefetch.d.ts

@@ -0,0 +1,62 @@
+import type { Task, TaskQueue } from '@amazon/vinyl-util';
+import { type Comparator } from '@amazon/vinyl-util';
+import type { ContentType } from './MediaQualityMetadata';
+/**
+ * Properties affecting segment prefetch priority.
+ * Each track when prefetching will only add one segment to the prefetch queue at a time.
+ */
+export interface SegmentPrefetchPriority {
+    /**
+     * The track's prefetch priority.
+     */
+    readonly trackPriority: number;
+    /**
+     * The starting time of the segment.
+     */
+    readonly segmentStartTime: number;
+    /**
+     * The time position prefetching starts for this segment's track.
+     */
+    readonly prefetchStartTime: number;
+}
+export declare const defaultTrackPriority: {
+    readonly trackPriority: 0;
+    readonly segmentStartTime: 9007199254740991;
+    readonly prefetchStartTime: 0;
+};
+/**
+ * Highest priority; used to block prefetching while an actively-needed operation is enqueued.
+ */
+export declare const immediatePrefetchPriority: {
+    trackPriority: number;
+    segmentStartTime: number;
+    prefetchStartTime: number;
+};
+/**
+ * A comparator for segment prefetching.
+ * Given tracks A, B, and C with track priorities 1, 2, and 3 respectively:
+ * The expected prefetch order will be:
+ *
+ * A0
+ * B0 // "lean forward" case
+ * C0 // "lean forward" case
+ * A1 ... An
+ * B1 ... Bn
+ * C1 ... Cn
+ *
+ * Note that background prefetching is in parallel to prefetching for the active track.
+ */
+export declare const segmentPriorityComparatorRef: import("@amazon/vinyl-util").GlobalRef<Comparator<SegmentPrefetchPriority>>;
+export declare const prefetchPriorityQueuesRef: import("@amazon/vinyl-util").GlobalRef<Record<ContentType, TaskQueue<SegmentPrefetchPriority>>>;
+/**
+ * Enqueues a task to request a streaming segment for a specific content type.
+ * This should only be used for low priority background requests. Active tracks should request without
+ * prioritization for the immediately needed segment.
+ * Tracks are expected to prefetch one segment at a time, in order.
+ *
+ * @param requestTask
+ * @param contentType
+ * @param priority
+ */
+export declare function enqueueSegmentPrefetch(requestTask: Task<any>, contentType: ContentType, priority: SegmentPrefetchPriority): Promise<void>;
+//# sourceMappingURL=SegmentPrefetch.d.ts.map

package/dist/types/current/streaming/SegmentPrefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentPrefetch.d.ts","sourceRoot":"","sources":["../../../../src/streaming/SegmentPrefetch.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EACH,KAAK,UAAU,EAIlB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACpC;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAE9B;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IAEjC;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACrC;AAED,eAAO,MAAM,oBAAoB;;;;CAKW,CAAA;AAE5C;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;CAIrC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B,6EAWvC,CAAA;AAGF,eAAO,MAAM,yBAAyB,iGAiBpC,CAAA;AAEF;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAClC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,EACtB,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,uBAAuB,GAClC,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/types/current/streaming/SegmentPrefetch.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { compareBy, createTaskQueue, globalRef, } from '@amazon/vinyl-util';
+export const defaultTrackPriority = {
+    // Default priority is lowest, but not used. Use enqueueSegmentPrefetch to enqueue.
+    trackPriority: 0,
+    segmentStartTime: 9007199254740991, // Number.MAX_SAFE_INTEGER,
+    prefetchStartTime: 0,
+};
+/**
+ * Highest priority; used to block prefetching while an actively-needed operation is enqueued.
+ */
+export const immediatePrefetchPriority = {
+    trackPriority: 9007199254740991, // Number.MAX_SAFE_INTEGER,
+    segmentStartTime: 0,
+    prefetchStartTime: 0,
+};
+/**
+ * A comparator for segment prefetching.
+ * Given tracks A, B, and C with track priorities 1, 2, and 3 respectively:
+ * The expected prefetch order will be:
+ *
+ * A0
+ * B0 // "lean forward" case
+ * C0 // "lean forward" case
+ * A1 ... An
+ * B1 ... Bn
+ * C1 ... Cn
+ *
+ * Note that background prefetching is in parallel to prefetching for the active track.
+ */
+export const segmentPriorityComparatorRef = globalRef(() => {
+    return compareBy((e) => {
+        // First segments always take priority over subsequent ones.
+        return e.segmentStartTime <= e.prefetchStartTime ? 0 : 1;
+    }, 
+    // Next, consider track priority.
+    (e) => -e.trackPriority);
+});
+// Task queues for each content type
+export const prefetchPriorityQueuesRef = globalRef(() => {
+    return {
+        video: createTaskQueue(segmentPriorityComparatorRef.value, defaultTrackPriority),
+        audio: createTaskQueue(segmentPriorityComparatorRef.value, defaultTrackPriority),
+        text: createTaskQueue(segmentPriorityComparatorRef.value, defaultTrackPriority),
+    };
+});
+/**
+ * Enqueues a task to request a streaming segment for a specific content type.
+ * This should only be used for low priority background requests. Active tracks should request without
+ * prioritization for the immediately needed segment.
+ * Tracks are expected to prefetch one segment at a time, in order.
+ *
+ * @param requestTask
+ * @param contentType
+ * @param priority
+ */
+export function enqueueSegmentPrefetch(requestTask, contentType, priority) {
+    return prefetchPriorityQueuesRef.value[contentType].enqueue(requestTask, priority);
+}

package/dist/types/current/streaming/SegmentReference.d.ts

@@ -0,0 +1,48 @@
+import type { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+export interface MediaSegmentMetadata {
+    /**
+     * The timestamp offset of the segment.
+     * Should be used as the append timestamp offset.
+     * This is in seconds, relative to the MPD timeline.
+     * For example if the first segment has a timestampOffset of -2 and startTime of 0, playback will begin 2s into the
+     * start of that segment.
+     */
+    readonly timestampOffset: number;
+    /**
+     * The start time of the segment, in seconds.
+     * Relative to the MPD timeline.
+     * Should be used as the append window start.
+     */
+    readonly startTime: number;
+    /**
+     * The end time of the segment, in seconds.
+     * Relative to the MPD timeline.
+     * Should be used as the append window end.
+     */
+    readonly endTime: number;
+}
+export interface InitSegmentReference<T> {
+    /**
+     * Metadata describing the media encoding.
+     */
+    readonly quality: MediaQualityMetadata;
+    /**
+     * References initialization data for this segment.
+     * Must be appended before `data` if the decoderId has changed from the last buffered
+     * segment.
+     * This is a shared reference between other streaming segments of the same quality/representation.
+     */
+    readonly initData: T;
+}
+export interface MediaSegmentReference<T> extends MediaSegmentMetadata {
+    /**
+     * Provides the media data.
+     */
+    readonly data: T;
+}
+/**
+ * A reference, with metadata, to streaming and initialization data.
+ */
+export interface SegmentReference<T> extends InitSegmentReference<T>, MediaSegmentReference<T> {
+}
+//# sourceMappingURL=SegmentReference.d.ts.map

package/dist/types/current/streaming/SegmentReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentReference.d.ts","sourceRoot":"","sources":["../../../../src/streaming/SegmentReference.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAE5E,MAAM,WAAW,oBAAoB;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACnC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAA;IAEtC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,CAAE,SAAQ,oBAAoB;IAClE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAC/B,SAAQ,oBAAoB,CAAC,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC;CAAG"}

package/dist/types/current/streaming/SegmentReference.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/streaming/StreamingEventMap.d.ts

@@ -0,0 +1,57 @@
+import type { ChangeEvent } from '../event/ChangeEvent';
+import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { BasicErrorEvent } from '../event/BasicErrorEvent';
+import type { AnyRecord } from '@amazon/vinyl-util';
+/**
+ * Events a track dispatches related to streaming quality and status.
+ */
+export interface StreamingEventMap {
+    /**
+     * The actively streamed content types have changed.
+     */
+    readonly contentTypesChange: ChangeEvent<ReadonlySet<ContentType>>;
+    /**
+     * fetchedRanges have been updated.
+     */
+    readonly fetchedRangesChange: AnyRecord;
+    /**
+     * Dispatched when the currently streaming quality changes.
+     * This is dispatched when a new streaming quality has been requested.
+     */
+    readonly streamingQualityChange: ChangeEvent<MediaQualityMetadata | null>;
+    /**
+     * Dispatched when the currently buffering quality changes.
+     * This is dispatched before the segment is appended.
+     */
+    readonly bufferingQualityChange: ChangeEvent<MediaQualityMetadata | null>;
+    /**
+     * The currently playing quality has changed.
+     */
+    readonly playbackQualityChange: ChangeEvent<MediaQualityMetadata | null>;
+    /**
+     * The last segment has finished appending.
+     */
+    readonly bufferingEnded: AnyRecord;
+    /**
+     * Dispatched when a streaming error occurs.
+     */
+    readonly error: BasicErrorEvent;
+    /**
+     * Emitted when the error state has been reset.
+     */
+    readonly reset: AnyRecord;
+    /**
+     * The available qualities for the current period have changed.
+     */
+    readonly qualitiesChange: ChangeEvent<readonly MediaQualityMetadata[]>;
+    /**
+     * The available unfiltered qualities for the current period have changed.
+     */
+    readonly qualitiesUnfilteredChange: ChangeEvent<readonly MediaQualityMetadata[]>;
+}
+/**
+ * All streaming-related events a track may emit.
+ * These will be bubbled by the player.
+ */
+export declare const ALL_STREAMING_EVENTS: readonly ["contentTypesChange", "fetchedRangesChange", "streamingQualityChange", "bufferingQualityChange", "playbackQualityChange", "bufferingEnded", "error", "reset", "qualitiesChange", "qualitiesUnfilteredChange"];
+//# sourceMappingURL=StreamingEventMap.d.ts.map

package/dist/types/current/streaming/StreamingEventMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingEventMap.d.ts","sourceRoot":"","sources":["../../../../src/streaming/StreamingEventMap.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,KAAK,EACR,WAAW,EACX,oBAAoB,EACvB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;OAEG;IACH,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAA;IAElE;;OAEG;IACH,QAAQ,CAAC,mBAAmB,EAAE,SAAS,CAAA;IAEvC;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,EAAE,WAAW,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAA;IAEzE;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,EAAE,WAAW,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAA;IAEzE;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,WAAW,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAA;IAExE;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAA;IAElC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;IAE/B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IAEzB;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,SAAS,oBAAoB,EAAE,CAAC,CAAA;IAEtE;;OAEG;IACH,QAAQ,CAAC,yBAAyB,EAAE,WAAW,CAC3C,SAAS,oBAAoB,EAAE,CAClC,CAAA;CACJ;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,yNAWwB,CAAA"}

package/dist/types/current/streaming/StreamingEventMap.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * All streaming-related events a track may emit.
+ * These will be bubbled by the player.
+ */
+export const ALL_STREAMING_EVENTS = [
+    'contentTypesChange',
+    'fetchedRangesChange',
+    'streamingQualityChange',
+    'bufferingQualityChange',
+    'playbackQualityChange',
+    'bufferingEnded',
+    'error',
+    'reset',
+    'qualitiesChange',
+    'qualitiesUnfilteredChange',
+];

package/dist/types/current/streaming/abr/QualitySelector.d.ts

@@ -0,0 +1,33 @@
+import type { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+export interface PrefetchState {
+    /**
+     * The number of seconds currently prefetched.
+     */
+    readonly fetchedTime: number;
+    /**
+     * The quality metadata of the previous segment. Quality selection may have a bias to prefer avoiding
+     * decoder re-initialization.
+     */
+    readonly previousQuality: MediaQualityMetadata | null;
+    /**
+     * True when prefetching for the active track.
+     */
+    readonly active: boolean;
+}
+export interface QualitySelector {
+    /**
+     * Returns the quality that should currently be streamed.
+     *
+     * @param qualities A sorted list of qualities for the currently streaming media.
+     * All qualities are expected to be playable.
+     *
+     * Higher bandwidth values are expected to also mean higher quality.
+     * That is, if there are multiple playable qualities where one has a higher quality ranking and lower bandwidth,
+     * the less efficient representation should be filtered out before the request.
+     * @param prefetchState The current prefetch state.
+     *
+     * @return Returns the index of the quality to stream.
+     */
+    selectQuality(qualities: readonly MediaQualityMetadata[], prefetchState: PrefetchState): number;
+}
+//# sourceMappingURL=QualitySelector.d.ts.map

package/dist/types/current/streaming/abr/QualitySelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QualitySelector.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/abr/QualitySelector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAE5E,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAE5B;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAC3B;AAED,MAAM,WAAW,eAAe;IAC5B;;;;;;;;;;;;OAYG;IACH,aAAa,CACT,SAAS,EAAE,SAAS,oBAAoB,EAAE,EAC1C,aAAa,EAAE,aAAa,GAC7B,MAAM,CAAA;CACZ"}

package/dist/types/current/streaming/abr/QualitySelector.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/streaming/abr/QualitySelectorImpl.d.ts

@@ -0,0 +1,100 @@
+import type { PrefetchState, QualitySelector } from '../../streaming/abr/QualitySelector';
+import { type Disposable, type LogTarget } from '@amazon/vinyl-util';
+import { type ObjectSchema } from '@amazon/vinyl-validation';
+import type { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+export interface QualitySelectorImplOptions {
+    /**
+     * If at least this amount of time (in seconds) is currently fetched, don't consider an ABR-down.
+     * Also used as the upper bound for interpolating between {@link bandwidthMultiplierLow} and
+     * {@link bandwidthMultiplierHigh} based on the current fetched time.
+     * Default: 15
+     */
+    readonly highBufferThreshold?: number;
+    /**
+     * If less than this amount of time (in seconds) is currently fetched, don't consider an ABR-up.
+     * Default: 4
+     */
+    readonly lowBufferThreshold?: number;
+    /**
+     * Defines the strategy used for quality selection.
+     *
+     * Default: BEST (ABR will be enabled)
+     */
+    readonly strategy?: AbrStrategy;
+    /**
+     * A multiplier applied to the estimated bandwidth when the fetched buffer is empty (0 seconds).
+     * Lower values are more conservative (reduce the bandwidth used for quality selection) and help
+     * avoid rebuffers when the buffer is low.
+     *
+     * As the fetched buffer fills toward {@link highBufferThreshold}, the effective multiplier
+     * linearly interpolates between this value and {@link bandwidthMultiplierHigh}.
+     *
+     * Default: 0.4
+     */
+    readonly bandwidthMultiplierLow?: number;
+    /**
+     * A multiplier applied to the estimated bandwidth when the fetched buffer is at or above
+     * {@link highBufferThreshold}. Higher values are more optimistic and allow selection of higher
+     * qualities once enough data is buffered to absorb short-term bandwidth dips.
+     *
+     * As the fetched buffer fills from 0 toward {@link highBufferThreshold}, the effective multiplier
+     * linearly interpolates between {@link bandwidthMultiplierLow} and this value.
+     *
+     * Default: 0.9
+     */
+    readonly bandwidthMultiplierHigh?: number;
+    /**
+     * When true, avoids changing codecs when considering choosing a higher audio bitrate
+     * than what is currently playing. A decoder re-initialization is often an audible change,
+     * so consumers that prefer to avoid audible artifacts may enable this. ABR-down is still
+     * allowed across decoders because the subtle audio artifact is more desirable than a rebuffer.
+     * Default: false
+     */
+    readonly restrictDecoderChangeOnAudioAbrUp?: boolean;
+}
+export declare enum AbrStrategy {
+    /**
+     * Selects lowest quality, regardless of bandwidth conditions.
+     */
+    LOWEST = "lowest",
+    /**
+     * Selects highest quality, regardless of bandwidth conditions.
+     */
+    HIGHEST = "highest",
+    /**
+     * Selects the best quality based on user bandwidth data.
+     * Uses an EWMA estimation.
+     */
+    BEST = "best",
+    /**
+     * Selects the initial quality based on bandwidth information, but will not change qualities mid-stream.
+     *
+     * May choose new quality after streaming clear, such as after a seek.
+     */
+    FIXED = "fixed"
+}
+export declare const qualitySelectorImplOptionsValidator: ObjectSchema<QualitySelectorImplOptions>;
+export declare const defaultQualitySelectorImplOptions: {
+    readonly highBufferThreshold: 15;
+    readonly lowBufferThreshold: 4;
+    readonly strategy: AbrStrategy.BEST;
+    readonly bandwidthMultiplierLow: 0.4;
+    readonly bandwidthMultiplierHigh: 0.9;
+    readonly restrictDecoderChangeOnAudioAbrUp: false;
+};
+export interface QualitySelectorImplDeps {
+    readonly options: ObservableValue<QualitySelectorImplOptions>;
+}
+export declare class QualitySelectorImpl implements QualitySelector, LogTarget, Disposable {
+    get [Symbol.toStringTag](): string;
+    readonly logPrefix: string;
+    private _options;
+    private disposer;
+    constructor(deps: QualitySelectorImplDeps);
+    get options(): Required<QualitySelectorImplOptions>;
+    selectQuality(qualities: readonly MediaQualityMetadata[], prefetchState: PrefetchState): number;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=QualitySelectorImpl.d.ts.map

package/dist/types/current/streaming/abr/QualitySelectorImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QualitySelectorImpl.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/abr/QualitySelectorImpl.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,aAAa,EACb,eAAe,EAClB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAIH,KAAK,UAAU,EAEf,KAAK,SAAS,EAEjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAKH,KAAK,YAAY,EACpB,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,MAAM,WAAW,0BAA0B;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAErC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAEpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAA;IAE/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAExC;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAEzC;;;;;;OAMG;IACH,QAAQ,CAAC,iCAAiC,CAAC,EAAE,OAAO,CAAA;CACvD;AAED,oBAAY,WAAW;IACnB;;OAEG;IACH,MAAM,WAAW;IAEjB;;OAEG;IACH,OAAO,YAAY;IAEnB;;;OAGG;IACH,IAAI,SAAS;IAEb;;;;OAIG;IACH,KAAK,UAAU;CAClB;AAED,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,0BAA0B,CAQnF,CAAA;AAEN,eAAO,MAAM,iCAAiC;;;;;;;CAOC,CAAA;AAE/C,MAAM,WAAW,uBAAuB;IACpC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC,0BAA0B,CAAC,CAAA;CAChE;AAED,qBAAa,mBACT,YAAW,eAAe,EAAE,SAAS,EAAE,UAAU;IAEjD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,QAAQ,CAAC,SAAS,SAAwB;IAC1C,OAAO,CAAC,QAAQ,CACqB;IAErC,OAAO,CAAC,QAAQ,CAAmB;gBAEvB,IAAI,EAAE,uBAAuB;IASzC,IAAI,OAAO,IAAI,QAAQ,CAAC,0BAA0B,CAAC,CAElD;IAED,aAAa,CACT,SAAS,EAAE,SAAS,oBAAoB,EAAE,EAC1C,aAAa,EAAE,aAAa,GAC7B,MAAM;IA0GT,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO;CAGV"}