rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/_esm5.processed/core/init/utils/get_loaded_reference.js

@@ -26,7 +26,8 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @returns {Object}
  */
 export default function getLoadedReference(playbackObserver, mediaElement, isDirectfile, cancelSignal) {
-    var listenCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var listenCanceller = new TaskCanceller();
+    listenCanceller.linkToSignal(cancelSignal);
     var isLoaded = createSharedReference(false, listenCanceller.signal);
     playbackObserver.listen(function (observation) {
         if (observation.rebuffering !== null ||

package/dist/_esm5.processed/core/init/utils/initial_seek_and_play.js

@@ -42,7 +42,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
     if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
         onLoadedMetadata();
     }
-    cancelSignal.register(function (err) {
+    var deregisterCancellation = cancelSignal.register(function (err) {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
         rejectAutoPlay(err);
     });
@@ -60,7 +60,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
                 "falsely announced having loaded the content.");
             onWarning(error);
         }
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
             return;
         }
         playbackObserver.listen(function (observation, stopListening) {
@@ -82,6 +82,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             }
             initialPlayPerformed.setValue(true);
             initialPlayPerformed.finish();
+            deregisterCancellation();
             return resolveAutoPlay({ type: "skipped" });
         }
         var playResult;
@@ -89,19 +90,22 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
         }
         catch (playError) {
+            deregisterCancellation();
             return rejectAutoPlay(playError);
         }
         playResult
             .then(function () {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             initialPlayPerformed.setValue(true);
             initialPlayPerformed.finish();
+            deregisterCancellation();
             return resolveAutoPlay({ type: "autoplay" });
         })
             .catch(function (playError) {
-            if (cancelSignal.isCancelled) {
+            deregisterCancellation();
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             if (playError instanceof Error && playError.name === "NotAllowedError") {
@@ -111,7 +115,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
                 var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
                     "your browser does not allow it.");
                 onWarning(error);
-                if (cancelSignal.isCancelled) {
+                if (cancelSignal.isCancelled()) {
                     return;
                 }
                 return resolveAutoPlay({ type: "autoplay-blocked" });

package/dist/_esm5.processed/core/init/utils/initialize_content_decryption.js

@@ -62,7 +62,8 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
         ref.finish(); // We know that no new value will be triggered
         return ref;
     }
-    var decryptorCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var decryptorCanceller = new TaskCanceller();
+    decryptorCanceller.linkToSignal(cancelSignal);
     var drmStatusRef = createSharedReference({
         initializationState: { type: "uninitialized", value: null },
         drmSystemId: undefined,

package/dist/_esm5.processed/core/init/utils/media_source_duration_updater.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+export default class MediaSourceDurationUpdater {
+    /**
+     * `MediaSource` on which we're going to update the `duration` attribute.
+     */
+    private _mediaSource;
+    /**
+     * Abort the current duration-setting logic.
+     * `null` if no such logic is pending.
+     */
+    private _currentMediaSourceDurationUpdateCanceller;
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    constructor(mediaSource: MediaSource);
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    updateDuration(newDuration: number, isRealEndKnown: boolean): void;
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     */
+    stopUpdating(): void;
+}

package/dist/_esm5.processed/core/init/utils/{media_duration_updater.js → media_source_duration_updater.js}

@@ -14,94 +14,91 @@
  * limitations under the License.
  */
 import { onSourceOpen, onSourceEnded, onSourceClose, } from "../../../compat/event_listeners";
+/* eslint-disable-next-line max-len */
+import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
 import log from "../../../log";
 import createSharedReference from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 /** Number of seconds in a regular year. */
 var YEAR_IN_SECONDS = 365 * 24 * 3600;
 /**
- * Keep the MediaSource's duration up-to-date with what is being played.
- * @class MediaDurationUpdater
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
  */
-var MediaDurationUpdater = /** @class */ (function () {
+var MediaSourceDurationUpdater = /** @class */ (function () {
     /**
-     * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
-     * duration as soon as possible.
-     * This duration will be updated until the `stop` method is called.
-     * @param {Object} manifest - The Manifest currently played.
-     * For another content, you will have to create another `MediaDurationUpdater`.
+     * Create a new `MediaSourceDurationUpdater`,
      * @param {MediaSource} mediaSource - The MediaSource on which the content is
-     * pushed.
+     * played.
      */
-    function MediaDurationUpdater(manifest, mediaSource) {
-        var canceller = new TaskCanceller();
-        var currentKnownDuration = createSharedReference(undefined, canceller.signal);
-        this._canceller = canceller;
-        this._currentKnownDuration = currentKnownDuration;
-        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, this._canceller.signal);
-        /** TaskCanceller triggered each time the MediaSource open status changes. */
-        var msUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+    function MediaSourceDurationUpdater(mediaSource) {
+        this._mediaSource = mediaSource;
+        this._currentMediaSourceDurationUpdateCanceller = null;
+    }
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    MediaSourceDurationUpdater.prototype.updateDuration = function (newDuration, isRealEndKnown) {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+        }
+        this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
+        var mediaSource = this._mediaSource;
+        var currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+        var msOpenStatusCanceller = new TaskCanceller();
+        msOpenStatusCanceller.linkToSignal(currentSignal);
         isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
-            clearSignal: this._canceller.signal });
+            clearSignal: currentSignal });
         function onMediaSourceOpenedStatusChanged() {
-            msUpdateCanceller.cancel();
+            msOpenStatusCanceller.cancel();
             if (!isMediaSourceOpened.getValue()) {
                 return;
             }
-            msUpdateCanceller = new TaskCanceller({ cancelOn: canceller.signal });
-            /** TaskCanceller triggered each time the content's duration may have change */
-            var durationChangeCanceller = new TaskCanceller({
-                cancelOn: msUpdateCanceller.signal,
-            });
-            var reSetDuration = function () {
-                durationChangeCanceller.cancel();
-                durationChangeCanceller = new TaskCanceller({
-                    cancelOn: msUpdateCanceller.signal,
-                });
-                onDurationMayHaveChanged(durationChangeCanceller.signal);
-            };
-            currentKnownDuration.onUpdate(reSetDuration, { emitCurrentValue: false,
-                clearSignal: msUpdateCanceller.signal });
-            manifest.addEventListener("manifestUpdate", reSetDuration, msUpdateCanceller.signal);
-            onDurationMayHaveChanged(durationChangeCanceller.signal);
-        }
-        function onDurationMayHaveChanged(cancelSignal) {
-            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, cancelSignal);
+            msOpenStatusCanceller = new TaskCanceller();
+            msOpenStatusCanceller.linkToSignal(currentSignal);
+            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
             /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-            var sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+            var sourceBuffersUpdatingCanceller = new TaskCanceller();
+            sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
             return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
                 sourceBuffersUpdatingCanceller.cancel();
-                sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+                sourceBuffersUpdatingCanceller = new TaskCanceller();
+                sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
                 if (areUpdating) {
                     return;
                 }
-                recursivelyForceDurationUpdate(mediaSource, manifest, currentKnownDuration.getValue(), cancelSignal);
-            }, { clearSignal: cancelSignal, emitCurrentValue: true });
+                recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
+            }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
         }
-    }
-    /**
-     * By default, the `MediaDurationUpdater` only set a safe estimate for the
-     * MediaSource's duration.
-     * A more precize duration can be set by communicating to it a more precize
-     * media duration through `updateKnownDuration`.
-     * If the duration becomes unknown, `undefined` can be given to it so the
-     * `MediaDurationUpdater` goes back to a safe estimate.
-     * @param {number | undefined} newDuration
-     */
-    MediaDurationUpdater.prototype.updateKnownDuration = function (newDuration) {
-        this._currentKnownDuration.setValueIfChanged(newDuration);
     };
     /**
-     * Stop the `MediaDurationUpdater` from updating and free its resources.
-     * Once stopped, it is not possible to start it again, beside creating another
-     * `MediaDurationUpdater`.
+     * Abort the last duration-setting operation and free its resources.
      */
-    MediaDurationUpdater.prototype.stop = function () {
-        this._canceller.cancel();
+    MediaSourceDurationUpdater.prototype.stopUpdating = function () {
+        if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+            this._currentMediaSourceDurationUpdateCanceller.cancel();
+            this._currentMediaSourceDurationUpdateCanceller = null;
+        }
     };
-    return MediaDurationUpdater;
+    return MediaSourceDurationUpdater;
 }());
