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

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 () {
@@ -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/segment_buffers/implementations/audio_video/audio_video_segment_buffer.d.ts

@@ -49,16 +49,25 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      */
     private _pendingTask;
     /**
-     * Keep track of the of the latest init segment pushed in the linked
-     * SourceBuffer.
+     * Keep track of the unique identifier of the  of the latest init segment
+     * pushed to the linked SourceBuffer.
      *
-     * This allows to be sure the right initialization segment is pushed before
-     * any chunk is.
+     * Such identifiers are first declared through the `declareInitSegment`
+     * method and the corresponding initialization segment is then pushed through
+     * the `pushChunk` method.
+     *
+     * Keeping track of this allows to be sure the right initialization segment is
+     * pushed before any chunk is.
      *
      * `null` if no initialization segment have been pushed to the
      * `AudioVideoSegmentBuffer` yet.
      */
-    private _lastInitSegment;
+    private _lastInitSegmentUniqueId;
+    /**
+     * Link unique identifiers for initialization segments (as communicated by
+     * `declareInitSegment`) to the corresponding initialization data.
+     */
+    private _initSegmentsMap;
     /**
      * @constructor
      * @param {string} bufferType
@@ -66,6 +75,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      * @param {MediaSource} mediaSource
      */
     constructor(bufferType: "audio" | "video", codec: string, mediaSource: MediaSource);
+    declareInitSegment(uniqueId: string, initSegmentData: unknown): void;
+    freeInitSegment(uniqueId: string): void;
     /**
      * Push a chunk of the media segment given to the attached SourceBuffer, in a
      * FIFO queue.
@@ -162,9 +173,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
      */
     private _preparePushOperation;
     /**
-     * Return `true` if the given `segmentData` is the same segment than the last
+     * Return `true` if the given `uniqueId` is the identifier of the last
      * initialization segment pushed to the `AudioVideoSegmentBuffer`.
-     * @param {BufferSource} segmentData
+     * @param {string} uniqueId
      * @returns {boolean}
      */
     private _isLastInitSegment;

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -32,11 +32,8 @@ import { tryToChangeSourceBufferType, } from "../../../../compat";
 import config from "../../../../config";
 import log from "../../../../log";
 import { getLoggableSegmentId } from "../../../../manifest";
-import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
-import { toUint8Array } from "../../../../utils/byte_parsing";
 import createCancellablePromise from "../../../../utils/create_cancellable_promise";
-import hashBuffer from "../../../../utils/hash_buffer";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import TaskCanceller, { CancellationError, } from "../../../../utils/task_canceller";
@@ -68,8 +65,9 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         _this._sourceBuffer = sourceBuffer;
         _this._queue = [];
         _this._pendingTask = null;
-        _this._lastInitSegment = null;
+        _this._lastInitSegmentUniqueId = null;
         _this.codec = codec;
+        _this._initSegmentsMap = new Map();
         var onError = _this._onPendingTaskError.bind(_this);
         var reCheck = _this._flush.bind(_this);
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
@@ -89,6 +87,13 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         });
         return _this;
     }
