rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/main_thread/init/utils/get_initial_time.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getInitialTime;
+var config_1 = require("../../../config");
+var log_1 = require("../../../log");
+var manifest_1 = require("../../../manifest");
+var is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
+var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+/**
+ * Returns the calculated initial time for the content described by the given
+ * Manifest:
+ *   1. if a start time is defined by user, calculate starting time from the
+ *      manifest information
+ *   2. else if the media is live, use the live edge and suggested delays from
+ *      it
+ *   3. else returns the minimum time announced in the manifest
+ * @param {Manifest} manifest
+ * @param {boolean} lowLatencyMode
+ * @param {Object} startAt
+ * @returns {Number}
+ */
+function getInitialTime(manifest, lowLatencyMode, startAt) {
+    var _a;
+    if (!(0, is_null_or_undefined_1.default)(startAt)) {
+        var min = (0, manifest_1.getMinimumSafePosition)(manifest);
+        var max = (0, manifest_1.getMaximumSafePosition)(manifest);
+        if (!(0, is_null_or_undefined_1.default)(startAt.position)) {
+            log_1.default.debug("Init", "Initial Position: using startAt.position", {
+                position: startAt.position,
+                min: min,
+                max: max,
+                isDynamic: manifest.isDynamic,
+            });
+            if (manifest.isDynamic) {
+                return startAt.position;
+            }
+            return Math.max(Math.min(startAt.position, max), min);
+        }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.wallClockTime)) {
+            var ast = manifest.availabilityStartTime === undefined ? 0 : manifest.availabilityStartTime;
+            var position = startAt.wallClockTime - ast;
+            log_1.default.debug("Init", "Initial Position: using startAt.wallClockTime", {
+                wallClockTime: startAt.wallClockTime,
+                wallClockOffset: ast,
+                deOffseted: position,
+                min: min,
+                max: max,
+                isDynamic: manifest.isDynamic,
+            });
+            if (manifest.isDynamic) {
+                return position;
+            }
+            return Math.max(Math.min(position, max), min);
+        }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromFirstPosition)) {
+            var fromFirstPosition = startAt.fromFirstPosition;
+            log_1.default.debug("Init", "Initial Position: using startAt.fromFirstPosition", {
+                fromFirstPosition: fromFirstPosition,
+                min: min,
+                max: max,
+            });
+            return fromFirstPosition <= 0 ? min : Math.min(max, min + fromFirstPosition);
+        }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromLastPosition)) {
+            var fromLastPosition = startAt.fromLastPosition;
+            log_1.default.debug("Init", "Initial Position: using startAt.fromLastPosition", {
+                fromLastPosition: fromLastPosition,
+                min: min,
+                max: max,
+            });
+            return fromLastPosition >= 0 ? max : Math.max(min, max + fromLastPosition);
+        }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromLivePosition)) {
+            var livePosition = (_a = (0, manifest_1.getLivePosition)(manifest)) !== null && _a !== void 0 ? _a : max;
+            var fromLivePosition = startAt.fromLivePosition;
+            log_1.default.debug("Init", "Initial Position: using startAt.fromLivePosition", {
+                fromLivePosition: fromLivePosition,
+                livePosition: livePosition,
+                min: min,
+            });
+            return fromLivePosition >= 0
+                ? livePosition
+                : Math.max(min, livePosition + fromLivePosition);
+        }
+        else if (!(0, is_null_or_undefined_1.default)(startAt.percentage)) {
+            var percentage = startAt.percentage;
+            log_1.default.debug("Init", "Initial Position: using startAt.percentage", {
+                percentage: percentage,
+                min: min,
+                max: max,
+            });
+            if (percentage > 100) {
+                return max;
+            }
+            else if (percentage < 0) {
+                return min;
+            }
+            var ratio = +percentage / 100;
+            var extent = max - min;
+            return min + extent * ratio;
+        }
+    }
+    var minimumPosition = (0, manifest_1.getMinimumSafePosition)(manifest);
+    if (manifest.isLive) {
+        var suggestedPresentationDelay = manifest.suggestedPresentationDelay, clockOffset = manifest.clockOffset;
+        var maximumPosition = (0, manifest_1.getMaximumSafePosition)(manifest);
+        var liveTime = void 0;
+        var DEFAULT_LIVE_GAP = config_1.default.getCurrent().DEFAULT_LIVE_GAP;
+        if (clockOffset === undefined) {
+            log_1.default.info("Init", "no clock offset found for a live content, " +
+                "starting close to maximum available position", { maximumPosition: maximumPosition });
+            liveTime = maximumPosition;
+        }
+        else {
+            var ast = manifest.availabilityStartTime === undefined ? 0 : manifest.availabilityStartTime;
+            var clockRelativeLiveTime = ((0, monotonic_timestamp_1.default)() + clockOffset) / 1000 - ast;
+            liveTime = Math.min(maximumPosition, clockRelativeLiveTime);
+            log_1.default.info("Init", "clock offset found for a live content, " +
+                "checking if we can start close to it", {
+                wallClockOffset: ast,
+                clockRelativeLiveTime: clockRelativeLiveTime,
+                liveTime: liveTime,
+            });
+        }
+        var diffFromLiveTime = suggestedPresentationDelay !== null && suggestedPresentationDelay !== void 0 ? suggestedPresentationDelay : (lowLatencyMode ? DEFAULT_LIVE_GAP.LOW_LATENCY : DEFAULT_LIVE_GAP.DEFAULT);
+        log_1.default.debug("Init", "Initial Position: Applying gap from live time", {
+            liveTime: liveTime,
+            diffFromLiveTime: diffFromLiveTime,
+            minimumPosition: minimumPosition,
+        });
+        return Math.max(liveTime - diffFromLiveTime, minimumPosition);
+    }
+    log_1.default.info("Init", "Initial Position: starting at the minimum available position", {
+        minimumPosition: minimumPosition,
+    });
+    return minimumPosition;
+}

