rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -1,29 +1,51 @@
-/**
- * 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.
- */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
+import assertUnreachable from "../../../utils/assert_unreachable";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
 import SharedReference, { createMappedReference, } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 import RepresentationStream from "../representation";
-import createRepresentationEstimator from "./utils/create_representation_estimator";
+import getRepresentationsSwitchingStrategy from "./get_representations_switch_strategy";
 /**
  * Create new `AdaptationStream` whose task will be to download the media data
  * for a given Adaptation (i.e. "track").
@@ -56,7 +78,6 @@ import createRepresentationEstimator from "./utils/create_representation_estimat
  */
 export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
     var playbackObserver = _a.playbackObserver, content = _a.content, options = _a.options, representationEstimator = _a.representationEstimator, segmentBuffer = _a.segmentBuffer, segmentFetcherCreator = _a.segmentFetcherCreator, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
-    var directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
     /** Allows to cancel everything the `AdaptationStream` is doing. */
     var adapStreamCanceller = new TaskCanceller();
@@ -75,80 +96,149 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * `null` if no Representation is chosen for now.
      */
     var currentRepresentation = new SharedReference(null, adapStreamCanceller.signal);
-    var _b = createRepresentationEstimator(content, representationEstimator, currentRepresentation, playbackObserver, function (err) {
-        adapStreamCanceller.cancel();
-        callbacks.error(err);
-    }, adapStreamCanceller.signal), estimateRef = _b.estimateRef, abrCallbacks = _b.abrCallbacks;
-    /** Allows the `RepresentationStream` to easily fetch media segments. */
-    var segmentFetcher = segmentFetcherCreator
-        .createSegmentFetcher(adaptation.type, 
-    /* eslint-disable @typescript-eslint/unbound-method */
-    { onRequestBegin: abrCallbacks.requestBegin,
-        onRequestEnd: abrCallbacks.requestEnd,
-        onProgress: abrCallbacks.requestProgress,
-        onMetrics: abrCallbacks.metrics });
-    /* eslint-enable @typescript-eslint/unbound-method */
     /** Stores the last emitted bitrate. */