+    AudioVideoSegmentBuffer.prototype.declareInitSegment = function (uniqueId, initSegmentData) {
+        assertDataIsBufferSource(initSegmentData);
+        this._initSegmentsMap.set(uniqueId, initSegmentData);
+    };
+    AudioVideoSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        this._initSegmentsMap.delete(uniqueId);
+    };
     /**
      * Push a chunk of the media segment given to the attached SourceBuffer, in a
      * FIFO queue.
@@ -117,7 +122,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @returns {Promise}
      */
     AudioVideoSegmentBuffer.prototype.pushChunk = function (infos, cancellationSignal) {
-        assertPushedDataIsBufferSource(infos);
+        assertDataIsBufferSource(infos.data.chunk);
         log.debug("AVSB: receiving order to push data to the SourceBuffer", this.bufferType, getLoggableSegmentId(infos.inventoryInfos));
         return this._addToQueue({ type: SegmentBufferOperation.Push,
             value: infos }, cancellationSignal);
@@ -211,7 +216,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      * @param {Event} err
      */
     AudioVideoSegmentBuffer.prototype._onPendingTaskError = function (err) {
-        this._lastInitSegment = null; // initialize init segment as a security
+        this._lastInitSegmentUniqueId = null; // initialize init segment as a security
         if (this._pendingTask !== null) {
             var error = err instanceof Error ?
                 err :
@@ -304,7 +309,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                     var error = e instanceof Error ?
                         e :
                         new Error("An unknown error occured when preparing a push operation");
-                    this._lastInitSegment = null; // initialize init segment as a security
+                    this._lastInitSegmentUniqueId = null; // initialize init segment as a security
                     nextItem.reject(error);
                     return;
                 }
@@ -392,14 +397,16 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         else if (appendWindow[1] !== this._sourceBuffer.appendWindowEnd) {
             this._sourceBuffer.appendWindowEnd = appendWindow[1];
         }
-        if (data.initSegment !== null &&
-            (hasUpdatedSourceBufferType || !this._isLastInitSegment(data.initSegment))) {
+        if (data.initSegmentUniqueId !== null &&
+            (hasUpdatedSourceBufferType ||
+                !this._isLastInitSegment(data.initSegmentUniqueId))) {
             // Push initialization segment before the media segment
-            var segmentData = data.initSegment;
+            var segmentData = this._initSegmentsMap.get(data.initSegmentUniqueId);
+            if (segmentData === undefined) {
+                throw new Error("Invalid initialization segment uniqueId");
+            }
             dataToPush.push(segmentData);
-            var initU8 = toUint8Array(segmentData);
-            this._lastInitSegment = { data: initU8,
-                hash: hashBuffer(initU8) };
+            this._lastInitSegmentUniqueId = data.initSegmentUniqueId;
         }
         if (data.chunk !== null) {
             dataToPush.push(data.chunk);
@@ -407,27 +414,16 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         return dataToPush;
     };
     /**
-     * Return `true` if the given `segmentData` is the same segment than the last
+     * Return `true` if the given `uniqueId` is the identifier of the last
      * initialization segment pushed to the `AudioVideoSegmentBuffer`.
-     * @param {BufferSource} segmentData
+     * @param {string} uniqueId
      * @returns {boolean}
      */
-    AudioVideoSegmentBuffer.prototype._isLastInitSegment = function (segmentData) {
-        if (this._lastInitSegment === null) {
+    AudioVideoSegmentBuffer.prototype._isLastInitSegment = function (uniqueId) {
+        if (this._lastInitSegmentUniqueId === null) {
             return false;
         }
-        if (this._lastInitSegment.data === segmentData) {
-            return true;
-        }
-        var oldInit = this._lastInitSegment.data;
-        if (oldInit.byteLength === segmentData.byteLength) {
-            var newInitU8 = toUint8Array(segmentData);
-            if (hashBuffer(newInitU8) === this._lastInitSegment.hash &&
-                areArraysOfNumbersEqual(oldInit, newInitU8)) {
-                return true;
-            }
-        }
-        return false;
+        return this._lastInitSegmentUniqueId === uniqueId;
     };
     return AudioVideoSegmentBuffer;
 }(SegmentBuffer));
@@ -436,21 +432,16 @@ export default AudioVideoSegmentBuffer;
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
  * difficult to enforce.
- * @param {Object} pushedData
+ * @param {Object} data
  */
-function assertPushedDataIsBufferSource(pushedData) {
+function assertDataIsBufferSource(data) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    var _a = pushedData.data, chunk = _a.chunk, initSegment = _a.initSegment;
-    if (typeof chunk !== "object" ||
-        typeof initSegment !== "object" ||
-        (chunk !== null &&
-            !(chunk instanceof ArrayBuffer) &&
-            !(chunk.buffer instanceof ArrayBuffer)) ||
-        (initSegment !== null &&
-            !(initSegment instanceof ArrayBuffer) &&
-            !(initSegment.buffer instanceof ArrayBuffer))) {
+    if (typeof data !== "object" ||
+        (data !== null &&
+            !(data instanceof ArrayBuffer) &&
+            !(data.buffer instanceof ArrayBuffer))) {
         throw new Error("Invalid data given to the AudioVideoSegmentBuffer");
     }
 }

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.d.ts

@@ -47,6 +47,14 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
      * @param {HTMLElement} textTrackElement
      */
     constructor(videoElement: HTMLMediaElement, textTrackElement: HTMLElement);
+    /**
+     * @param {string} uniqueId
+     */
+    declareInitSegment(uniqueId: string): void;
+    /**
+     * @param {string} uniqueId
+     */
+    freeInitSegment(uniqueId: string): void;
     /**
      * Push text segment to the HTMLTextSegmentBuffer.
      * @param {Object} infos

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -93,6 +93,18 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         _this.autoRefreshSubtitles(_this._canceller.signal);
         return _this;
     }
+    /**
+     * @param {string} uniqueId
+     */
+    HTMLTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
+        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    };
+    /**
+     * @param {string} uniqueId
+     */
+    HTMLTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    };
     /**
      * Push text segment to the HTMLTextSegmentBuffer.
      * @param {Object} infos

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.d.ts

@@ -31,6 +31,14 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
      * @param {HTMLMediaElement} videoElement
      */
     constructor(videoElement: HTMLMediaElement);
+    /**
+     * @param {string} uniqueId
+     */
+    declareInitSegment(uniqueId: string): void;
+    /**
+     * @param {string} uniqueId
+     */
+    freeInitSegment(uniqueId: string): void;
     /**
      * @param {Object} infos
      * @returns {Promise}

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -57,6 +57,18 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
         _this._trackElement = trackElement;
         return _this;
     }
+    /**
+     * @param {string} uniqueId
+     */
+    NativeTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
+        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    };
+    /**
+     * @param {string} uniqueId
+     */
+    NativeTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
+        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    };
     /**
      * @param {Object} infos
      * @returns {Promise}

package/dist/_esm5.processed/core/segment_buffers/implementations/types.d.ts

@@ -68,6 +68,8 @@ export declare abstract class SegmentBuffer {
      */
     codec: string | undefined;
     constructor();
