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

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

@@ -147,9 +147,10 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
-    segmentBuffersStore.getBufferTypes().map(function (bufferType) {
+    for (var _i = 0, _b = segmentBuffersStore.getBufferTypes(); _i < _b.length; _i++) {
+        var bufferType = _b[_i];
         manageEveryStreams(bufferType, initialPeriod);
-    });
+    }
     /**
      * Manage creation and removal of Streams for every Periods for a given type.
      *
@@ -171,7 +172,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          */
         var enableOutOfBoundsCheck = false;
         /** Cancels currently created `PeriodStream`s. */
-        var currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+        var currentCanceller = new TaskCanceller();
+        currentCanceller.linkToSignal(orchestratorCancelSignal);
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
         playbackObserver.listen(function (_a) {
@@ -189,7 +191,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
             }
             currentCanceller.cancel();
-            currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+            currentCanceller = new TaskCanceller();
+            currentCanceller.linkToSignal(orchestratorCancelSignal);
             var nextPeriod = (_c = manifest.getPeriodForTime(time)) !== null && _c !== void 0 ? _c : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
                 log.warn("Stream: The wanted position is not found in the Manifest.");
@@ -198,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);
             });
@@ -265,8 +274,15 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
                             ofCurrentType = updates
                                 .filter(function (update) { return update.adaptation.type === bufferType; });