package/dist/commonjs/main_thread/init/utils/get_loaded_reference.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../playback_observer";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+/**
+ * Returns an `IReadOnlySharedReference` that switches to `true` once the
+ * content is considered loaded (i.e. once it can begin to be played).
+ * @param {Object} playbackObserver
+ * @param {boolean} isDirectfile - `true` if this is a directfile content
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+export default function getLoadedReference(playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>, isDirectfile: boolean, cancelSignal: CancellationSignal): IReadOnlySharedReference<boolean>;
+//# sourceMappingURL=get_loaded_reference.d.ts.map

package/dist/commonjs/main_thread/init/utils/get_loaded_reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_loaded_reference.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/init/utils/get_loaded_reference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EACV,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAGxE;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,gBAAgB,EAAE,yBAAyB,CAAC,oBAAoB,CAAC,EACjE,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,kBAAkB,GAC/B,wBAAwB,CAAC,OAAO,CAAC,CA0CnC"}

package/dist/commonjs/main_thread/init/utils/get_loaded_reference.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getLoadedReference;
+var should_validate_metadata_1 = require("../../../compat/should_validate_metadata");
+var should_wait_for_data_before_loaded_1 = require("../../../compat/should_wait_for_data_before_loaded");
+var should_wait_for_have_enough_data_1 = require("../../../compat/should_wait_for_have_enough_data");
+var reference_1 = require("../../../utils/reference");
+var task_canceller_1 = require("../../../utils/task_canceller");
+/**
+ * Returns an `IReadOnlySharedReference` that switches to `true` once the
+ * content is considered loaded (i.e. once it can begin to be played).
+ * @param {Object} playbackObserver
+ * @param {boolean} isDirectfile - `true` if this is a directfile content
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function getLoadedReference(playbackObserver, isDirectfile, cancelSignal) {
+    var listenCanceller = new task_canceller_1.default("Loaded Reference update");
+    listenCanceller.linkToSignal(cancelSignal);
+    var isLoaded = new reference_1.default(false, listenCanceller.signal);
+    playbackObserver.listen(function (observation) {
+        if (observation.rebuffering !== null ||
+            observation.freezing !== null ||
+            observation.readyState === 0) {
+            return;
+        }
+        if (!(0, should_wait_for_data_before_loaded_1.default)(isDirectfile)) {
+            // The duration is NaN if no media data is available,
+            // which means media is not loaded yet.
+            if (isNaN(observation.duration)) {
+                return;
+            }
+            if (observation.duration > 0) {
+                isLoaded.setValue(true);
+                listenCanceller.cancel("Content Loaded");
+                return;
+            }
+        }
+        var minReadyState = (0, should_wait_for_have_enough_data_1.default)() ? 4 : 3;
+        if (observation.readyState >= minReadyState) {
+            if (observation.currentRange !== null || observation.ended) {
+                if (!(0, should_validate_metadata_1.default)() || observation.duration > 0) {
+                    isLoaded.setValue(true);
+                    listenCanceller.cancel("Content Loaded");
+                    return;
+                }
+            }
+        }
+    }, { includeLastObservation: true, clearSignal: listenCanceller.signal });
+    return isLoaded;
+}

package/dist/commonjs/main_thread/init/utils/initial_seek_and_play.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import type { IMediaElementPlaybackObserver } from "../../../playback_observer";
+import type { IPlayerError } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+/** Event emitted when trying to perform the initial `play`. */
+export type IInitialPlayEvent = 
+/** Autoplay is not enabled, but all required steps to do so are there. */
+{
+    type: "skipped";
+}
+/**
+ * Tried to play, but autoplay is blocked by the browser.
+ * A corresponding warning should have already been sent.
+ */
+ | {
+    type: "autoplay-blocked";
+}
+/** Autoplay was done with success. */
+ | {
+    type: "autoplay";
+};
+/** Object returned by `initialSeekAndPlay`. */
+export interface IInitialSeekAndPlayObject {
+    /** Emit the result of the auto-play operation, once performed. */
+    autoPlayResult: Promise<IInitialPlayEvent>;
+    /**
+     * Shared reference whose value becomes `true` once the initial play has
+     * been considered / has been done by `performInitialSeekAndPlay`.
+     */
+    initialPlayPerformed: IReadOnlySharedReference<boolean>;
+}
+/**
+ * Seek as soon as possible at the initially wanted position and play if
+ * autoPlay is wanted.
+ * @param {Object} args
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+export default function performInitialSeekAndPlay({ mediaElement, playbackObserver, startTime, mustAutoPlay, isDirectfile, onWarning, }: {
+    mediaElement: IMediaElement;
+    playbackObserver: IMediaElementPlaybackObserver;
+    startTime: number | (() => number | undefined);
+    mustAutoPlay: boolean;
+    isDirectfile: boolean;
+    onWarning: (err: IPlayerError) => void;
+}, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;
+//# sourceMappingURL=initial_seek_and_play.d.ts.map

package/dist/commonjs/main_thread/init/utils/initial_seek_and_play.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial_seek_and_play.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/init/utils/initial_seek_and_play.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAIjF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,+BAA+B,CAAC;AAEvC,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB;AAC3B,0EAA0E;AACxE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;AACrB;;;GAGG;GACD;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE;AAC9B,sCAAsC;GACpC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB,+CAA+C;AAC/C,MAAM,WAAW,yBAAyB;IACxC,kEAAkE;IAClE,cAAc,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE3C;;;OAGG;IACH,oBAAoB,EAAE,wBAAwB,CAAC,OAAO,CAAC,CAAC;CACzD;AAED;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,EACE,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,EAAE;IACD,YAAY,EAAE,aAAa,CAAC;IAC5B,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,SAAS,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/C,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;CACxC,EACD,YAAY,EAAE,kBAAkB,GAC/B,yBAAyB,CA2O3B"}

package/dist/commonjs/main_thread/init/utils/initial_seek_and_play.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = performInitialSeekAndPlay;
+var should_validate_metadata_1 = require("../../../compat/should_validate_metadata");
+var errors_1 = require("../../../errors");
+var log_1 = require("../../../log");
+var reference_1 = require("../../../utils/reference");
+/**
+ * Seek as soon as possible at the initially wanted position and play if
+ * autoPlay is wanted.
+ * @param {Object} args
+ * @param {Object} cancelSignal
+ * @returns {Object}
+ */
+function performInitialSeekAndPlay(_a, cancelSignal) {
+    var mediaElement = _a.mediaElement, playbackObserver = _a.playbackObserver, startTime = _a.startTime, mustAutoPlay = _a.mustAutoPlay, isDirectfile = _a.isDirectfile, onWarning = _a.onWarning;
+    var initialPlayPerformed = new reference_1.default(false, cancelSignal);
+    var autoPlayResult = new Promise(function (resolveAutoPlay, rejectAutoPlay) {
+        var deregisterCancellation = cancelSignal.register(function (err) {
+            rejectAutoPlay(err);
+        });
+        if (cancelSignal.isCancelled()) {
+            return;
+        }
+        /** `true` if we asked the `PlaybackObserver` to perform an initial seek. */
+        var hasAskedForInitialSeek = false;
+        var performInitialSeek = function (initialSeekTime) {
+            var pendingSeek = playbackObserver.getPendingSeekInformation();
+            /*
+             * NOTE: The user might have asked for a seek before the media element
+             * was ready, in which case we want the seek to be at the user's wanted
+             * position instead.
+             * If multiple internal seeks were asked however, we want to keep the
+             * last one.
+             */
+            if (pendingSeek === null || pendingSeek.isInternal) {
+                playbackObserver.setCurrentTime(initialSeekTime);
+            }
+            hasAskedForInitialSeek = true;
+            playbackObserver.unblockSeeking();
+        };
+        // `startTime` defined as a function might depend on metadata to make its
+        // choice, such as the content duration, minimum and/or maximum position.
+        //
+        // The RxPlayer might already know those through the Manifest file for
+        // non-Directfile contents, yet only through the `HTMLMediaElement` once a
+        // a sufficient `readyState` has been reached for directfile contents.
+        // So let's divide the two possibilities here.
+        if (!isDirectfile || typeof startTime === "number") {
+            var initiallySeekedTime = typeof startTime === "number" ? startTime : startTime();
+            if (initiallySeekedTime !== 0 && initiallySeekedTime !== undefined) {
+                performInitialSeek(initiallySeekedTime);
+            }
+            else {
+                playbackObserver.unblockSeeking();
+            }
+            waitForSeekable();
+        }
+        else {
+            playbackObserver.listen(function (obs, stopListening) {
+                var initiallySeekedTime = typeof startTime === "number" ? startTime : startTime();
+                if (initiallySeekedTime === undefined &&
+                    obs.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
+                    /**
+                     * The starting position may not be known yet.
+                     * Postpone the seek to a moment where the starting position should be known,
+                     * assumely it's when readyState is greater or equal to HAVE_CURRENT_DATA (2).
+                     * If the initiallySeekedTime is still `undefined` when the readyState is >= 2,
+                     * let assume that the initiallySeekedTime will never be known and continue
+                     * the logic without seeking.
+                     */
+                    return;
+                }
+                if (obs.readyState >= 1) {
+                    stopListening();
+                    if (initiallySeekedTime !== 0 && initiallySeekedTime !== undefined) {
+                        performInitialSeek(initiallySeekedTime);
+                    }
+                    else {
+                        playbackObserver.unblockSeeking();
+                    }
+                    waitForSeekable();
+                }
+            }, { includeLastObservation: false, clearSignal: cancelSignal });
+        }
+        /**
+         * Logic that should be run once the initial seek has been asked to the
+         * PlaybackObserver.
+         *
+         * Actually wait until the seek has been performed, wait for the right moment
+         * to perform autoplay, resolve the promise once everything has been done and
+         * potentially send warning if a minor issue is detected.
+         */
+        function waitForSeekable() {
+            /**
+             * We only want to continue to `play` when a `seek` has actually been
+             * performed (if it has been asked). This boolean keep track of if the
+             * seek arised.
+             */
+            var hasStartedSeeking = false;
+            playbackObserver.listen(function (obs, stopListening) {
+                if (!hasStartedSeeking &&
+                    (obs.seeking !== 0 /* SeekingState.None */ ||
+                        obs.event === "seeking" ||
+                        obs.event === "internal-seeking")) {
+                    hasStartedSeeking = true;
+                }
+                if ((hasAskedForInitialSeek && !hasStartedSeeking) || obs.readyState === 0) {
+                    return;
+                }
+                stopListening();
+                if ((0, should_validate_metadata_1.default)() && mediaElement.duration === 0) {
+                    var error = new errors_1.MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
+                        "falsely announced having loaded the content.");
+                    onWarning(error);
+                }
+                if (cancelSignal.isCancelled()) {
+                    return;
+                }
+                waitForPlayable();
+            }, { includeLastObservation: false, clearSignal: cancelSignal });
+        }
+        /**
+         * Logic that should be run once the initial seek has been properly performed.
+         *
+         * Wait for the media being playable before performing the autoplay operation
+         * if asked. Potentially send warning if a minor issue has been detected while
+         * doing so.
+         */
+        function waitForPlayable() {
+            playbackObserver.listen(function (observation, stopListening) {
+                if (observation.seeking === 0 /* SeekingState.None */ &&
+                    observation.rebuffering === null &&
+                    observation.readyState >= 1) {
+                    stopListening();
+                    onPlayable();
+                }
+            }, { includeLastObservation: true, clearSignal: cancelSignal });
+        }
+        /**
+         * Callback called once the content is considered "playable".
+         *
+         * Perform the autoplay if needed, handling potential issues and resolve the
+         * Promise when done.
+         * Might also send warnings if minor issues arise.
+         */
+        function onPlayable() {
+            var _a;
+            log_1.default.info("Init", "Can begin to play content");
+            if (!mustAutoPlay) {
+                if (mediaElement.autoplay) {
+                    log_1.default.warn("Init", "autoplay is enabled on HTML media element. " +
+                        "Media will play as soon as possible.");
+                }
+                initialPlayPerformed.setValue(true);
+                initialPlayPerformed.finish();
+                deregisterCancellation();
+                return resolveAutoPlay({ type: "skipped" });
+            }
+            else if (mediaElement.ended) {
+                // the video has ended state to true, executing VideoElement.play() will
+                // restart the video from the start, which is not wanted in most cases.
+                // returning "skipped" prevents the call to play() and fix the issue
+                log_1.default.warn("Init", "autoplay is enabled but the video is ended. " +
+                    "Skipping autoplay to prevent video to start again");
+                initialPlayPerformed.setValue(true);
+                initialPlayPerformed.finish();
+                deregisterCancellation();
+                return resolveAutoPlay({ type: "skipped" });
+            }
+            var playResult;
+            try {
+                playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
+            }
+            catch (playError) {
+                deregisterCancellation();
+                return rejectAutoPlay(playError);
+            }
+            playResult
+                .then(function () {
+                if (cancelSignal.isCancelled()) {
+                    return;
+                }
+                initialPlayPerformed.setValue(true);
+                initialPlayPerformed.finish();
+                deregisterCancellation();
+                return resolveAutoPlay({ type: "autoplay" });
+            })
+                .catch(function (playError) {
+                deregisterCancellation();
+                if (cancelSignal.isCancelled()) {
+                    return;
+                }
+                if (playError instanceof Error && playError.name === "NotAllowedError") {
+                    // auto-play was probably prevented.
+                    log_1.default.warn("Init", "Media element can't play." +
+                        " It may be due to browser auto-play policies.");
+                    var error = new errors_1.MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
+                        "your browser does not allow it.");
+                    onWarning(error);
+                    if (cancelSignal.isCancelled()) {
+                        return;
+                    }
+                    return resolveAutoPlay({ type: "autoplay-blocked" });
+                }
+                else {
+                    rejectAutoPlay(playError);
+                }
+            });
+        }
+    });
+    return { autoPlayResult: autoPlayResult, initialPlayPerformed: initialPlayPerformed };
+}