+    abstract declareInitSegment(uniqueId: string, initSegmentData: unknown): void;
+    abstract freeInitSegment(uniqueId: string): void;
     /**
      * Push a chunk of the media segment given to the attached buffer, in a
      * FIFO queue.
@@ -77,7 +79,8 @@ export declare abstract class SegmentBuffer {
      * pushed.
      *
      * Depending on the type of data appended, the pushed chunk might rely on an
-     * initialization segment, given through the `data.initSegment` property.
+     * initialization segment, which had to be previously declared through the
+     * `declareInitSegment` method.
      *
      * Such initialization segment will be first pushed to the buffer if the
      * last pushed segment was associated to another initialization segment.
@@ -87,7 +90,7 @@ export declare abstract class SegmentBuffer {
      * reference).
      *
      * If you don't need any initialization segment to push the wanted chunk, you
-     * can just set `data.initSegment` to `null`.
+     * can just set the corresponding property to `null`.
      *
      * You can also only push an initialization segment by setting the
      * `data.chunk` argument to null.
@@ -177,12 +180,16 @@ export type IBufferType = "audio" | "video" | "text";
  */
 export interface IPushedChunkData<T> {
     /**
-     * The whole initialization segment's data related to the chunk you want to
+     * The `uniqueId` of the initialization segment linked to the data you want to
      * push.
+     *
+     * That identifier should previously have been declared through the
+     * `declareInitSegment` method and not freed.
+     *
      * To set to `null` either if no initialization data is needed, or if you are
      * confident that the last pushed one is compatible.
      */
-    initSegment: T | null;
+    initSegmentUniqueId: string | null;
     /**
      * Chunk you want to push.
      * This can be the whole decodable segment's data or just a decodable sub-part

package/dist/_esm5.processed/core/segment_buffers/index.d.ts

@@ -15,7 +15,7 @@
  */
 import BufferGarbageCollector from "./garbage_collector";
 import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
-import { IBufferedChunk, IChunkContext, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
+import { IBufferedChunk, IChunkContext, IInsertedChunkInfos, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod } from "./inventory";
 import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };
+export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };

