@amazon/vinyl 1.0.0

package/dist/types/current/streaming/buffering/BufferingController.js

@@ -0,0 +1,482 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createAbortSlot, createDisposer, createTaskQueue, EventHostImpl, getLogLevel, isSilentError, LinkedList, logDebug, LogLevel, logVerbose, logWarn, throttle, } from '@amazon/vinyl-util';
+import { LIVE_DURATION } from '../../playback/PlaybackController';
+import { SEGMENT_START_AFFORDANCE } from '../../streaming/SegmentController';
+/**
+ * Chrome 52 has decoding errors when duration is set to the mediaPresentationDuration.
+ * Adds a slight padding as a workaround.
+ * @private
+ */
+export const DURATION_PADDING = 0.1;
+/**
+ * The interval to throttle polling the buffer.
+ * Reset after a seek.
+ * @private
+ */
+export const POLL_BUFFER_THROTTLE = 0.1;
+/**
+ * If segments are too large to append, reduces the max append size.
+ */
+export const QUOTA_REACHED_SCALE = 0.8;
+/**
+ * If quota exceeded errors are hit, the max append size will not be reduced below this value and the buffering
+ * controller will be set to an erred state.
+ */
+export const MIN_APPEND_SIZE = 524288; // 512 * 1024
+/**
+ * If the content type does not match a config setting.
+ */
+export const DEFAULT_MAX_APPEND_SIZE = 10485760; // 10 * 1024 * 1024
+/**
+ * The measured source buffer quotas.
+ */
+const sourceBufferQuotas = new Map();
+/**
+ * Clears the current estimated source buffer quota.
+ * @private
+ */
+export function clearSourceBufferQuota() {
+    sourceBufferQuotas.clear();
+}
+/**
+ * Returns the measured source buffer quota for the given content type.
+ * Will return null if the quota was never reached.
+ *
+ * @param contentType
+ */
+export function getSourceBufferQuota(contentType) {
+    return sourceBufferQuotas.get(contentType) ?? null;
+}
+const defaultBufferingControllerOptions = {
+    minBuffer: 4.0,
+    maxAppendSize: {
+        audio: 10485760, // 10 * 1024 * 1024
+        video: 157286400, // 150 * 1024 * 1024
+    },
+};
+/**
+ * The buffering controller is responsible for requesting and appending segments to the source
+ * buffer controller.
+ */
+export class BufferingControllerImpl extends EventHostImpl {
+    deps;
+    contentType;
+    get [Symbol.toStringTag]() {
+        return 'BufferingControllerImpl';
+    }
+    options;
+    mediaSourceController;
+    playbackController;
+    segmentController;
+    sourceBufferController = null;
+    decoderId = null;
+    /**
+     * The currently buffered segments.
+     */
+    buffered = new LinkedList();
+    appendOffset = 0;
+    /**
+     * The currently buffering quality.
+     */
+    _bufferingQuality = null;
+    /**
+     * If true and in a bufferingEnded state, the segment provider will be queried again.
+     * This will be set to true after the segment controller reports a change event, indicating that there may be new
+     * segments to append.
+     */
+    reopen = false;
+    _error = null;
+    _bufferingEnded = false;
+    queue = createTaskQueue();
+    disposer = createDisposer();
+    _active = false;
+    activateDisposer = null;
+    segmentAbort = createAbortSlot();
+    constructor(deps, contentType, options) {
+        super();
+        this.deps = deps;
+        this.contentType = contentType;
+        this.options = {
+            ...defaultBufferingControllerOptions,
+            ...options,
+        };
+        logDebug(this, 'constructed', this.options);
+        this.mediaSourceController = deps.mediaSourceController;
+        this.playbackController = deps.playbackController;
+        this.segmentController = deps.segmentController;
+    }
+    get active() {
+        return this._active;
+    }
+    /**
+     * Activates the buffering controller, watching the playhead and segment controller.
+     */
+    activate() {
+        if (this._active)
+            return;
+        this._active = true;
+        logDebug(this, 'activate');
+        this.activateDisposer = createDisposer();
+        const { add } = this.activateDisposer;
+        this.sourceBufferController = add(this.deps.sourceBufferControllerFactory());
+        add(this.playbackController.on('timeUpdate', this.pollBuffer));
+        add(this.playbackController.on('seeking', () => {
+            this.clear();
+        }));
+        const onMediaSourceOpen = () => {
+            logDebug(this, 'media source opened');
+            this.refreshDuration();
+            this.pollBufferImmediate();
+        };
+        if (this.mediaSourceOpen) {
+            onMediaSourceOpen();
+        }
+        else {
+            add(this.mediaSourceController.on('sourceOpen', onMediaSourceOpen));
+        }
+        add(this.segmentController.on('change', () => {
+            this.reopen = true;
+            this.refreshDuration();
+            this.pollBufferImmediate();
+        }));
+    }
+    deactivate() {
+        if (!this._active)
+            return;
+        logDebug(this, 'deactivate');
+        this.abortCurrentSegment();
+        this.resetBufferedState();
+        this.activateDisposer.dispose();
+        this.activateDisposer = null;
+        this.sourceBufferController = null;
+        this._active = false;
+    }
+    reset() {
+        if (!this._error) {
+            logDebug(this, 'reset no-op');
+            return;
+        }
+        logDebug(this, 'reset');
+        this._error = null;
+        this.pollBufferImmediate();
+    }
+    /**
+     * Returns true if there are active operations.
+     */
+    get busy() {
+        return this.queue.running > 0;
+    }
+    /**
+     * Enqueues a duration update.
+     */
+    refreshDuration() {
+        this.sourceBufferController.enqueue(async () => {
+            if (!this.mediaSourceOpen)
+                return; // Cannot set duration when media source is not open.
+            const duration = await this.segmentController.getDuration();
+            // For live streams, set the duration to LIVE_DURATION; not all browsers support +Infinity duration.
+            const newDuration = duration == null ? LIVE_DURATION : duration + DURATION_PADDING;
+            logDebug(this, `setting duration: ${newDuration}`);
+            this.mediaSourceController.duration = newDuration;
+        }).catch(this.handleError);
+    }
+    /**
+     * Resets the throttle and polls the buffer on the next frame.
+     */
+    pollBufferImmediate = () => {
+        this.pollBuffer.reset();
+        setTimeout(() => {
+            if (this.active)
+                this.pollBuffer();
+        });
+    };
+    /**
+     * If buffered time reaches below minBuffer, request the segment for the next unbuffered
+     * time and append.
+     * @private
+     */
+    pollBuffer = this.disposer.add(throttle(() => {
+        const time = this.playbackController.currentTime;
+        if (getLogLevel() === LogLevel.VERBOSE) {
+            logVerbose(this, `pollBuffer time: ${time}, bufferedTime: ${this.getBufferedTime()}, busy: ${this.busy}, error: ${this.error != null}, readyState: ${this.mediaSourceController.readyState}`);
+        }
+        this.refreshHead();
+        if (!this.shouldAppend())
+            return;
+        this.reopen = false;
+        this.queue
+            .enqueue(() => this.appendNext())
+            .catch(this.handleError)
+            // An append has finished. Poll again on the next frame.
+            // The append either completed successfully, erred fatally (setting an error state),
+            // or erred silently (an abort).
+            .finally(this.pollBufferImmediate);
+    }, POLL_BUFFER_THROTTLE, {
+        leading: true,
+        trailing: true,
+    }));
+    shouldAppend() {
+        return (this.active &&
+            !this.busy &&
+            !this.error &&
+            !this.mediaSourceClosed &&
+            (!this.bufferingEnded || this.reopen) &&
+            // Return true if the current buffer is less than the minimum buffer and the playhead has not reached duration.
+            this.getBufferedTime() <= this.options.minBuffer);
+    }
+    /**
+     * The buffered segment at the playhead.
+     */
+    get head() {
+        return this.buffered.head?.value;
+    }
+    /**
+     * The most recently buffered segment.
+     */
+    get tail() {
+        return this.buffered.tail?.value;
+    }
+    async appendNext() {
+        logVerbose(this, 'appendNext');
+        const sourceBufferController = this.sourceBufferController;
+        const time = this.playbackController.currentTime;
+        const tail = this.tail;
+        let streamingSegment;
+        // If appendOffset is less than the last buffered segment size, this indicates a partial append, continue
+        // buffering the last segment.
+        if (tail && this.appendOffset < tail.data.byteLength) {
+            streamingSegment = tail;
+        }
+        else {
+            streamingSegment = await this.segmentController.getSegment(
+            // If buffering is a continuation from the previous segment, use its end time.
+            // Otherwise, start streaming from slightly behind the playhead.
+            tail?.endTime ?? time - SEGMENT_START_AFFORDANCE, this.segmentAbort.value);
+            logVerbose(this, 'streamingSegment', streamingSegment);
+            if (streamingSegment)
+                this.appendOffset = 0;
+        }
+        if (!streamingSegment) {
+            await sourceBufferController.enqueue(() => {
+                if (this.mediaSourceOpen)
+                    this.endBuffering();
+            });
+            return;
+        }
+        this.bufferingQuality = streamingSegment.quality;
+        if (this.decoderId !== streamingSegment.quality.decoderId) {
+            // Append the initialization segment before the media segment if the decoder
+            // needs (re)-initialization.
+            this.decoderId = null;
+            await sourceBufferController.appendInit(streamingSegment.initData, streamingSegment.quality.mimeType);
+            this.decoderId = streamingSegment.quality.decoderId;
+        }
+        // Set the timestamp offset only if appending from an unbuffered position.
+        if (!tail) {
+            await sourceBufferController.setTimestampOffset(streamingSegment.timestampOffset);
+        }
+        const maxAppendSize = this.getMaxAppendSize(streamingSegment.quality.contentType);
+        const currentBitrate = streamingSegment.data.byteLength /
+            (streamingSegment.endTime - streamingSegment.startTime);
+        const appendSize = maxAppendSize - currentBitrate * this.getBufferedTime();
+        if (appendSize <= 0) {
+            // current buffered data is filling entire quota
+            return;
+        }
+        const byteLength = streamingSegment.data.byteLength;
+        if (byteLength > appendSize) {
+            const newOffset = this.appendOffset + appendSize;
+            const chunk = streamingSegment.data.slice(this.appendOffset, newOffset);
+            await sourceBufferController.append(chunk);
+            if (this.appendOffset === 0) {
+                this.buffered.push(streamingSegment);
+            }
+            this.appendOffset = newOffset;
+            logVerbose(this, `appended chunk, this.appendOffset: ${this.appendOffset}`);
+        }
+        else {
+            await sourceBufferController.append(streamingSegment.data);
+            this.appendOffset = streamingSegment.data.byteLength;
+            this.buffered.push(streamingSegment);
+        }
+        if (!tail)
+            this.refreshHead(); // Update quality immediately if buffer was empty
+    }
+    abortCurrentSegment() {
+        this.segmentAbort.abort();
+    }
+    /**
+     * Checks if the playhead has progressed past the current head segment and shifts the linked list.
+     * Updates the playback quality if changed.
+     */
+    refreshHead() {
+        const head = this.head;
+        const tail = this.tail;
+        const time = this.playbackController.currentTime;
+        if (head && time >= head.endTime && head !== tail) {
+            // The playhead has passed the end of the head segment.
+            this.buffered.shift();
+        }
+        this.playbackQuality = this.head?.quality ?? null;
+    }
+    getMaxAppendSize(contentType) {
+        const maxAppendSize = this.options.maxAppendSize[contentType] ?? DEFAULT_MAX_APPEND_SIZE;
+        const sourceBufferQuota = sourceBufferQuotas.get(contentType);
+        return sourceBufferQuota == null
+            ? maxAppendSize
+            : Math.min(sourceBufferQuota, maxAppendSize);
+    }
+    _playbackQuality = null;
+    get playbackQuality() {
+        return this._playbackQuality;
+    }
+    /**
+     * Returns the quality currently buffering.
+     */
+    get bufferingQuality() {
+        return this._bufferingQuality;
+    }
+    set bufferingQuality(value) {
+        const previous = this._bufferingQuality;
+        if (value?.qualityId === previous?.qualityId)
+            return;
+        this._bufferingQuality = value;
+        logDebug(this, 'bufferingQualityChange', value);
+        this.dispatch('bufferingQualityChange', {
+            previous,
+            current: value,
+        });
+    }
+    /**
+     * Sets the current playback quality and emits a playbackQualityChange event.
+     * No-ops if quality id has not changed.
+     */
+    set playbackQuality(value) {
+        const previous = this._playbackQuality;
+        if (value?.qualityId === previous?.qualityId)
+            return;
+        this._playbackQuality = value;
+        logDebug(this, 'playbackQualityChange', value);
+        this.dispatch('playbackQualityChange', {
+            previous,
+            current: value,
+        });
+    }
+    /**
+     * The last error emitted.
+     * Buffering will halt if this controller is in an error state.
+     * Deactivating this controller will reset the error state.
+     */
+    get error() {
+        return this._error;
+    }
+    /**
+     * Returns true if the media source's ready state is 'open'
+     */
+    get mediaSourceOpen() {
+        return this.mediaSourceController.readyState === 'open';
+    }
+    /**
+     * Returns true if the media source's ready state is 'closed'
+     */
+    get mediaSourceClosed() {
+        return this.mediaSourceController.readyState === 'closed';
+    }
+    /**
+     * Returns true if the last segment has been appended.
+     */
+    get bufferingEnded() {
+        return this._bufferingEnded;
+    }
+    handleError = (error) => {
+        if ('name' in error && error.name === 'QuotaExceededError') {
+            const contentType = this.bufferingQuality?.contentType;
+            if (contentType) {
+                const newAppendSize = this.getMaxAppendSize(contentType) * QUOTA_REACHED_SCALE;
+                if (newAppendSize >= MIN_APPEND_SIZE) {
+                    sourceBufferQuotas.set(contentType, newAppendSize);
+                    logWarn(this, 'QuotaExceededError, new source buffer limit:', (newAppendSize / 1024 / 1024).toFixed(1) + ' MiB');
+                    const sourceBufferController = this.sourceBufferController;
+                    if (sourceBufferController) {
+                        this.clear();
+                    }
+                    return; // If the quota size was successfully reduced, do not err and try again.
+                }
+            }
+        }
+        if (!isSilentError(error)) {
+            // Set this controller to an error state. If in an error state, buffering will
+            // not continue.
+            this._error = error;
+            this.dispatch('error', {
+                target: this,
+                error,
+            });
+        }
+    };
+    /**
+     * Returns the amount of time buffered at the current media position.
+     * @private
+     */
+    getBufferedTime() {
+        if (!this.active)
+            return 0;
+        const time = this.playbackController.currentTime;
+        const range = this.sourceBufferController.buffered.getRangeAt(time);
+        if (!range)
+            return 0;
+        return range[1] - time;
+    }
+    /**
+     * Cancels any currently buffering fragments and clears the source buffer.
+     */
+    clear() {
+        if (!this.active)
+            return;
+        logDebug(this, 'clear');
+        this.abortCurrentSegment();
+        // Enqueue clearing the buffer and buffered list.
+        this.queue
+            .enqueue(this.finishAndClearBuffers)
+            .catch(this.handleError)
+            .finally(() => {
+            this.resetBufferedState();
+            this.pollBufferImmediate();
+        });
+    }
+    endBuffering() {
+        logDebug(this, 'bufferingEnded');
+        this._bufferingEnded = true;
+        this.bufferingQuality = null;
+        this.dispatch('bufferingEnded', {});
+    }
+    resetBufferedState() {
+        this.decoderId = null;
+        this.appendOffset = 0;
+        this.buffered.clear();
+        this._bufferingEnded = false;
+        this.bufferingQuality = null;
+        this.playbackQuality = null;
+    }
+    /**
+     * Finish any partial appends and clear the source buffer.
+     */
+    finishAndClearBuffers = async () => {
+        if (!this.active)
+            return;
+        logVerbose(this, 'finishAndClearBuffers');
+        await this.sourceBufferController.clear();
+        logVerbose(this, 'finishAndClearBuffers complete');
+    };
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    dispose() {
+        this.deactivate();
+        super.dispose();
+        this.disposer.dispose();
+    }
+}