package/dist/commonjs/main_thread/init/utils/initialize_content_decryption.d.ts

@@ -0,0 +1,99 @@
+import type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import { EncryptedMediaError } from "../../../errors";
+import type { IKeySystemOption, IPlayerError } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import SharedReference from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type IContentDecryptor from "../../decrypt";
+import type { IProcessedProtectionData } from "../../decrypt";
+/**
+ * Initialize content decryption capabilities on the given `HTMLMediaElement`.
+ *
+ * You can call this function even if you don't want decrytpion capabilities, in
+ * which case you can just set the `keySystems` option as an empty array.
+ * In this situation, the returned object will directly correspond to an
+ * "`initialized`" state and the `onError` callback will be triggered as soon
+ * as protection information is received.
+ *
+ * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which content
+ * decryption may be wanted.
+ * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
+ * Empty array if no content decryption capability is wanted.
+ * protection initialization data will be sent through.
+ * @param {Object} callbacks - Callbacks called at various decryption-related
+ * events.
+ * @param {Object} cancelSignal - When that signal emits, this function will
+ * stop listening to various events.
+ * @returns {Object} - Reference emitting the current status regarding DRM
+ * initialization.
+ */
+export default function initializeContentDecryption(mediaElement: IMediaElement, keySystems: IKeySystemOption[], callbacks: {
+    onWarning: (err: IPlayerError) => void;
+    onError: (err: Error) => void;
+    onBlackListProtectionData: (val: IProcessedProtectionData) => void;
+    onKeyIdsCompatibilityUpdate: (updates: {
+        whitelistedKeyIds: Uint8Array[];
+        blacklistedKeyIds: Uint8Array[];
+        delistedKeyIds: Uint8Array[];
+    }) => void;
+    onCodecSupportUpdate?: () => void;
+}, cancelSignal: CancellationSignal): {
+    statusRef: IReadOnlySharedReference<IDrmInitializationStatus>;
+    contentDecryptor: {
+        enabled: true;
+        value: IContentDecryptor;
+    } | {
+        enabled: false;
+        value: EncryptedMediaError;
+    };
+};
+/** Status of content decryption initialization. */
+interface IDrmInitializationStatus {
+    /** Current initialization state the decryption logic is in. */
+    initializationState: IDecryptionInitializationState;
+    /**
+     * If set, corresponds to the hex string describing the current key system
+     * used.
+     * `undefined` if unknown or if it does not apply.
+     */
+    drmSystemId: string | undefined;
+}
+/** Initialization steps to add decryption capabilities to an `HTMLMediaElement`. */
+type IDecryptionInitializationState = 
+/**
+ * Decryption capabilities have not been initialized yet.
+ * You should wait before performing any action on the concerned
+ * `HTMLMediaElement` (such as linking a content / `MediaSource` to it).
+ */
+{
+    type: "uninitialized";
+    value: null;
+}
+/**
+ * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
+ * before continuing.
+ * Once it has been linked with success (e.g. the `MediaSource` has "opened"),
+ * the `isMediaLinked` `SharedReference` should be set to `true`.
+ *
+ * In the `MediaSource` case, you should wait until the `"initialized"`
+ * state before pushing segment.
+ *
+ * Note that the `"awaiting-media-link"` is an optional state. It can be
+ * skipped to directly `"initialized"` instead.
+ */
+ | {
+    type: "awaiting-media-link";
+    value: {
+        isMediaLinked: SharedReference<boolean>;
+    };
+}
+/**
+ * The `MediaSource` or media url can be linked AND segments can be pushed to
+ * the `HTMLMediaElement` on which decryption capabilities were wanted.
+ */
+ | {
+    type: "initialized";
+    value: null;
+};
+export {};
+//# sourceMappingURL=initialize_content_decryption.d.ts.map