package/dist/_esm5.processed/core/stream/adaptation/utils/create_representation_estimator.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 Manifest, { Adaptation, Period, Representation } from "../../../../manifest";
+import { IPlayerError } from "../../../../public_types";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
+import { CancellationSignal } from "../../../../utils/task_canceller";
+import { IABREstimate, IRepresentationEstimatorPlaybackObservation, IRepresentationEstimator, IRepresentationEstimatorCallbacks } from "../../../adaptive";
+import { IReadOnlyPlaybackObserver } from "../../../api";
+/**
+ * Produce estimates to know which Representation should be played.
+ * @param {Object} content - The Manifest, Period and Adaptation wanted.
+ * @param {Object} representationEstimator - `IRepresentationEstimator` which
+ * will produce Representation estimates.
+ * @param {Object} currentRepresentation - Reference emitting the
+ * currently-loaded Representation.
+ * @param {Object} playbackObserver - Allows to observe the current playback
+ * conditions.
+ * @param {Function} onFatalError - Callback called when a fatal error was
+ * thrown. Once this callback is called, no estimate will be produced.
+ * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
+ * the production of estimates (and clean-up all linked resources).
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `estimateRef`: Reference emitting the last estimate
+ *   - `abrCallbacks`: Callbacks allowing to report back network and playback
+ *     activities to improve the estimates given.
+ */
+export default function getRepresentationEstimate(content: {
+    manifest: Manifest;
+    period: Period;
+    adaptation: Adaptation;
+}, representationEstimator: IRepresentationEstimator, currentRepresentation: IReadOnlySharedReference<Representation | null>, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationEstimatorPlaybackObservation>, onFatalError: (err: IPlayerError) => void, cancellationSignal: CancellationSignal): {
+    estimateRef: IReadOnlySharedReference<IABREstimate>;
+    abrCallbacks: IRepresentationEstimatorCallbacks;
+};

package/dist/_esm5.processed/core/stream/adaptation/utils/create_representation_estimator.js