-    var previousBitrate;
-    /** Emit at each bitrate estimate done by the IRepresentationEstimator. */
-    estimateRef.onUpdate(function (_a) {
-        var bitrate = _a.bitrate;
-        if (bitrate === undefined) {
-            return;
-        }
-        if (bitrate === previousBitrate) {
-            return;
-        }
-        previousBitrate = bitrate;
-        log.debug("Stream: new ".concat(adaptation.type, " bitrate estimate"), bitrate);
-        callbacks.bitrateEstimationChange({ type: adaptation.type, bitrate: bitrate });
-    }, { emitCurrentValue: true, clearSignal: adapStreamCanceller.signal });
-    recursivelyCreateRepresentationStreams(true);
+    var previouslyEmittedBitrate;
+    /** When triggered, cancel all `RepresentationStream`s currently created. */
+    var cancelCurrentStreams;
+    // Each time the list of wanted Representations changes, we restart the logic
+    content.representations.onUpdate(function (val) {
+        cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.cancel();
+        cancelCurrentStreams = new TaskCanceller();
+        cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
+        onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch(function (err) {
+            if ((cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.isUsed()) === true &&
+                TaskCanceller.isCancellationError(err)) {
+                return;
+            }
+            adapStreamCanceller.cancel();
+            callbacks.error(err);
+        });
+    }, { clearSignal: adapStreamCanceller.signal, emitCurrentValue: true });
+    return;
+    /**
+     * Function called each time the list of wanted Representations is updated.
+     *
+     * Returns a Promise to profit from async/await syntax. The Promise resolution
+     * does not indicate anything. The Promise may reject however, either on some
+     * error or on some cancellation.
+     * @param {Object} choice - The last Representations choice that has been
+     * made.
+     * @param {Object} fnCancelSignal - `CancellationSignal` allowing to cancel
+     * everything this function is doing and free all related resources.
+     */
+    function onRepresentationsChoiceChange(choice, fnCancelSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            var switchStrat, _a, _i, _b, range, representationsList, _c, estimateRef, abrCallbacks;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        switchStrat = getRepresentationsSwitchingStrategy(period, adaptation, choice, segmentBuffer, playbackObserver);
+                        _a = switchStrat.type;
+                        switch (_a) {
+                            case "continue": return [3 /*break*/, 1];
+                            case "needs-reload": return [3 /*break*/, 2];
+                            case "flush-buffer": return [3 /*break*/, 3];
+                            case "clean-buffer": return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 8];
+                    case 1: return [3 /*break*/, 9]; // nothing to do
+                    case 2: // Just ask to reload
+                    // We begin by scheduling a micro-task to reduce the possibility of race
+                    // conditions where the inner logic would be called synchronously before
+                    // the next observation (which may reflect very different playback conditions)
+                    // is actually received.
+                    return [2 /*return*/, nextTick(function () {
+                            if (fnCancelSignal.isCancelled()) {
+                                return;
+                            }
+                            var DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
+                            var timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
+                            return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type, period: period, timeOffset: timeOffset, stayInPeriod: true });
+                        })];
+                    case 3:
+                        _i = 0, _b = switchStrat.value;
+                        _d.label = 4;
+                    case 4:
+                        if (!(_i < _b.length)) return [3 /*break*/, 7];
+                        range = _b[_i];
+                        return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal)];
+                    case 5:
+                        _d.sent();
+                        if (fnCancelSignal.isCancelled()) {
+                            return [2 /*return*/];
+                        }
+                        _d.label = 6;
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 4];
+                    case 7:
+                        if (switchStrat.type === "flush-buffer") {
+                            callbacks.needsBufferFlush();
+                            if (fnCancelSignal.isCancelled()) {
+                                return [2 /*return*/];
+                            }
+                        }
+                        return [3 /*break*/, 9];
+                    case 8:
+                        assertUnreachable(switchStrat);
+                        _d.label = 9;
+                    case 9:
+                        representationsList = new SharedReference(choice.representations);
+                        representationsList.finish();
+                        _c = representationEstimator({ manifest: manifest, period: period, adaptation: adaptation }, currentRepresentation, representationsList, playbackObserver, fnCancelSignal), estimateRef = _c.estimates, abrCallbacks = _c.callbacks;
+                        /** Emit at each bitrate estimate done by the IRepresentationEstimator. */
+                        estimateRef.onUpdate(function (_a) {
+                            var bitrate = _a.bitrate;
+                            if (bitrate === undefined || bitrate === previouslyEmittedBitrate) {
+                                return;
+                            }
+                            previouslyEmittedBitrate = bitrate;
+                            log.debug("Stream: new ".concat(adaptation.type, " bitrate estimate"), bitrate);
+                            callbacks.bitrateEstimateChange({ type: adaptation.type, bitrate: bitrate });
+                        }, { emitCurrentValue: true, clearSignal: fnCancelSignal });
+                        recursivelyCreateRepresentationStreams(estimateRef, abrCallbacks, fnCancelSignal);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
     /**
      * Create `RepresentationStream`s starting with the Representation of the last
      * estimate performed.
      * Each time a new estimate is made, this function will create a new
      * `RepresentationStream` corresponding to that new estimate.
-     * @param {boolean} isFirstEstimate - Whether this is the first time we're
-     * creating a `RepresentationStream` in the corresponding `AdaptationStream`.
-     * This is important because manual quality switches might need a full reload
-     * of the MediaSource _except_ if we are talking about the first quality chosen.
+     * @param {Object} estimateRef - Reference through which ABR estimates are
+     * set. May be updated at any time.
+     * @param {Object} abrCallbacks - Callbacks defined by the ABR logic that have
+     * to be called at the right time.
+     * @param {Object} fnCancelSignal - `CancellationSignal` which will abort
+     * anything this function is doing and free allocated resources.
      */