package/dist/commonjs/main_thread/init/utils/initialize_content_decryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize_content_decryption.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/init/utils/initialize_content_decryption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAExE,OAAO,KAAK,iBAAiB,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,UAAU,2BAA2B,CACjD,YAAY,EAAE,aAAa,EAC3B,UAAU,EAAE,gBAAgB,EAAE,EAC9B,SAAS,EAAE;IACT,SAAS,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;IAC9B,yBAAyB,EAAE,CAAC,GAAG,EAAE,wBAAwB,KAAK,IAAI,CAAC;IACnE,2BAA2B,EAAE,CAAC,OAAO,EAAE;QACrC,iBAAiB,EAAE,UAAU,EAAE,CAAC;QAChC,iBAAiB,EAAE,UAAU,EAAE,CAAC;QAChC,cAAc,EAAE,UAAU,EAAE,CAAC;KAC9B,KAAK,IAAI,CAAC;IACX,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC,EACD,YAAY,EAAE,kBAAkB,GAC/B;IACD,SAAS,EAAE,wBAAwB,CAAC,wBAAwB,CAAC,CAAC;IAC9D,gBAAgB,EACZ;QACE,OAAO,EAAE,IAAI,CAAC;QACd,KAAK,EAAE,iBAAiB,CAAC;KAC1B,GACD;QACE,OAAO,EAAE,KAAK,CAAC;QACf,KAAK,EAAE,mBAAmB,CAAC;KAC5B,CAAC;CACP,CA8GA;AAED,mDAAmD;AACnD,UAAU,wBAAwB;IAChC,+DAA+D;IAC/D,mBAAmB,EAAE,8BAA8B,CAAC;IACpD;;;;OAIG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED,oFAAoF;AACpF,KAAK,8BAA8B;AACjC;;;;GAIG;AACD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE;AACxC;;;;;;;;;;;GAWG;GACD;IACE,IAAI,EAAE,qBAAqB,CAAC;IAC5B,KAAK,EAAE;QAAE,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;CACpD;AACH;;;GAGG;GACD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC"}