-export default MediaDurationUpdater;
+export default MediaSourceDurationUpdater;
 /**
  * Checks that duration can be updated on the MediaSource, and then
  * sets it.
@@ -111,26 +108,16 @@ export default MediaDurationUpdater;
  *   - `null` if it hasn'nt been updated
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @returns {string}
  */
-function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
-    var _a;
-    var newDuration = knownDuration;
-    if (newDuration === undefined) {
-        if (manifest.isDynamic) {
-            var maxPotentialPos = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : manifest.getMaximumSafePosition();
-            // Some targets poorly support setting a very high number for durations.
-            // Yet, in dynamic contents, we would prefer setting a value as high as possible
-            // to still be able to seek anywhere we want to (even ahead of the Manifest if
-            // we want to). As such, we put it at a safe default value of 2^32 excepted
-            // when the maximum position is already relatively close to that value, where
-            // we authorize exceptionally going over it.
-            newDuration = Math.max(Math.pow(2, 32), maxPotentialPos + YEAR_IN_SECONDS);
-        }
-        else {
-            newDuration = manifest.getMaximumSafePosition();
-        }
+function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
+    var newDuration = duration;
+    if (!isRealEndKnown) {
+        newDuration = hasIssuesWithHighMediaSourceDuration() ?
+            Infinity :
+            getMaximumLiveSeekablePosition(duration);
     }
     var maxBufferedEnd = 0;
     for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
@@ -149,7 +136,7 @@ function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
         if (maxBufferedEnd < mediaSource.duration) {
             try {
                 log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
-                mediaSource.duration = newDuration;
+                mediaSource.duration = maxBufferedEnd;
             }
             catch (err) {
                 log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
@@ -163,6 +150,9 @@ function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
         try {
             log.info("Init: Updating duration", newDuration);
             mediaSource.duration = newDuration;
+            if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
+                mediaSource.setLiveSeekableRange(0, getMaximumLiveSeekablePosition(duration));
+            }
         }
         catch (err) {
             log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
@@ -238,25 +228,36 @@ function createMediaSourceOpenReference(mediaSource, cancelSignal) {
 }
 /**
  * Immediately tries to set the MediaSource's duration to the most appropriate
- * one according to the Manifest and duration given.
+ * one.
  *
  * If it fails, wait 2 seconds and retries.
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
- * @param {number|undefined} duration
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @param {Object} cancelSignal
  */
-function recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal) {
-    var res = setMediaSourceDuration(mediaSource, manifest, duration);
+function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
+    var res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
     if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
         return;
     }
     var timeoutId = setTimeout(function () {
         unregisterClear();
-        recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal);
+        recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
     }, 2000);
     var unregisterClear = cancelSignal.register(function () {
         clearTimeout(timeoutId);
     });
 }