-    function recursivelyCreateRepresentationStreams(isFirstEstimate) {
+    function recursivelyCreateRepresentationStreams(estimateRef, abrCallbacks, fnCancelSignal) {
+        /** Allows a `RepresentationStream` to easily fetch media segments. */
+        var segmentFetcher = segmentFetcherCreator
+            .createSegmentFetcher(adaptation.type, 
+        /* eslint-disable @typescript-eslint/unbound-method */
+        { onRequestBegin: abrCallbacks.requestBegin,
+            onRequestEnd: abrCallbacks.requestEnd,
+            onProgress: abrCallbacks.requestProgress,
+            onMetrics: abrCallbacks.metrics });
+        /* eslint-enable @typescript-eslint/unbound-method */
         /**
          * `TaskCanceller` triggered when the current `RepresentationStream` is
          * terminating and as such the next one might be immediately created
          * recursively.
          */
         var repStreamTerminatingCanceller = new TaskCanceller();
-        repStreamTerminatingCanceller.linkToSignal(adapStreamCanceller.signal);
-        var _a = estimateRef.getValue(), representation = _a.representation, manual = _a.manual;
+        repStreamTerminatingCanceller.linkToSignal(fnCancelSignal);
+        var representation = estimateRef.getValue().representation;
         if (representation === null) {
             return;
         }
-        // A manual bitrate switch might need an immediate feedback.
-        // To do that properly, we need to reload the MediaSource
-        if (directManualBitrateSwitching && manual && !isFirstEstimate) {
-            var DELTA_POSITION_AFTER_RELOAD_1 = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
-            // We begin by scheduling a micro-task to reduce the possibility of race
-            // conditions where the inner logic would be called synchronously before
-            // the next observation (which may reflect very different playback conditions)
-            // is actually received.
-            return nextTick(function () {
-                if (repStreamTerminatingCanceller.isUsed()) {
-                    return;
-                }
-                var newManual = estimateRef.getValue().manual;
-                if (!newManual) {
-                    return;
-                }
-                var timeOffset = DELTA_POSITION_AFTER_RELOAD_1.bitrateSwitch;
-                return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type, period: period, timeOffset: timeOffset, stayInPeriod: true });
-            });
-        }
         /**
-         * Emit when the current RepresentationStream should be terminated to make
-         * place for a new one (e.g. when switching quality).
+         * Stores the last estimate emitted, starting with `null`.
+         * This allows to easily rely on that value in inner Observables which might also
+         * need the last already-considered value.
          */
         var terminateCurrentStream = new SharedReference(null, repStreamTerminatingCanceller.signal);
         /** Allows to stop listening to estimateRef on the following line. */
@@ -167,15 +257,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             }
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
         /**
-         * "Fast-switching" is a behavior allowing to replace low-quality segments
-         * (i.e. with a low bitrate) with higher-quality segments (higher bitrate) in
-         * the buffer.
-         * This threshold defines a bitrate from which "fast-switching" is disabled.
-         * For example with a fastSwitchThreshold set to `100`, segments with a
-         * bitrate of `90` can be replaced. But segments with a bitrate of `100`
-         * onward won't be replaced by higher quality segments.
-         * Set to `undefined` to indicate that there's no threshold (anything can be
-         * replaced by higher-quality segments).
+         * Recursively create `RepresentationStream`s according to the last
+         * Representation estimate.
          */
         var fastSwitchThreshold = new SharedReference(0);
         if (options.enableFastSwitching) {
@@ -215,26 +298,33 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     return; // Already handled
                 }
                 repStreamTerminatingCanceller.cancel();
-                return recursivelyCreateRepresentationStreams(false);
+                return recursivelyCreateRepresentationStreams(estimateRef, abrCallbacks, fnCancelSignal);
             },
         };
-        createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
+        createRepresentationStream(representation, segmentFetcher, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks, fnCancelSignal);
     }
     /**
      * Create and returns a new `RepresentationStream`, linked to the
      * given Representation.
-     * @param {Object} representation
-     * @param {Object} terminateCurrentStream
-     * @param {Object} fastSwitchThreshold
-     * @param {Object} representationStreamCallbacks
+     * @param {Object} representation - The Representation the
+     * `RepresentationStream` has to be created for.
+     * @param {Object} segmentFetcher - Allows to easily fetch segments.
+     * @param {Object} terminateCurrentStream - Gives termination orders,
+     * indicating that the `RepresentationStream` should stop what it's doing.
+     * @param {Object} fastSwitchThreshold - Used to determine when
+     * "fast-switching" is possible.
+     * @param {Object} representationStreamCallbacks - Callbacks to call on
+     * various `RepresentationStream` events.
+     * @param {Object} fnCancelSignal - `CancellationSignal` which will abort
+     * anything this function is doing and free allocated resources.
      */