package/dist/types/current/streaming/buffering/MediaSourceController.d.ts

@@ -0,0 +1,103 @@
+import { type AnyRecord, type Disposable, EventHostImpl, type Json, type LogTarget, type ReadonlyEventHost, ReportableError } from '@amazon/vinyl-util';
+import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import type { BasicErrorEvent } from '../../event/BasicErrorEvent';
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+export interface SourceBufferRef extends Disposable {
+    /**
+     * The source buffer.
+     */
+    readonly value: SourceBuffer;
+}
+export interface MediaSourceControllerEventMap {
+    /**
+     * The media source has entered a 'closed' state.
+     */
+    readonly sourceClose: AnyRecord;
+    /**
+     * The media source has entered an 'ended' state.
+     */
+    readonly sourceEnded: AnyRecord;
+    /**
+     * The media source has entered an 'open' state.
+     */
+    readonly sourceOpen: AnyRecord;
+    /**
+     * All source buffers have been created and data may be appended.
+     */
+    readonly readyToAppend: AnyRecord;
+    /**
+     * An error has occurred.
+     */
+    readonly error: BasicErrorEvent;
+}
+export interface ReadonlyMediaSourceController extends ReadonlyEventHost<MediaSourceControllerEventMap> {
+    /**
+     * Returns the parent media source ready state.
+     */
+    readonly readyState: ReadyState;
+    /**
+     * Gets the media source's duration.
+     */
+    readonly duration: number;
+    /**
+     * True if all source buffers have been created and data may be appended.
+     */
+    readonly readyToAppend: boolean;
+}
+export interface MediaSourceController extends ReadonlyMediaSourceController {
+    /**
+     * Sets/gets the media source's duration.
+     */
+    duration: number;
+    /**
+     * Constructs a new SourceBuffer with the given content type and mime type.
+     */
+    createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
+    /**
+     * Signals the end of the stream.
+     * @param error A string representing an error to throw when the end of the stream is reached.
+     */
+    endOfStream(error?: EndOfStreamError): void;
+    /**
+     * Creates an Object URL to use as the source for this stream.
+     */
+    createUrl(): string;
+}
+export interface MediaSourceControllerImplDeps {
+    /**
+     * Creates a new media source.
+     */
+    readonly mediaSourceFactory: () => MediaSource;
+    /**
+     * Provides the streams that must be created before appending.
+     */
+    readonly contentTypesValue: ContentTypesValue;
+}
+export declare class MediaSourceControllerImpl extends EventHostImpl<MediaSourceControllerEventMap> implements MediaSourceController, LogTarget {
+    get [Symbol.toStringTag](): string;
+    private sourceBufferCount;
+    private readonly mediaSource;
+    private readonly disposer;
+    private contentTypes;
+    constructor(deps: MediaSourceControllerImplDeps);
+    private initializeEvents;
+    get duration(): number;
+    set duration(value: number);
+    get readyState(): ReadyState;
+    createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
+    /**
+     * Emits a 'readyToAppend' event if all source buffers have been created.
+     */
+    private readonly checkReady;
+    endOfStream(error?: EndOfStreamError): void;
+    createUrl(): string;
+    get readyToAppend(): boolean;
+    dispose(): void;
+}
+export declare class MediaSourceError extends ReportableError {
+    private readonly reason;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, reason: Error);
+    toJSON(): Json;
+}
+//# sourceMappingURL=MediaSourceController.d.ts.map

package/dist/types/current/streaming/buffering/MediaSourceController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaSourceController.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/buffering/MediaSourceController.ts"],"names":[],"mappings":"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"}