+function getMaximumLiveSeekablePosition(contentLastPosition) {
+    // Some targets poorly support setting a very high number for seekable
+    // ranges.
+    // Yet, in contents whose end is not yet known (e.g. live contents), we
+    // would prefer setting a value as high as possible to still be able to
+    // seek anywhere we want to (even ahead of the Manifest if we want to).
+    // As such, we put it at a safe default value of 2^32 excepted when the
+    // maximum position is already relatively close to that value, where we
+    // authorize exceptionally going over it.
+    return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
+}

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.d.ts

@@ -18,7 +18,7 @@ import { IPlayerError } from "../../../public_types";
 import EventEmitter from "../../../utils/event_emitter";
 import { IReadOnlySharedReference } from "../../../utils/reference";
 import { PlaybackObserver } from "../../api";
-import { IBufferType } from "../../segment_buffers";
+import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
 import { IStallingSituation } from "../types";
 /**
  * Monitor playback, trying to avoid stalling situation.
@@ -32,6 +32,7 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
     /** Emit the current playback conditions */
     private _playbackObserver;
     private _manifest;
+    private _segmentBuffersStore;
     private _speed;
     private _isStarted;
     /**
@@ -40,12 +41,23 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
      */
     private _discontinuitiesStore;
     private _canceller;