-    function createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks) {
+    function createRepresentationStream(representation, segmentFetcher, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks, fnCancelSignal) {
         /**
          * `TaskCanceller` triggered when the `RepresentationStream` calls its
          * `terminating` callback.
          */
         var terminatingRepStreamCanceller = new TaskCanceller();
-        terminatingRepStreamCanceller.linkToSignal(adapStreamCanceller.signal);
+        terminatingRepStreamCanceller.linkToSignal(fnCancelSignal);
         var bufferGoal = createMappedReference(wantedBufferAhead, function (prev) {
             return prev * getBufferGoalRatio(representation);
         }, terminatingRepStreamCanceller.signal);
@@ -264,7 +354,7 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     // We wait 4 seconds to let the situation evolve by itself before
                     // retrying loading segments with a lower buffer goal
                     cancellableSleep(4000, adapStreamCanceller.signal).then(function () {
-                        return createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
+                        return createRepresentationStream(representation, segmentFetcher, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks, fnCancelSignal);
                     }).catch(noop);
                 }
             },
@@ -274,7 +364,7 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             },
         });
         RepresentationStream({ playbackObserver: playbackObserver, content: { representation: representation, adaptation: adaptation, period: period, manifest: manifest }, segmentBuffer: segmentBuffer, segmentFetcher: segmentFetcher, terminate: terminateCurrentStream,
-            options: { bufferGoal: bufferGoal, maxBufferSize: maxBufferSize, drmSystemId: options.drmSystemId, fastSwitchThreshold: fastSwitchThreshold } }, updatedCallbacks, adapStreamCanceller.signal);
+            options: { bufferGoal: bufferGoal, maxBufferSize: maxBufferSize, drmSystemId: options.drmSystemId, fastSwitchThreshold: fastSwitchThreshold } }, updatedCallbacks, fnCancelSignal);
     }
     /**
      * @param {Object} representation

package/dist/_esm5.processed/core/stream/adaptation/get_representations_switch_strategy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { Adaptation, Period } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
+import { SegmentBuffer } from "../../segment_buffers";
+import { IRepresentationsChoice } from "../representation";
+export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<unknown>): IRepresentationSwitchStrategy;
+export type IRepresentationSwitchStrategy = {
+    type: "continue";
+    value: undefined;
+} | {
+    type: "clean-buffer";
+    value: Array<{
+        start: number;
+        end: number;
+    }>;
+} | {
+    type: "flush-buffer";
+    value: Array<{
+        start: number;
+        end: number;
+    }>;
+} | {
+    type: "needs-reload";
+    value: undefined;
+};

package/dist/_esm5.processed/core/stream/adaptation/get_representations_switch_strategy.js

@@ -0,0 +1,133 @@
+/**
+ * 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 config from "../../../config";
+import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../utils/ranges";
+import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../segment_buffers";
+export default function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentBuffer, playbackObserver) {
+    if (settings.switchingMode === "lazy") {
+        return { type: "continue", value: undefined };
+    }
+    var buffered = segmentBuffer.getBufferedRanges();
+    if (buffered.length === 0) {
+        return { type: "continue", value: undefined };
+    }
+    var bufferedRanges = convertToRanges(buffered);
+    var start = period.start;
+    var end = period.end == null ? Infinity :
+        period.end;
+    var intersection = keepRangeIntersection(bufferedRanges, [{ start: start, end: end }]);
+    if (intersection.length === 0) {
+        return { type: "continue", value: undefined };
+    }
+    segmentBuffer.synchronizeInventory();
+    var inventory = segmentBuffer.getInventory();
+    /** Data already in the right Adaptation */
+    var rangesWithReps = getBufferedRangesFromRepresentations(inventory, period, adaptation, settings.representations);
+    /**
+     * Data different from the wanted Adaptation in the Period's range.
+     * /!\ Could contain some data at the end of the previous Period or at the
+     * beginning of the next one.
+     */
+    var unwantedRange = excludeFromRanges(intersection, rangesWithReps);
+    if (unwantedRange.length === 0) {
+        return { type: "continue", value: undefined };
+    }
+    var currentTime = playbackObserver.getCurrentTime();
+    var readyState = playbackObserver.getReadyState();
+    if (settings.switchingMode === "reload" &&
+        // We're playing the current Period
+        isTimeInRange({ start: start, end: end }, currentTime) &&
+        // There is data for the current position
+        readyState > 1 &&
+        // We're not playing the current wanted video Adaptation
+        !isTimeInRanges(rangesWithReps, currentTime)) {
+        return { type: "needs-reload", value: undefined };
+    }
+    // From here, clean-up data from the previous Adaptation, if one
+    var shouldFlush = settings.switchingMode === "direct";
+    var rangesToExclude = [];
+    // First, we don't want to accidentally remove some segments from the previous
+    // Period (which overlap a little with this one)
+    /** Last segment before one for the current period. */
+    var lastSegmentBefore = getLastSegmentBeforePeriod(inventory, period);
+    if (lastSegmentBefore !== null &&
+        (lastSegmentBefore.bufferedEnd === undefined ||
+            period.start - lastSegmentBefore.bufferedEnd < 1)) // Close to Period's start
+     {
+        // Exclude data close to the period's start to avoid cleaning
+        // to much
+        rangesToExclude.push({ start: 0,
+            end: period.start + 1 });
+    }
+    if (!shouldFlush) {
+        // exclude data around current position to avoid decoding issues
+        var ADAP_REP_SWITCH_BUFFER_PADDINGS = config.getCurrent().ADAP_REP_SWITCH_BUFFER_PADDINGS;
+        var bufferType = adaptation.type;
+        /** Ranges that won't be cleaned from the current buffer. */
+        var paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
+        if (paddingBefore == null) {
+            paddingBefore = 0;
+        }
+        var paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
+        if (paddingAfter == null) {
+            paddingAfter = 0;
+        }
+        rangesToExclude.push({ start: currentTime - paddingBefore,
+            end: currentTime + paddingAfter });
+    }
+    // Now remove possible small range from the end if there is a segment from the
+    // next Period
+    if (period.end !== undefined) {
+        /** first segment after for the current period. */
+        var firstSegmentAfter = getFirstSegmentAfterPeriod(inventory, period);
+        if (firstSegmentAfter !== null &&
+            (firstSegmentAfter.bufferedStart === undefined ||
+                // Close to Period's end
+                (firstSegmentAfter.bufferedStart - period.end) < 1)) {
+            rangesToExclude.push({ start: period.end - 1,
+                end: Number.MAX_VALUE });
+        }
+    }
+    var toRemove = excludeFromRanges(unwantedRange, rangesToExclude);
+    if (toRemove.length === 0) {
+        return { type: "continue", value: undefined };
+    }
+    return shouldFlush ? { type: "flush-buffer", value: toRemove } :
+        { type: "clean-buffer", value: toRemove };
+}
+/**
+ * Returns buffered ranges of what we know correspond to the given `adaptation`
+ * in the SegmentBuffer.
+ * @param {Array.<Object>} inventory
+ * @param {Object} period
+ * @param {Object} adaptation
+ * @returns {Array.<Object>}
+ */
+function getBufferedRangesFromRepresentations(inventory, period, adaptation, representations) {
+    return inventory.reduce(function (acc, chunk) {
+        if (chunk.infos.period.id !== period.id ||
+            chunk.infos.adaptation.id !== adaptation.id ||
+            !representations.some(function (rep) { return rep.id === chunk.infos.representation.id; })) {
+            return acc;
+        }
+        var bufferedStart = chunk.bufferedStart, bufferedEnd = chunk.bufferedEnd;
+        if (bufferedStart === undefined || bufferedEnd === undefined) {
+            return acc;
+        }
+        acc.push({ start: bufferedStart, end: bufferedEnd });
+        return acc;
+    }, []);
+}

