rx-player 4.3.0-dev.2025012900 → 4.3.0-dev.2025030400

package/dist/commonjs/core/main/common/FreezeResolver.js

@@ -0,0 +1,431 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var experimental_1 = require("../../../experimental");
+var log_1 = require("../../../log");
+var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+/**
+ * "Freezing" is a complex situation indicating that playback is not advancing
+ * despite no valid reason for it not to.
+ *
+ * Technically, there's multiple scenarios in which the RxPlayer will consider
+ * the stream as "freezing" and try to fix it.
+ * One of those scenarios is when there's a
+ * `HTMLMediaElement.prototype.readyState` set to `1` (which is how the browser
+ * tells us that it doesn't have any data to play), despite the fact that
+ * there's actually data in the buffer.
+ *
+ * The `MINIMUM_BUFFER_GAP_AT_READY_STATE_1_BEFORE_FREEZING` is the minimum
+ * buffer size in seconds after which we will suspect a "freezing" scenario if
+ * the `readyState` is still at `1`.
+ */
+var MINIMUM_BUFFER_GAP_AT_READY_STATE_1_BEFORE_FREEZING = 6;
+/**
+ * The amount of milliseconds since a freeze was detected from which we consider
+ * that the freeze should be worked around: either by flushing buffers,
+ * reloading, or any other kind of strategies.
+ *
+ * Before that delay, will continue to wait to see if the browser succeeds to
+ * un-freeze by itself.
+ */
+var FREEZING_FOR_TOO_LONG_DELAY = 4000;
+/**
+ * To avoid handling freezes (e.g. "reloading" or "seeking") in a loop when
+ * things go wrong, we have a security delay in milliseconds, this
+ * `MINIMUM_TIME_BETWEEN_FREEZE_HANDLING` constant, which we'll await between
+ * un-freezing attempts.
+ */
+var MINIMUM_TIME_BETWEEN_FREEZE_HANDLING = 6000;
+/**
+ * We maintain here a short-term history of what segments have been played
+ * recently, to then implement heuristics detecting if a freeze was due to a
+ * particular quality or track.
+ *
+ * To avoid growing that history indefinitely in size, we only save data
+ * corresponding to the last `MAXIMUM_SEGMENT_HISTORY_RETENTION_TIME`
+ * milliseconds from now.
+ */
+var MAXIMUM_SEGMENT_HISTORY_RETENTION_TIME = 60000;
+/**
+ * Sometimes playback is stuck for no known reason, despite having data in
+ * buffers.
+ *
+ * This can be due to relatively valid cause: performance being slow on the
+ * device making the content slow to start up, decryption keys not being
+ * obtained / usable yet etc.
+ *
+ * Yet in many cases, this is abnormal and may lead to being stuck at the same
+ * position and video frame indefinitely.
+ *
+ * For those situations, we have a series of tricks and heuristic, which are
+ * implemented by the `FreezeResolver`.
+ *
+ * @class FreezeResolver
+ */
+var FreezeResolver = /** @class */ (function () {
+    function FreezeResolver(segmentSinksStore) {
+        this._segmentSinksStore = segmentSinksStore;
+        this._decipherabilityFreezeStartingTimestamp = null;
+        this._ignoreFreezeUntil = null;
+        this._lastFlushAttempt = null;
+        this._lastSegmentInfo = {
+            audio: [],
+            video: [],
+        };
+    }
+    /**
+     * Check that playback is not freezing, and if it is, return a solution that
+     * should be attempted to unfreeze it.
+     *
+     * Returns `null` either when there's no freeze happening or if there's one
+     * but there's nothing we should do about it yet.
+     *
+     * Refer to the returned type's definition for more information.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {Object|null}
+     */
+    FreezeResolver.prototype.onNewObservation = function (observation) {
+        var _a, _b;
+        var now = (0, monotonic_timestamp_1.default)();
+        this._addPositionToHistory(observation, now);
+        if (this._ignoreFreezeUntil !== null && now < this._ignoreFreezeUntil) {
+            return null;
+        }
+        this._ignoreFreezeUntil = null;
+        var _c = experimental_1.config.getCurrent(), UNFREEZING_SEEK_DELAY = _c.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _c.UNFREEZING_DELTA_POSITION, FREEZING_FLUSH_FAILURE_DELAY = _c.FREEZING_FLUSH_FAILURE_DELAY;
+        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing, fullyLoaded = observation.fullyLoaded;
+        var freezingPosition = observation.position.getPolled();
+        var bufferGap = normalizeBufferGap(observation.bufferGap);
+        /** If set to `true`, we consider playback "frozen" */
+        var isFrozen = freezing !== null ||
+            // When rebuffering, `freezing` might be not set as we're actively pausing
+            // playback. Yet, rebuffering occurences can also be abnormal, such as
+            // when enough buffer is constructed but with a low readyState (those are
+            // generally decryption issues).
+            (rebuffering !== null &&
+                readyState === 1 &&
+                (bufferGap >= MINIMUM_BUFFER_GAP_AT_READY_STATE_1_BEFORE_FREEZING ||
+                    fullyLoaded));
+        if (!isFrozen) {
+            this._decipherabilityFreezeStartingTimestamp = null;
+            return null;
+        }
+        var freezingTs = (_b = (_a = freezing === null || freezing === void 0 ? void 0 : freezing.timestamp) !== null && _a !== void 0 ? _a : rebuffering === null || rebuffering === void 0 ? void 0 : rebuffering.timestamp) !== null && _b !== void 0 ? _b : null;
+        log_1.default.info("FR: Freeze detected", freezingTs, now - (freezingTs !== null && freezingTs !== void 0 ? freezingTs : now));
+        /**
+         * If `true`, we recently tried to "flush" to unstuck playback but playback
+         * is still stuck
+         */
+        var recentFlushAttemptFailed = this._lastFlushAttempt !== null &&
+            now - this._lastFlushAttempt.timestamp < FREEZING_FLUSH_FAILURE_DELAY.MAXIMUM &&
+            now - this._lastFlushAttempt.timestamp >= FREEZING_FLUSH_FAILURE_DELAY.MINIMUM &&
+            Math.abs(freezingPosition - this._lastFlushAttempt.position) <
+                FREEZING_FLUSH_FAILURE_DELAY.POSITION_DELTA;
+        if (recentFlushAttemptFailed) {
+            var secondUnfreezeStrat = this._getStrategyIfFlushingFails(freezingPosition);
+            this._decipherabilityFreezeStartingTimestamp = null;
+            this._ignoreFreezeUntil = now + MINIMUM_TIME_BETWEEN_FREEZE_HANDLING;
+            return secondUnfreezeStrat;
+        }
+        var decipherabilityFreezeStrat = this._checkForDecipherabilityRelatedFreeze(observation, now);
+        if (decipherabilityFreezeStrat !== null) {
+            return decipherabilityFreezeStrat;
+        }
+        if (freezingTs !== null && now - freezingTs > UNFREEZING_SEEK_DELAY) {
+            this._lastFlushAttempt = {
+                timestamp: now,
+                position: freezingPosition + UNFREEZING_DELTA_POSITION,
+            };
+            log_1.default.debug("FR: trying to flush to un-freeze");
+            this._decipherabilityFreezeStartingTimestamp = null;
+            this._ignoreFreezeUntil = now + MINIMUM_TIME_BETWEEN_FREEZE_HANDLING;
+            return {
+                type: "flush",
+                value: { relativeSeek: UNFREEZING_DELTA_POSITION },
+            };
+        }
+        return null;
+    };
+    /**
+     * Performs decipherability-related checks if it makes sense.
+     *
+     * If decipherability-related checks have been performed **AND** an
+     * un-freezing strategy has been selected by this method, then return
+     * an object describing this wanted unfreezing strategy.
+     *
+     * If this method decides to take no action for now, it returns `null`.
+     * @param {Object} observation - playback observation that has just been
+     * performed.
+     * @param {number} now - Monotonically-raising timestamp for the current
+     * time.
+     * @returns {Object|null}
+     */
+    FreezeResolver.prototype._checkForDecipherabilityRelatedFreeze = function (observation, now) {
+        var e_1, _a, e_2, _b;
+        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing, fullyLoaded = observation.fullyLoaded;
+        var bufferGap = normalizeBufferGap(observation.bufferGap);
+        var rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > FREEZING_FOR_TOO_LONG_DELAY;
+        var frozenForTooLong = freezing !== null && now - freezing.timestamp > FREEZING_FOR_TOO_LONG_DELAY;
+        var hasDecipherabilityFreezePotential = (rebufferingForTooLong || frozenForTooLong) &&
+            (bufferGap >= MINIMUM_BUFFER_GAP_AT_READY_STATE_1_BEFORE_FREEZING || fullyLoaded) &&
+            readyState <= 1;
+        if (!hasDecipherabilityFreezePotential) {
+            this._decipherabilityFreezeStartingTimestamp = null;
+        }
+        else if (this._decipherabilityFreezeStartingTimestamp === null) {
+            log_1.default.debug("FR: Start of a potential decipherability freeze detected");
+            this._decipherabilityFreezeStartingTimestamp = now;
+        }
+        var shouldHandleDecipherabilityFreeze = this._decipherabilityFreezeStartingTimestamp !== null &&
+            (0, monotonic_timestamp_1.default)() - this._decipherabilityFreezeStartingTimestamp >
+                FREEZING_FOR_TOO_LONG_DELAY;
+        var hasOnlyDecipherableSegments = true;
+        var isClear = true;
+        try {
+            for (var _c = __values(["audio", "video"]), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var ttype = _d.value;
+                var status_1 = this._segmentSinksStore.getStatus(ttype);
+                if (status_1.type === "initialized") {
+                    try {
+                        for (var _e = (e_2 = void 0, __values(status_1.value.getLastKnownInventory())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var segment = _f.value;
+                            var representation = segment.infos.representation;
+                            if (representation.decipherable === false) {
+                                log_1.default.warn("FR: we have undecipherable segments left in the buffer, reloading");
+                                this._decipherabilityFreezeStartingTimestamp = null;
+                                this._ignoreFreezeUntil = now + MINIMUM_TIME_BETWEEN_FREEZE_HANDLING;
+                                return { type: "reload", value: null };
+                            }
+                            else if (representation.contentProtections !== undefined) {
+                                isClear = false;
+                                if (representation.decipherable !== true) {
+                                    hasOnlyDecipherableSegments = false;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (shouldHandleDecipherabilityFreeze && !isClear && hasOnlyDecipherableSegments) {
+            log_1.default.warn("FR: we are frozen despite only having decipherable " +
+                "segments left in the buffer, reloading");
+            this._decipherabilityFreezeStartingTimestamp = null;
+            this._ignoreFreezeUntil = now + MINIMUM_TIME_BETWEEN_FREEZE_HANDLING;
+            return { type: "reload", value: null };
+        }
+        return null;
+    };
+    /**
+     * This method should only be called if a "flush" strategy has recently be
+     * taken to try to unfreeze playback yet playback is still frozen.
+     *
+     * It considers the current played content and returns a more-involved
+     * unfreezing strategy (most often reload-related) to try to unfree playback.
+     * @param {number} freezingPosition - The playback position at which we're
+     * currently frozen.
+     * @returns {Object}
+     */
+    FreezeResolver.prototype._getStrategyIfFlushingFails = function (freezingPosition) {
+        var e_3, _a;
+        log_1.default.warn("FR: A recent flush seemed to have no effect on freeze, checking for transitions");
+        /** Contains Representation we might want to avoid after the following algorithm */
+        var toAvoid = [];
+        try {
+            for (var _b = __values(["audio", "video"]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var ttype = _c.value;
+                var segmentList = this._lastSegmentInfo[ttype];
+                if (segmentList.length === 0) {
+                    // There's no buffered segment for that type, go to next type
+                    continue;
+                }
+                /** Played history information on the current segment we're stuck on. */
+                var currentSegmentEntry = segmentList[segmentList.length - 1];
+                if (currentSegmentEntry.segment === null) {
+                    // No segment currently played for that given type, go to next type
+                    continue;
+                }
+                /** Metadata on the segment currently being played. */
+                var currentSegment = currentSegmentEntry.segment;
+                /**
+                 * Set to the first previous segment which is linked to a different
+                 * Representation.
+                 */
+                var previousRepresentationEntry = void 0;
+                // Now find `previousRepresentationEntry` and `currentSegmentEntry`.
+                for (var i = segmentList.length - 2; i >= 0; i--) {
+                    var segment = segmentList[i];
+                    if (segment.segment === null) {
+                        // Before the current segment, there was no segment being played
+                        previousRepresentationEntry = segment;
+                        break;
+                    }
+                    else if (segment.segment.infos.representation.uniqueId !==
+                        currentSegment.infos.representation.uniqueId &&
+                        currentSegmentEntry.timestamp - segment.timestamp < 5000) {
+                        // Before the current segment, there was a segment of a different
+                        // Representation being played
+                        previousRepresentationEntry = segment;
+                        break;
+                    }
+                    else if (segment.segment.start === currentSegment.start &&
+                        // Ignore history entry concerning the same segment more than 3
+                        // seconds of playback behind - we don't want to compare things
+                        // that happended too long ago.
+                        freezingPosition - segment.position < 3000) {
+                        // We're still playing the last segment at that point, update it.
+                        //
+                        // (We may be playing, or be freezing, on the current segment for some
+                        // time, this allows to consider a more precize timestamp at which we
+                        // switched segments).
+                        currentSegmentEntry = segment;
+                    }
+                }
+                if (previousRepresentationEntry === undefined ||
+                    previousRepresentationEntry.segment === null) {
+                    log_1.default.debug("FR: Freeze when beginning to play a content, try avoiding this quality");
+                    toAvoid.push({
+                        adaptation: currentSegment.infos.adaptation,
+                        period: currentSegment.infos.period,
+                        representation: currentSegment.infos.representation,
+                    });
+                }
+                else if (currentSegment.infos.period.id !==
+                    previousRepresentationEntry.segment.infos.period.id) {
+                    log_1.default.debug("FR: Freeze when switching Period, reloading");
+                    return { type: "reload", value: null };
+                }
+                else if (currentSegment.infos.representation.uniqueId !==
+                    previousRepresentationEntry.segment.infos.representation.uniqueId) {
+                    log_1.default.warn("FR: Freeze when switching Representation, avoiding", currentSegment.infos.representation.bitrate);
+                    toAvoid.push({
+                        adaptation: currentSegment.infos.adaptation,
+                        period: currentSegment.infos.period,
+                        representation: currentSegment.infos.representation,
+                    });
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (toAvoid.length > 0) {
+            return { type: "avoid-representations", value: toAvoid };
+        }
+        else {
+            log_1.default.debug("FR: Reloading because flush doesn't work");
+            return { type: "reload", value: null };
+        }
+    };
+    /**
+     * Add entry to `this._lastSegmentInfo` for the position that is currently
+     * played according to the given `observation`.
+     *
+     * @param {Object} observation
+     * @param {number} currentTimestamp
+     */
+    FreezeResolver.prototype._addPositionToHistory = function (observation, currentTimestamp) {
+        var e_4, _a, e_5, _b;
+        var _c, _d;
+        var position = observation.position.getPolled();
+        try {
+            for (var _e = __values(["audio", "video"]), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var ttype = _f.value;
+                var status_2 = this._segmentSinksStore.getStatus(ttype);
+                if (status_2.type === "initialized") {
+                    try {
+                        for (var _g = (e_5 = void 0, __values(status_2.value.getLastKnownInventory())), _h = _g.next(); !_h.done; _h = _g.next()) {
+                            var segment = _h.value;
+                            if (((_c = segment.bufferedStart) !== null && _c !== void 0 ? _c : segment.start) <= position &&
+                                ((_d = segment.bufferedEnd) !== null && _d !== void 0 ? _d : segment.end) > position) {
+                                this._lastSegmentInfo[ttype].push({
+                                    segment: segment,
+                                    position: position,
+                                    timestamp: currentTimestamp,
+                                });
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }
+                else {
+                    this._lastSegmentInfo[ttype].push({
+                        segment: null,
+                        position: position,
+                        timestamp: currentTimestamp,
+                    });
+                }
+                if (this._lastSegmentInfo[ttype].length > 100) {
+                    var toRemove = this._lastSegmentInfo[ttype].length - 100;
+                    this._lastSegmentInfo[ttype].splice(0, toRemove);
+                }
+                var removalTs = currentTimestamp - MAXIMUM_SEGMENT_HISTORY_RETENTION_TIME;
+                var i = void 0;
+                for (i = 0; i < this._lastSegmentInfo[ttype].length; i++) {
+                    if (this._lastSegmentInfo[ttype][i].timestamp > removalTs) {
+                        break;
+                    }
+                }
+                if (i > 0) {
+                    this._lastSegmentInfo[ttype].splice(0, i);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    return FreezeResolver;
+}());
+exports.default = FreezeResolver;
+/**
+ * Constructs a `bufferGap` value that is more usable than what the
+ * `PlaybackObserver` returns:
+ *   - it cannot be `undefined`
+ *   - its weird `Infinity` value is translated to the more explicit `0`.
+ * @param {number|undefined} bufferGap
+ * @returns {number}
+ */
+function normalizeBufferGap(bufferGap) {
+    return bufferGap !== undefined && isFinite(bufferGap) ? bufferGap : 0;
+}

package/dist/commonjs/core/main/common/synchronize_sinks_on_observation.d.ts

@@ -0,0 +1,11 @@
+import type { ICorePlaybackObservation } from "../../../main_thread/init/utils/create_core_playback_observer";
+import type SegmentSinksStore from "../../segment_sinks";
+/**
+ * Synchronize SegmentSinks with what has been buffered.
+ * @param {Object} observation - The just-received playback observation,
+ * including what has been buffered on lower-level buffers
+ * @param {Object} segmentSinksStore - Interface allowing to interact
+ * with `SegmentSink`s, so their inventory can be updated accordingly.
+ */
+export default function synchronizeSegmentSinksOnObservation(observation: ICorePlaybackObservation, segmentSinksStore: SegmentSinksStore): void;
+//# sourceMappingURL=synchronize_sinks_on_observation.d.ts.map

package/dist/commonjs/core/main/common/synchronize_sinks_on_observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronize_sinks_on_observation.d.ts","sourceRoot":"","sources":["../../../../../src/core/main/common/synchronize_sinks_on_observation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAC9G,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AAEzD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,oCAAoC,CAC1D,WAAW,EAAE,wBAAwB,EACrC,iBAAiB,EAAE,iBAAiB,GACnC,IAAI,CAQN"}

package/dist/commonjs/core/main/common/synchronize_sinks_on_observation.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = synchronizeSegmentSinksOnObservation;
+/**
+ * Synchronize SegmentSinks with what has been buffered.
+ * @param {Object} observation - The just-received playback observation,
+ * including what has been buffered on lower-level buffers
+ * @param {Object} segmentSinksStore - Interface allowing to interact
+ * with `SegmentSink`s, so their inventory can be updated accordingly.
+ */
+function synchronizeSegmentSinksOnObservation(observation, segmentSinksStore) {
+    // Synchronize SegmentSinks with what has been buffered.
+    ["video", "audio", "text"].forEach(function (tType) {
+        var _a;
+        var segmentSinkStatus = segmentSinksStore.getStatus(tType);
+        if (segmentSinkStatus.type === "initialized") {
+            segmentSinkStatus.value.synchronizeInventory((_a = observation.buffered[tType]) !== null && _a !== void 0 ? _a : []);
+        }
+    });
+}

package/dist/commonjs/core/main/worker/content_preparer.d.ts

@@ -7,13 +7,46 @@ import type { IManifestRefreshSettings } from "../../fetchers";
 import { ManifestFetcher, SegmentQueueCreator } from "../../fetchers";
 import SegmentSinksStore from "../../segment_sinks";
 import type { INeedsMediaSourceReloadPayload } from "../../stream";
-import DecipherabilityFreezeDetector from "../common/DecipherabilityFreezeDetector";
+import FreezeResolver from "../common/FreezeResolver";
 import TrackChoiceSetter from "./track_choice_setter";
 import WorkerTextDisplayerInterface from "./worker_text_displayer_interface";
+/**
+ * Class facilitating the workflows behind loading a new content for the
+ * RxPlayer Core:
+ *
+ *   - Handle Manifest fetching and Manifest updates.
+ *
+ *   - Handle the `MediaSource`'s creation and indirectly of its `SourceBuffer`s
+ *     as well as handling "MediaSource reloading".
+ *
+ *   - initialize various modules (`segmentQueueCreator`, CmcdDataBuilder`,
+ *     `RepresentationEstimator`) linked to the initialized content.
+ *
+ * You can start loading a content through the `initializeNewContent` method.
+ *
+ * When a content is linked to the `ContentPreparer` you can inspect the
+ * different initialized modules by calling its `getCurrentContent` method.
+ *
+ * @class ContentPreparer
+ */
 export default class ContentPreparer {
+    /**
+     * Information on the content linked to that `ContentPreparer` through its
+     * `initializeNewContent` method.
+     * `null` if no content is initialized.
+     */
     private _currentContent;
-    private _currentMediaSourceCanceller;
+    /**
+     * TaskCanceller which is triggered when the currently-initialized content is
+     * not needed anymore, because we stopped it since or switched to a new content.
+     */
     private _contentCanceller;
+    /**
+     * TaskCanceller which is triggered when the currently-created MediaSource is
+     * not needed anymore, either because the content has changed or because we
+     * had to reload.
+     */
+    private _currentMediaSourceCanceller;
     /** @see constructor */
     private _hasMseInWorker;
     /** @see constructor */
@@ -35,10 +68,48 @@ export default class ContentPreparer {
         hasMseInWorker: boolean;
         hasVideo: boolean;
     });
+    /**
+     * Start fetching the wanted content's Manifest and initializing the various
+     * modules stored by the `ContentPreparer` linked to that content.
+     *
+     * The returned Promise resolves with the parsed Manifest when those modules
+     * are all ready and you can thus begin to load the content.
+     *
+     * Reject if it failed to do so.
+     * @param {Object} context - Information on the content that should be
+     * initialized.
+     * @returns {Promise.<Object>}
+     */
     initializeNewContent(context: IContentInitializationData): Promise<IManifestMetadata>;
+    /**
+     * Get information on the current content prepared through the
+     * `initializeNewContent` method, or `null` if no content is currently
+     * prepared.
+     * @returns {Object|null}
+     */
     getCurrentContent(): IPreparedContentData | null;
+    /**
+     * Schedule an update for the Manifest file,
+     *
+     * Do nothing if no content is currently prepared.
+     * @param {Object} settings - Various settings to configure the ways and
+     * moment at which the Manifest will be refreshed.
+     */
     scheduleManifestRefresh(settings: IManifestRefreshSettings): void;
+    /**
+     * If there is a prepared content right now, performs the destructive
+     * "reloading" strategy: dispose of its `MediaSource` (and of its
+     * `SourceBuffer`) and recreate one.
+     *
+     * The returned Promise resolves when it restarts being ready.
+     * @param {Object} reloadInfo
+     * @returns {Promise}
+     */
     reloadMediaSource(reloadInfo: INeedsMediaSourceReloadPayload): Promise<void>;
+    /**
+     * Dispose all resources linked to the currently preopared content if one and
+     * stop linking it to this `ContentPreparer`.
+     */
     disposeCurrentContent(): void;
 }
 /**
@@ -57,6 +128,12 @@ export interface IPreparedContentData {
      * conditions with a CDN.
      */
     cmcdDataBuilder: CmcdDataBuilder | null;
+    /**
+     * If `true`, the RxPlayer can enable its "Representation avoidance"
+     * mechanism, where it avoid loading Representation that it suspect
+     * have issues being decoded on the current device.
+     */
+    enableRepresentationAvoidance: boolean;
     /**
      * Interface to the MediaSource implementation, allowing to buffer audio
      * and video media segments.
@@ -71,10 +148,10 @@ export interface IPreparedContentData {
      */
     manifest: IManifest | null;
     /**
-     * Specific module detecting freezing issues due to lower-level
-     * decipherability-related bugs.
+     * Specific module detecting freezing issues and trying to work-around
+     * them.
      */
-    decipherabilityFreezeDetector: DecipherabilityFreezeDetector;
+    freezeResolver: FreezeResolver;
     /**
      * Perform the adaptive logic, allowing to choose the best Representation for
      * the different types of media to load.

package/dist/commonjs/core/main/worker/content_preparer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content_preparer.d.ts","sourceRoot":"","sources":["../../../../../src/core/main/worker/content_preparer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,4BAA4B,CAAC;AAWpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,OAAO,eAAe,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,6BAA6B,MAAM,yCAAyC,CAAC;AAGpF,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AACtD,OAAO,4BAA4B,MAAM,mCAAmC,CAAC;AAI7E,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,4BAA4B,CAAgB;IACpD,OAAO,CAAC,iBAAiB,CAAgB;IAEzC,uBAAuB;IACvB,OAAO,CAAC,eAAe,CAAU;IAEjC,uBAAuB;IACvB,OAAO,CAAC,SAAS,CAAU;IAE3B;;;;;;;;;;;;OAYG;gBACS,EACV,cAAc,EACd,QAAQ,GACT,EAAE;QACD,cAAc,EAAE,OAAO,CAAC;QACxB,QAAQ,EAAE,OAAO,CAAC;KACnB;IASM,oBAAoB,CACzB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC;IA4KtB,iBAAiB,IAAI,oBAAoB,GAAG,IAAI;IAIhD,uBAAuB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;IAIjE,iBAAiB,CAAC,UAAU,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IAmD5E,qBAAqB;CAI7B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC;;;OAGG;IACH,WAAW,EAAE,qBAAqB,CAAC;IACnC,0DAA0D;IAC1D,eAAe,EAAE,eAAe,CAAC;IACjC;;;;OAIG;IACH,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,6BAA6B,EAAE,6BAA6B,CAAC;IAC7D;;;OAGG;IACH,uBAAuB,EAAE,wBAAwB,CAAC;IAClD;;;OAGG;IACH,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,kEAAkE;IAClE,gBAAgB,EAAE,4BAA4B,GAAG,IAAI,CAAC;IACtD;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IACzC;;;OAGG;IACH,iBAAiB,EAAE,iBAAiB,CAAC;CACtC"}
+{"version":3,"file":"content_preparer.d.ts","sourceRoot":"","sources":["../../../../../src/core/main/worker/content_preparer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,KAAK,EAEV,0BAA0B,EAC3B,MAAM,4BAA4B,CAAC;AAWpC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,OAAO,eAAe,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAGtD,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AACtD,OAAO,4BAA4B,MAAM,mCAAmC,CAAC;AAK7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAA8B;IACrD;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAgB;IACzC;;;;OAIG;IACH,OAAO,CAAC,4BAA4B,CAAgB;IAEpD,uBAAuB;IACvB,OAAO,CAAC,eAAe,CAAU;IAEjC,uBAAuB;IACvB,OAAO,CAAC,SAAS,CAAU;IAE3B;;;;;;;;;;;;OAYG;gBACS,EACV,cAAc,EACd,QAAQ,GACT,EAAE;QACD,cAAc,EAAE,OAAO,CAAC;QACxB,QAAQ,EAAE,OAAO,CAAC;KACnB;IASD;;;;;;;;;;;OAWG;IACI,oBAAoB,CACzB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,iBAAiB,CAAC;IAiL7B;;;;;OAKG;IACI,iBAAiB,IAAI,oBAAoB,GAAG,IAAI;IAIvD;;;;;;OAMG;IACI,uBAAuB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI;IAIxE;;;;;;;;OAQG;IACI,iBAAiB,CAAC,UAAU,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDnF;;;OAGG;IACI,qBAAqB;CAI7B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,6BAA6B,EAAE,OAAO,CAAC;IACvC;;;OAGG;IACH,WAAW,EAAE,qBAAqB,CAAC;IACnC,0DAA0D;IAC1D,eAAe,EAAE,eAAe,CAAC;IACjC;;;;OAIG;IACH,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;;OAGG;IACH,uBAAuB,EAAE,wBAAwB,CAAC;IAClD;;;OAGG;IACH,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,kEAAkE;IAClE,gBAAgB,EAAE,4BAA4B,GAAG,IAAI,CAAC;IACtD;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IACzC;;;OAGG;IACH,iBAAiB,EAAE,iBAAiB,CAAC;CACtC"}