@@ -0,0 +1,70 @@
+/**
+ * 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 { MediaError } from "../../../../errors";
+import createSharedReference from "../../../../utils/reference";
+/**
+ * Produce estimates to know which Representation should be played.
+ * @param {Object} content - The Manifest, Period and Adaptation wanted.
+ * @param {Object} representationEstimator - `IRepresentationEstimator` which
+ * will produce Representation estimates.
+ * @param {Object} currentRepresentation - Reference emitting the
+ * currently-loaded Representation.
+ * @param {Object} playbackObserver - Allows to observe the current playback
+ * conditions.
+ * @param {Function} onFatalError - Callback called when a fatal error was
+ * thrown. Once this callback is called, no estimate will be produced.
+ * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
+ * the production of estimates (and clean-up all linked resources).
+ * @returns {Object} - Returns an object with the following properties:
+ *   - `estimateRef`: Reference emitting the last estimate
+ *   - `abrCallbacks`: Callbacks allowing to report back network and playback
+ *     activities to improve the estimates given.
+ */
+export default function getRepresentationEstimate(content, representationEstimator, currentRepresentation, playbackObserver, onFatalError, cancellationSignal) {
+    var manifest = content.manifest, adaptation = content.adaptation;
+    var representations = createSharedReference([], cancellationSignal);
+    updateRepresentationsReference();
+    manifest.addEventListener("decipherabilityUpdate", updateRepresentationsReference);
+    var unregisterCleanUp = cancellationSignal.register(cleanUp);
+    var _a = representationEstimator(content, currentRepresentation, representations, playbackObserver, cancellationSignal), estimateRef = _a.estimates, abrCallbacks = _a.callbacks;
+    return { abrCallbacks: abrCallbacks, estimateRef: estimateRef };
+    function updateRepresentationsReference() {
+        /** Representations for which a `RepresentationStream` can be created. */
+        var newRepr = adaptation.getPlayableRepresentations();
+        if (newRepr.length === 0) {
+            var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
+                adaptation.type + " Adaptation can be played", { adaptation: adaptation });
+            cleanUp();
+            onFatalError(noRepErr);
+            return;
+        }
+        var prevRepr = representations.getValue();
+        if (prevRepr.length === newRepr.length) {
+            if (prevRepr.every(function (r, idx) { return r.id === newRepr[idx].id; })) {
+                return;
+            }
+        }
+        representations.setValue(newRepr);
+    }
+    /** Clean-up all resources taken here. */
+    function cleanUp() {
+        manifest.removeEventListener("decipherabilityUpdate", updateRepresentationsReference);
+        // check to protect against the case where it is not yet defined.
+        if (typeof unregisterCleanUp !== "undefined") {
+            unregisterCleanUp();
+        }
+    }
+}

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -201,7 +201,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             launchConsecutiveStreamsForPeriod(nextPeriod);
         }, { clearSignal: orchestratorCancelSignal, includeLastObservation: true });
         manifest.addEventListener("decipherabilityUpdate", function (evt) {
+            if (orchestratorCancelSignal.isCancelled()) {
+                return;
+            }
             onDecipherabilityUpdates(evt).catch(function (err) {
+                if (orchestratorCancelSignal.isCancelled()) {
+                    return;
+                }
                 currentCanceller.cancel();
                 callbacks.error(err);
             });
@@ -408,12 +414,10 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         var periodStreamArgs = { bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, maxVideoBufferSize: maxVideoBufferSize, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, representationEstimator: representationEstimator, wantedBufferAhead: wantedBufferAhead };
         var periodStreamCallbacks = __assign(__assign({}, consecutivePeriodStreamCb), { streamStatusUpdate: function (value) {
                 if (value.hasFinishedLoading) {
-                    if (nextStreamInfo === null) {
-                        var nextPeriod = manifest.getPeriodAfter(basePeriod);
-                        if (nextPeriod !== null) {
-                            // current Stream is full, create the next one if not
-                            createNextPeriodStream(nextPeriod);
-                        }
+                    var nextPeriod = manifest.getPeriodAfter(basePeriod);
+                    if (nextPeriod !== null) {
+                        // current Stream is full, create the next one if not
+                        checkOrCreateNextPeriodStream(nextPeriod);
                     }
                 }
                 else if (nextStreamInfo !== null) {
@@ -439,9 +443,12 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
          * @param {Object} nextPeriod
          */
-        function createNextPeriodStream(nextPeriod) {
+        function checkOrCreateNextPeriodStream(nextPeriod) {
             if (nextStreamInfo !== null) {
-                log.warn("Stream: Creating next `PeriodStream` while it was already created.");
+                if (nextStreamInfo.period.id === nextPeriod.id) {
+                    return;
+                }
+                log.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
                 consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
                 nextStreamInfo.canceller.cancel();
             }

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -325,7 +325,7 @@ function getFirstDeclaredMimeType(adaptation) {
     var representations = adaptation.getPlayableRepresentations();
     if (representations.length === 0) {
         var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-            adaptation.type + " Adaptation can be played");
+            adaptation.type + " Adaptation can be played", { adaptation: adaptation });
         throw noRepErr;
     }
     return representations[0].getMimeTypeString();