package/dist/_esm5.processed/core/stream/adaptation/types.d.ts

@@ -1,14 +1,15 @@
 import Manifest, { Adaptation, Period, Representation } from "../../../manifest";
+import { IAudioTrackSwitchingMode, IVideoTrackSwitchingMode } from "../../../public_types";
 import { IReadOnlySharedReference } from "../../../utils/reference";
 import { IRepresentationEstimator } from "../../adaptive";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import { IBufferType, SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
+import { IRepresentationsChoice, IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IAdaptationStreamCallbacks<T> extends Omit<IRepresentationStreamCallbacks<T>, "terminating"> {
     /** Called as new bitrate estimates are done. */
-    bitrateEstimationChange(payload: IBitrateEstimationChangePayload): void;
+    bitrateEstimateChange(payload: IBitrateEstimateChangePayload): void;
     /**
      * Called when a new `RepresentationStream` is created to load segments from a
      * `Representation`.
@@ -19,9 +20,17 @@ export interface IAdaptationStreamCallbacks<T> extends Omit<IRepresentationStrea
      * needs the `MediaSource` to be reloaded first.
      */
     waitingMediaSourceReload(payload: IWaitingMediaSourceReloadPayload): void;
+    /**
+     * Some situations might require the browser's buffers to be refreshed.
+     * This callback is called when such situation arised.
+     *
+     * Generally flushing/refreshing low-level buffers can be performed simply by
+     * performing a very small seek.
+     */
+    needsBufferFlush(): void;
 }
-/** Payload for the `bitrateEstimationChange` callback. */
-export interface IBitrateEstimationChangePayload {
+/** Payload for the `bitrateEstimateChange` callback. */
+export interface IBitrateEstimateChangePayload {
     /** The type of buffer for which the estimation is done. */
     type: IBufferType;
     /**
@@ -113,6 +122,7 @@ export interface IAdaptationStreamArguments {
         manifest: Manifest;
         period: Period;
         adaptation: Adaptation;
+        representations: IReadOnlySharedReference<IRepresentationsChoice>;
     };
     options: IAdaptationStreamOptions;
     /** Estimate the right Representation to play. */
@@ -152,15 +162,6 @@ export interface IAdaptationStreamOptions {
      *   - We don't know which DRM system is currently used.
      */
     drmSystemId: string | undefined;
-    /**
-     * Strategy taken when the user switch manually the current Representation:
-     *   - "seamless": the switch will happen smoothly, with the Representation
-     *     with the new bitrate progressively being pushed alongside the old
-     *     Representation.
-     *   - "direct": hard switch. The Representation switch will be directly
-     *     visible but may necessitate the current MediaSource to be reloaded.
-     */
-    manualBitrateSwitchingMode: "seamless" | "direct";
     /**
      * If `true`, the AdaptationStream might replace segments of a lower-quality
      * (with a lower bitrate) with segments of a higher quality (with a higher
@@ -176,3 +177,16 @@ export interface IAdaptationStreamOptions {
      */
     enableFastSwitching: boolean;
 }
+/** Object indicating a choice of Adaptation made by the user. */
+export interface IAdaptationChoice {
+    /** The Adaptation choosen. */
+    adaptation: Adaptation;
+    /** "Switching mode" in which the track switch should happen. */
+    switchingMode: ITrackSwitchingMode;
+    /**
+     * Shared reference allowing to indicate which Representations from
+     * that Adaptation are allowed.
+     */
+    representations: IReadOnlySharedReference<IRepresentationsChoice>;
+}
+export type ITrackSwitchingMode = IAudioTrackSwitchingMode | IVideoTrackSwitchingMode;

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

@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 import StreamOrchestrator, { INeedsMediaSourceReloadPayload, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, IStreamOrchestratorCallbacks } from "./orchestrator";
-export { IAudioTrackSwitchingMode } from "./period";
-export { IInbandEvent, IStreamStatusPayload, } from "./representation";
-export { IWaitingMediaSourceReloadPayload, } from "./adaptation";
+export { IRepresentationsChoice, IInbandEvent, IStreamStatusPayload, } from "./representation";
+export { IAdaptationChoice, ITrackSwitchingMode, IWaitingMediaSourceReloadPayload, } from "./adaptation";
 export default StreamOrchestrator;
 export { INeedsMediaSourceReloadPayload, IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, IStreamOrchestratorCallbacks, };

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.d.ts

@@ -134,6 +134,8 @@ export interface IPeriodStreamClearedPayload {
      * about which `PeriodStream` has been removed.
      */
     type: IBufferType;
+    /** The `Manifest` linked to the `PeriodStream` we just cleared. */
+    manifest: Manifest;
     /**
      * The `Period` linked to the `PeriodStream` we just removed.
      *