+    /**
+     * If set to something else than `null`, this is the DOMHighResTimestamp as
+     * outputed by `performance.now()` when playback begin to seem to not start
+     * despite having decipherable data in the buffer(s).
+     *
+     * If enough time in that condition is spent, special considerations are
+     * taken at which point `_currentFreezeTimestamp` is reset to `null`.
+     *
+     * It is also reset to `null` when and if there is no such issue anymore.
+     */
+    private _currentFreezeTimestamp;
     /**
      * @param {object} playbackObserver - emit the current playback conditions.
      * @param {Object} manifest - The Manifest of the currently-played content.
      * @param {Object} speed - The last speed set by the user
      */
-    constructor(playbackObserver: PlaybackObserver, manifest: Manifest | null, speed: IReadOnlySharedReference<number>);
+    constructor(playbackObserver: PlaybackObserver, manifest: Manifest | null, segmentBuffersStore: SegmentBuffersStore | null, speed: IReadOnlySharedReference<number>);
     start(): void;
     /**
      * Update information on an upcoming discontinuity for a given buffer type and
@@ -68,10 +80,32 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
      * forever.
      */
     destroy(): void;
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case this method already performed the
+     * right handling steps.
+     */
+    private _checkDecipherabilityFreeze;
 }
 export interface IRebufferingControllerEvent {
     stalled: IStallingSituation;
     unstalled: null;
+    needsReload: null;
     warning: IPlayerError;
 }
 /**

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.js

@@ -55,14 +55,16 @@ var RebufferingController = /** @class */ (function (_super) {
      * @param {Object} manifest - The Manifest of the currently-played content.
      * @param {Object} speed - The last speed set by the user
      */
-    function RebufferingController(playbackObserver, manifest, speed) {
+    function RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed) {
         var _this = _super.call(this) || this;
         _this._playbackObserver = playbackObserver;
         _this._manifest = manifest;
+        _this._segmentBuffersStore = segmentBuffersStore;
         _this._speed = speed;
         _this._discontinuitiesStore = [];
         _this._isStarted = false;
         _this._canceller = new TaskCanceller();
+        _this._currentFreezeTimestamp = null;
         return _this;
     }
     RebufferingController.prototype.start = function () {
@@ -100,7 +102,7 @@ var RebufferingController = /** @class */ (function (_super) {
         this._canceller.signal.register(function () {
             playbackRateUpdater.dispose();
         });
-        var prevFreezingState;
+        var prevFreezingState = null;
         this._playbackObserver.listen(function (observation) {
             var _a;
             var discontinuitiesStore = _this._discontinuitiesStore;
@@ -117,6 +119,9 @@ var RebufferingController = /** @class */ (function (_super) {
             lastSeekingPosition = observation.seeking ?
                 Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) :
                 null;
+            if (_this._checkDecipherabilityFreeze(observation)) {
+                return;
+            }
             if (freezing !== null) {
                 var now = performance.now();
                 var referenceTimestamp = prevFreezingState === null ?
@@ -175,7 +180,7 @@ var RebufferingController = /** @class */ (function (_super) {
                     return;
                 }
                 else {
-                    log.warn("Init: ignored stall for too long, checking discontinuity", now - ignoredStallTimeStamp);
+                    log.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
                 }
             }
             ignoredStallTimeStamp = null;
@@ -291,6 +296,81 @@ var RebufferingController = /** @class */ (function (_super) {
     RebufferingController.prototype.destroy = function () {
         this._canceller.cancel();
     };
+    /**
+     * Support of contents with DRM on all the platforms out there is a pain in
+     * the *ss considering all the DRM-related bugs there are.
+     *
+     * We found out a frequent issue which is to be unable to play despite having
+     * all the decryption keys to play what is currently buffered.
+     * When this happens, re-creating the buffers from scratch, with a reload, is
+     * usually sufficient to unlock the situation.
+     *
+     * Although we prefer providing more targeted fixes or telling to platform
+     * developpers to fix their implementation, it's not always possible.
+     * We thus resorted to developping an heuristic which detects such situation
+     * and reload in that case.
+     *
+     * @param {Object} observation - The last playback observation produced, it
+     * has to be recent (just triggered for example).
+     * @returns {boolean} - Returns `true` if it seems to be such kind of
+     * decipherability freeze, in which case this method already performed the
+     * right handling steps.
+     */
+    RebufferingController.prototype._checkDecipherabilityFreeze = function (observation) {
+        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        var bufferGap = observation.bufferGap !== undefined &&
+            isFinite(observation.bufferGap) ? observation.bufferGap :
+            0;
+        if (this._segmentBuffersStore === null ||
+            bufferGap < 6 ||
+            (rebuffering === null && freezing === null) ||
+            readyState > 1) {
+            this._currentFreezeTimestamp = null;
+            return false;
+        }
+        var now = performance.now();
+        if (this._currentFreezeTimestamp === null) {
+            this._currentFreezeTimestamp = now;
+        }
+        var rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
+        var frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
+        if ((rebufferingForTooLong || frozenForTooLong) &&
+            performance.now() - this._currentFreezeTimestamp > 4000) {
+            var statusAudio = this._segmentBuffersStore.getStatus("audio");
+            var statusVideo = this._segmentBuffersStore.getStatus("video");
+            var hasOnlyDecipherableSegments = true;
+            var isClear = true;
+            for (var _i = 0, _a = [statusAudio, statusVideo]; _i < _a.length; _i++) {
+                var status_1 = _a[_i];
+                if (status_1.type === "initialized") {
+                    for (var _b = 0, _c = status_1.value.getInventory(); _b < _c.length; _b++) {
+                        var segment = _c[_b];
+                        var representation = segment.infos.representation;
+                        if (representation.decipherable === false) {
+                            log.warn("Init: we have undecipherable segments left in the buffer, reloading");
+                            this._currentFreezeTimestamp = null;
+                            this.trigger("needsReload", null);
+                            return true;
+                        }
+                        else if (representation.contentProtections !== undefined) {
+                            isClear = false;
+                            if (representation.decipherable !== true) {
+                                hasOnlyDecipherableSegments = false;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!isClear && hasOnlyDecipherableSegments) {
+                log.warn("Init: we are frozen despite only having decipherable " +
+                    "segments left in the buffer, reloading");
+                this._currentFreezeTimestamp = null;
+                this.trigger("needsReload", null);
+                return true;
+            }
+        }
+        return false;
+    };
     return RebufferingController;
 }(EventEmitter));
 export default RebufferingController;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/stream_events_emitter.js

@@ -35,13 +35,15 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
         scheduledEventsRef.setValue(refreshScheduledEventsList(prev, manifest));
     }, cancelSignal);
     var isPollingEvents = false;
-    var cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+    var cancelCurrentPolling = new TaskCanceller();
+    cancelCurrentPolling.linkToSignal(cancelSignal);
     scheduledEventsRef.onUpdate(function (_a) {
         var scheduledEventsLength = _a.length;
         if (scheduledEventsLength === 0) {
             if (isPollingEvents) {
                 cancelCurrentPolling.cancel();
-                cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+                cancelCurrentPolling = new TaskCanceller();
+                cancelCurrentPolling.linkToSignal(cancelSignal);
                 isPollingEvents = false;
             }
             return;
@@ -127,7 +129,7 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
                 else {
                     onEventSkip(event_2.value);
                 }
-                if (stopSignal.isCancelled) {
+                if (stopSignal.isCancelled()) {
                     return;
                 }
             }
@@ -138,7 +140,7 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
                 if (typeof event_3.onExit === "function") {
                     event_3.onExit();
                 }
-                if (stopSignal.isCancelled) {
+                if (stopSignal.isCancelled()) {
                     return;
                 }
             }

package/dist/_esm5.processed/core/init/utils/throw_on_media_error.js

@@ -21,7 +21,7 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
  * @param {Object} cancelSignal
  */
 export default function listenToMediaError(mediaElement, onError, cancelSignal) {
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
         return;
     }
     mediaElement.addEventListener("error", onMediaError);