-                            if (ofCurrentType.length === 0 || segmentBufferStatus.type !== "initialized") {
-                                return [2 /*return*/]; // no need to stop the current Streams.
+                            if (
+                            // No update concerns the current type of data
+                            ofCurrentType.length === 0 ||
+                                segmentBufferStatus.type !== "initialized" ||
+                                // The update only notifies of now-decipherable streams
+                                ofCurrentType.every(function (x) { return x.representation.decipherable === true; })) {
+                                // Data won't have to be removed from the buffers, no need to stop the
+                                // current Streams.
+                                return [2 /*return*/];
                             }
                             segmentBuffer = segmentBufferStatus.value;
                             resettedContent = ofCurrentType.filter(function (update) {
@@ -287,7 +303,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                 callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
                             }
                             currentCanceller.cancel();
-                            currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+                            currentCanceller = new TaskCanceller();
+                            currentCanceller.linkToSignal(orchestratorCancelSignal);
                             _i = 0, _a = __spreadArray(__spreadArray([], undecipherableRanges, true), rangesToRemove, true);
                             _c.label = 1;
                         case 1:
@@ -307,7 +324,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             // was going to be emitted synchronously.
                             nextTick(function () {
                                 var _a, _b;
-                                if (orchestratorCancelSignal.isCancelled) {
+                                if (orchestratorCancelSignal.isCancelled()) {
                                     return;
                                 }
                                 var observation = playbackObserver.getReference().getValue();
@@ -316,13 +333,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                     callbacks.needsDecipherabilityFlush({ position: observation.position.last,
                                         autoPlay: shouldAutoPlay,
                                         duration: observation.duration });
-                                    if (orchestratorCancelSignal.isCancelled) {
+                                    if (orchestratorCancelSignal.isCancelled()) {
                                         return;
                                     }
                                 }
                                 else if (needsFlushingAfterClean(observation, rangesToRemove)) {
                                     callbacks.needsBufferFlush();
-                                    if (orchestratorCancelSignal.isCancelled) {
+                                    if (orchestratorCancelSignal.isCancelled()) {
                                         return;
                                     }
                                 }
@@ -379,7 +396,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          */
         var nextStreamInfo = null;
         /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-        var currentStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        var currentStreamCanceller = new TaskCanceller();
+        currentStreamCanceller.linkToSignal(cancelSignal);
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
         playbackObserver.listen(function (_a, stopListeningObservations) {
@@ -396,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) {
@@ -427,13 +443,18 @@ 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();
             }
-            nextStreamInfo = { canceller: new TaskCanceller({ cancelOn: cancelSignal }),
+            var nextStreamCanceller = new TaskCanceller();
+            nextStreamCanceller.linkToSignal(cancelSignal);
+            nextStreamInfo = { canceller: nextStreamCanceller,
                 period: nextPeriod };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }

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

@@ -113,7 +113,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
      */
     var adaptationRef = createSharedReference(undefined, parentCancelSignal);
     callbacks.periodStreamReady({ type: bufferType, manifest: manifest, period: period, adaptationRef: adaptationRef });
-    if (parentCancelSignal.isCancelled) {
+    if (parentCancelSignal.isCancelled()) {
         return;
     }
     var currentStreamCanceller;
@@ -129,7 +129,8 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         if (choice === undefined) {
                             return [2 /*return*/];
                         }
-                        streamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+                        streamCanceller = new TaskCanceller();
+                        streamCanceller.linkToSignal(parentCancelSignal);
                         currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
                         currentStreamCanceller = streamCanceller;
                         if (!(choice === null)) return [3 /*break*/, 7];
@@ -151,7 +152,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 2: return [4 /*yield*/, segmentBufferStatus.value.removeBuffer(period.start, periodEnd, streamCanceller.signal)];
                     case 3:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The stream has been cancelled
                         }
                         _d.label = 4;
@@ -159,14 +160,14 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 5:
                         if (segmentBufferStatus.type === "uninitialized") {
                             segmentBuffersStore.disableSegmentBuffer(bufferType);
-                            if (streamCanceller.isUsed) {
+                            if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // The stream has been cancelled
                             }
                         }
                         _d.label = 6;
                     case 6:
                         callbacks.adaptationChange({ type: bufferType, adaptation: null, period: period });
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken Stream cancellation by side-effect
                         }
                         return [2 /*return*/, createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, streamCanceller.signal)];
@@ -209,7 +210,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         adaptation = choice.adaptation, representations = choice.representations;
                         log.info("Stream: Updating ".concat(bufferType, " adaptation"), "A: ".concat(adaptation.id), "P: ".concat(period.start));
                         callbacks.adaptationChange({ type: bufferType, adaptation: adaptation, period: period });
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken cancellation by side-effect
                         }
                         readyState = playbackObserver.getReadyState();
@@ -225,7 +226,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         return [4 /*yield*/, segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal)];
                     case 8:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The Stream has since been cancelled
                         }
                         if (!(strategy.type === "flush-buffer" || strategy.type === "clean-buffer")) return [3 /*break*/, 13];
@@ -237,7 +238,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         return [4 /*yield*/, segmentBuffer.removeBuffer(start, end, streamCanceller.signal)];
                     case 10:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The Stream has since been cancelled
                         }
                         _d.label = 11;
@@ -247,7 +248,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 12:
                         if (strategy.type === "flush-buffer") {
                             callbacks.needsBufferFlush();
-                            if (streamCanceller.isUsed) {
+                            if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // Previous callback cancelled the Stream by side-effect
                             }
                         }
@@ -287,7 +288,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     defaultReason: "Unknown `AdaptationStream` error",
                 });
                 callbacks.warning(formattedError);
-                if (cancelSignal.isCancelled) {
+                if (cancelSignal.isCancelled()) {
                     return; // Previous callback cancelled the Stream by side-effect
                 }
                 return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, cancelSignal);
@@ -324,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();

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -72,21 +72,27 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     var bufferGoal = options.bufferGoal, maxBufferSize = options.maxBufferSize, drmSystemId = options.drmSystemId, fastSwitchThreshold = options.fastSwitchThreshold;
     var bufferType = adaptation.type;
     /** `TaskCanceller` stopping ALL operations performed by the `RepresentationStream` */
-    var globalCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+    var globalCanceller = new TaskCanceller();
+    globalCanceller.linkToSignal(parentCancelSignal);
     /**
      * `TaskCanceller` allowing to only stop segment loading and checking operations.
      * This allows to stop only tasks linked to network resource usage, which is
      * often a limited resource, while still letting buffer operations to finish.
      */
-    var segmentsLoadingCanceller = new TaskCanceller({
-        cancelOn: globalCanceller.signal,
-    });
+    var segmentsLoadingCanceller = new TaskCanceller();
+    segmentsLoadingCanceller.linkToSignal(globalCanceller.signal);
     /** Saved initialization segment state for this representation. */
     var initSegmentState = {
         segment: representation.index.getInitSegment(),
-        segmentData: null,
+        uniqueId: null,
         isLoaded: false,
     };
+    globalCanceller.signal.register(function () {
+        // Free initialization segment if one has been declared
+        if (initSegmentState.uniqueId !== null) {
+            segmentBuffer.freeInitSegment(initSegmentState.uniqueId);
+        }
+    });
     /** Emit the last scheduled downloading queue for segments. */
     var lastSegmentQueue = createSharedReference({
         initSegment: null,
@@ -95,7 +101,6 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     /** If `true`, the current Representation has a linked initialization segment. */
     var hasInitSegment = initSegmentState.segment !== null;
     if (!hasInitSegment) {
-        initSegmentState.segmentData = null;
         initSegmentState.isLoaded = true;
     }
     /**
@@ -114,7 +119,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         if (encryptionData.length > 0 && encryptionData.every(function (e) { return e.keyIds !== undefined; })) {
             hasSentEncryptionData = true;
             callbacks.encryptionDataEncountered(encryptionData.map(function (d) { return objectAssign({ content: content }, d); }));
-            if (globalCanceller.isUsed) {
+            if (globalCanceller.isUsed()) {
                 return; // previous callback has stopped everything by side-effect
             }
         }
@@ -122,7 +127,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     /** Will load every segments in `lastSegmentQueue` */
     var downloadingQueue = new DownloadingQueue(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
     downloadingQueue.addEventListener("error", function (err) {
-        if (segmentsLoadingCanceller.signal.isCancelled) {
+        if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // ignore post requests-cancellation loading-related errors,
         }
         globalCanceller.cancel(); // Stop every operations
@@ -133,7 +138,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     downloadingQueue.addEventListener("emptyQueue", checkStatus);
     downloadingQueue.addEventListener("requestRetry", function (payload) {
         callbacks.warning(payload.error);
-        if (segmentsLoadingCanceller.signal.isCancelled) {
+        if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // If the previous callback led to loading operations being stopped, skip
         }
         var retriedSegment = payload.segment;
@@ -179,7 +184,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
      */
     function checkStatus() {
         var _a, _b;
-        if (segmentsLoadingCanceller.isUsed) {
+        if (segmentsLoadingCanceller.isUsed()) {
             return; // Stop all buffer status checking if load operations are stopped
         }
         var observation = playbackObserver.getReference().getValue();
@@ -251,14 +256,14 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             isEmptyStream: false,
             hasFinishedLoading: status.hasFinishedLoading,
             neededSegments: status.neededSegments });
-        if (segmentsLoadingCanceller.signal.isCancelled) {
+        if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // previous callback has stopped loading operations by side-effect
         }
         var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
             var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
-                segmentBuffer.removeBuffer(0, gcedPosition, segmentsLoadingCanceller.signal)
+                segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
                     .catch(onFatalBufferError);
             }
         }
@@ -272,7 +277,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
      * @param {Object} evt
      */
     function onParsedChunk(evt) {
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
             // We should not do anything with segments if the `RepresentationStream`
             // is not running anymore.
             return;
@@ -293,7 +298,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 callbacks.encryptionDataEncountered(allEncryptionData.map(function (p) { return objectAssign({ content: content }, p); }));
                 hasSentEncryptionData = true;
                 // previous callback could have lead to cancellation
-                if (globalCanceller.isUsed) {
+                if (globalCanceller.isUsed()) {
                     return;
                 }
             }
@@ -303,16 +308,20 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 evt.segmentList !== undefined) {
                 representation.index.initialize(evt.segmentList);
             }
-            initSegmentState.segmentData = evt.initializationData;
             initSegmentState.isLoaded = true;
-            pushInitSegment({ playbackObserver: playbackObserver, content: content, segment: evt.segment,
-                segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
-                .then(function (result) {
-                if (result !== null) {
-                    callbacks.addedSegment(result);
-                }
-            })
-                .catch(onFatalBufferError);
+            if (evt.initializationData !== null) {
+                var initSegmentUniqueId = representation.uniqueId;
+                initSegmentState.uniqueId = initSegmentUniqueId;
+                segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
+                pushInitSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
+                    segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+                    .then(function (result) {
+                    if (result !== null) {
+                        callbacks.addedSegment(result);
+                    }
+                })
+                    .catch(onFatalBufferError);
+            }
             // Sometimes the segment list is only known once the initialization segment
             // is parsed. Thus we immediately re-check if there's new segments to load.
             checkStatus();
@@ -325,18 +334,18 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             }
             if (needsManifestRefresh === true) {
                 callbacks.needsManifestRefresh();
-                if (globalCanceller.isUsed) {
+                if (globalCanceller.isUsed()) {
                     return; // previous callback has stopped everything by side-effect
                 }
             }
             if (inbandEvents !== undefined && inbandEvents.length > 0) {
                 callbacks.inbandEvent(inbandEvents);
-                if (globalCanceller.isUsed) {
+                if (globalCanceller.isUsed()) {
                     return; // previous callback has stopped everything by side-effect
                 }
             }
-            var initSegmentData = initSegmentState.segmentData;
-            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentData: initSegmentData, parsedSegment: evt,
+            var initSegmentUniqueId = initSegmentState.uniqueId;
+            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
                 segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
                 .then(function (result) {
                 if (result !== null) {
@@ -353,7 +362,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
      * @param {*} err
      */
     function onFatalBufferError(err) {
-        if (globalCanceller.isUsed && err instanceof CancellationError) {
+        if (globalCanceller.isUsed() && err instanceof CancellationError) {
             // The error is linked to cancellation AND we explicitely cancelled buffer
             // operations.
             // We can thus ignore it, it is very unlikely to lead to true buffer issues.

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.d.ts

@@ -15,7 +15,7 @@
  */
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
-import { IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
+import { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
 import { IRepresentationStreamPlaybackObservation } from "../types";
 /**
  * Append a segment to the given segmentBuffer.
@@ -27,4 +27,6 @@ import { IRepresentationStreamPlaybackObservation } from "../types";
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T>, cancellationSignal: CancellationSignal): Promise<void>;
+export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T> & {
+    inventoryInfos: IInsertedChunkInfos;
+}, cancellationSignal: CancellationSignal): Promise<void>;

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.js

@@ -79,7 +79,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     return [3 /*break*/, 8];
                 case 2:
                     appendError_1 = _b.sent();
-                    if (cancellationSignal.isCancelled && appendError_1 instanceof CancellationError) {
+                    if (cancellationSignal.isCancelled() && appendError_1 instanceof CancellationError) {
                         throw appendError_1;
                     }
                     else if (!(appendError_1 instanceof Error) ||
@@ -87,7 +87,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                         reason = appendError_1 instanceof Error ?
                             appendError_1.toString() :
                             "An unknown error happened when pushing content";
-                        throw new MediaError("BUFFER_APPEND_ERROR", reason);
+                        throw new MediaError("BUFFER_APPEND_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
                     }
                     position = playbackObserver.getReference().getValue().position;
                     currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
@@ -105,7 +105,7 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     err2_1 = _b.sent();
                     reason = err2_1 instanceof Error ? err2_1.toString() :
                         "Could not clean the buffer";
-                    throw new MediaError("BUFFER_FULL_ERROR", reason);
+                    throw new MediaError("BUFFER_FULL_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
                 case 7: return [3 /*break*/, 8];
                 case 8: return [2 /*return*/];
             }

package/dist/_esm5.processed/core/stream/representation/utils/downloading_queue.js

@@ -31,6 +31,7 @@ var __extends = (this && this.__extends) || (function () {
 import log from "../../../../log";
 import assert from "../../../../utils/assert";
 import EventEmitter from "../../../../utils/event_emitter";
+import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import createSharedReference from "../../../../utils/reference";
 import TaskCanceller from "../../../../utils/task_canceller";
@@ -171,6 +172,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
     DownloadingQueue.prototype.stop = function () {
         var _a;
         (_a = this._currentCanceller) === null || _a === void 0 ? void 0 : _a.cancel();
+        this._currentCanceller = null;
     };
     /**
      * Internal logic performing media segment requests.
@@ -183,8 +185,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
         var segmentQueue = this._downloadQueue.getValue().segmentQueue;
         var currentNeededSegment = segmentQueue[0];
         var recursivelyRequestSegments = function (startingSegment) {
-            var _a;
-            if (_this._currentCanceller !== null && _this._currentCanceller.isUsed) {
+            if (_this._currentCanceller !== null && _this._currentCanceller.isUsed()) {
                 _this._mediaSegmentRequest = null;
                 return;
             }
@@ -193,7 +194,10 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 _this.trigger("emptyQueue", null);
                 return;
             }
-            var canceller = new TaskCanceller({ cancelOn: (_a = _this._currentCanceller) === null || _a === void 0 ? void 0 : _a.signal });
+            var canceller = new TaskCanceller();
+            var unlinkCanceller = _this._currentCanceller === null ?
+                noop :
+                canceller.linkToSignal(_this._currentCanceller.signal);
             var segment = startingSegment.segment, priority = startingSegment.priority;
             var context = objectAssign({ segment: segment }, _this._content);
             /**
@@ -289,6 +293,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                  * requests are scheduled. It is used to schedule the next segment.
                  */
                 beforeEnded: function () {
+                    unlinkCanceller();
                     _this._mediaSegmentRequest = null;
                     if (isWaitingOnInitSegment) {
                         _this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, { clearSignal: canceller.signal });
@@ -299,6 +304,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 },
             }, canceller.signal);
             request.catch(function (error) {
+                unlinkCanceller();
                 if (!isComplete) {
                     isComplete = true;
                     _this.stop();
@@ -315,8 +321,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
      */
     DownloadingQueue.prototype._restartInitSegmentDownloadingQueue = function (queuedInitSegment) {
         var _this = this;
-        var _a;
-        if (this._currentCanceller !== null && this._currentCanceller.isUsed) {
+        if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
             return;
         }
         if (this._initSegmentRequest !== null) {
@@ -325,7 +330,10 @@ var DownloadingQueue = /** @class */ (function (_super) {
         if (queuedInitSegment === null) {
             return;
         }
-        var canceller = new TaskCanceller({ cancelOn: (_a = this._currentCanceller) === null || _a === void 0 ? void 0 : _a.signal });
+        var canceller = new TaskCanceller();
+        var unlinkCanceller = this._currentCanceller === null ?
+            noop :
+            canceller.linkToSignal(this._currentCanceller.signal);
         var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
         var context = objectAssign({ segment: segment }, this._content);
         /**
@@ -341,6 +349,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 log.info("Stream: init segment request interrupted temporarly.", segment.id);
             },
             beforeEnded: function () {
+                unlinkCanceller();
                 _this._initSegmentRequest = null;
                 isComplete = true;
             },
@@ -358,6 +367,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
             },
         }, canceller.signal);
         request.catch(function (error) {
+            unlinkCanceller();
             if (!isComplete) {
                 isComplete = true;
                 _this.stop();

package/dist/_esm5.processed/core/stream/representation/utils/push_init_segment.d.ts

@@ -24,7 +24,7 @@ import { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPaylo
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function pushInitSegment<T>({ playbackObserver, content, segment, segmentData, segmentBuffer, }: {
+export default function pushInitSegment<T>({ playbackObserver, content, initSegmentUniqueId, segment, segmentData, segmentBuffer, }: {
     playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     content: {
         adaptation: Adaptation;
@@ -32,7 +32,8 @@ export default function pushInitSegment<T>({ playbackObserver, content, segment,
         period: Period;
         representation: Representation;
     };
-    segmentData: T | null;
+    initSegmentUniqueId: string;
+    segmentData: T;
     segment: ISegment;
     segmentBuffer: SegmentBuffer;
 }, cancelSignal: CancellationSignal): Promise<IStreamEventAddedSegmentPayload<T> | null>;