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

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

@@ -1,17 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const next_tick_1 = require("next-tick");
-const config_1 = require("../../../config");
-const errors_1 = require("../../../errors");
-const log_1 = require("../../../log");
-const assert_unreachable_1 = require("../../../utils/assert_unreachable");
-const cancellable_sleep_1 = require("../../../utils/cancellable_sleep");
-const noop_1 = require("../../../utils/noop");
-const object_assign_1 = require("../../../utils/object_assign");
-const reference_1 = require("../../../utils/reference");
-const task_canceller_1 = require("../../../utils/task_canceller");
-const representation_1 = require("../representation");
-const get_representations_switch_strategy_1 = require("./get_representations_switch_strategy");
+/**
+ * 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 nextTick from "next-tick";
+import config from "../../../config";
+import { formatError } from "../../../errors";
+import log from "../../../log";
+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";
 /**
  * Create new `AdaptationStream` whose task will be to download the media data
  * for a given Adaptation (i.e. "track").
@@ -42,10 +54,12 @@ const get_representations_switch_strategy_1 = require("./get_representations_swi
  * triggered, to immediately stop all operations the `AdaptationStream` is
  * doing.
  */
-function AdaptationStream({ playbackObserver, content, options, representationEstimator, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, maxVideoBufferSize }, callbacks, parentCancelSignal) {
-    const { manifest, period, adaptation } = content;
+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. */
-    const adapStreamCanceller = new task_canceller_1.default();
+    var adapStreamCanceller = new TaskCanceller();
     adapStreamCanceller.linkToSignal(parentCancelSignal);
     /**
      * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
@@ -55,20 +69,18 @@ function AdaptationStream({ playbackObserver, content, options, representationEs
      * buffering and tells us that we should try to bufferize less data :
      * https://developers.google.com/web/updates/2017/10/quotaexceedederror
      */
-    const bufferGoalRatioMap = new Map();
+    var bufferGoalRatioMap = new Map();
     /**
      * Emit the currently chosen `Representation`.
      * `null` if no Representation is chosen for now.
      */
-    const currentRepresentation = new reference_1.default(null, adapStreamCanceller.signal);
-    /** Stores the last emitted bitrate. */
-    let previouslyEmittedBitrate;
-    /** Emit the list of Representation for the adaptive logic. */
-    const representationsList = new reference_1.default(content.representations.getValue().representations, adapStreamCanceller.signal);
-    // Start-up Adaptive logic
-    const { estimates: estimateRef, callbacks: abrCallbacks } = representationEstimator({ manifest, period, adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal);
-    /** Allows a `RepresentationStream` to easily fetch media segments. */
-    const segmentFetcher = segmentFetcherCreator
+    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,
@@ -76,140 +88,102 @@ function AdaptationStream({ playbackObserver, content, options, representationEs
         onProgress: abrCallbacks.requestProgress,
         onMetrics: abrCallbacks.metrics });
     /* eslint-enable @typescript-eslint/unbound-method */
-    /** Used to determine when "fast-switching" is possible. */
-    const fastSwitchThreshold = new reference_1.default(0);
-    estimateRef.onUpdate(({ bitrate, knownStableBitrate }) => {
-        if (options.enableFastSwitching) {
-            fastSwitchThreshold.setValueIfChanged(knownStableBitrate);
+    /** 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 === undefined || bitrate === previouslyEmittedBitrate) {
+        if (bitrate === previousBitrate) {
             return;
         }
-        previouslyEmittedBitrate = bitrate;
-        log_1.default.debug(`Stream: new ${adaptation.type} bitrate estimate`, bitrate);
-        callbacks.bitrateEstimateChange({ type: adaptation.type, bitrate });
+        previousBitrate = bitrate;
+        log.debug("Stream: new ".concat(adaptation.type, " bitrate estimate"), bitrate);
+        callbacks.bitrateEstimationChange({ type: adaptation.type, bitrate: bitrate });
     }, { emitCurrentValue: true, clearSignal: adapStreamCanceller.signal });
-    /**
-     * When triggered, cancel all `RepresentationStream`s currently created.
-     * Set to `undefined` initially.
-     */
-    let cancelCurrentStreams;
-    // Each time the list of wanted Representations changes, we restart the logic
-    content.representations.onUpdate((val) => {
-        if (cancelCurrentStreams !== undefined) {
-            cancelCurrentStreams.cancel();
-        }
-        representationsList.setValueIfChanged(val.representations);
-        cancelCurrentStreams = new task_canceller_1.default();
-        cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
-        onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch((err) => {
-            if ((cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.isUsed()) === true &&
-                task_canceller_1.default.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.
-     */
-    async function onRepresentationsChoiceChange(choice, fnCancelSignal) {
-        // First check if we should perform any action regarding what was previously
-        // in the buffer
-        const switchStrat = (0, get_representations_switch_strategy_1.default)(period, adaptation, choice, segmentBuffer, playbackObserver);
-        switch (switchStrat.type) {
-            case "continue":
-                break; // nothing to do
-            case "needs-reload": // 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 (0, next_tick_1.default)(() => {
-                    playbackObserver.listen(() => {
-                        if (fnCancelSignal.isCancelled()) {
-                            return;
-                        }
-                        const { DELTA_POSITION_AFTER_RELOAD } = config_1.default.getCurrent();
-                        const timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
-                        return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type,
-                            period,
-                            timeOffset,
-                            stayInPeriod: true });
-                    }, { includeLastObservation: true, clearSignal: fnCancelSignal });
-                });
-            case "flush-buffer": // Clean + flush
-            case "clean-buffer": // Just clean
-                for (const range of switchStrat.value) {
-                    await segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal);
-                    if (fnCancelSignal.isCancelled()) {
-                        return;
-                    }
-                }
-                if (switchStrat.type === "flush-buffer") {
-                    callbacks.needsBufferFlush();
-                    if (fnCancelSignal.isCancelled()) {
-                        return;
-                    }
-                }
-                break;
-            default: // Should be impossible
-                (0, assert_unreachable_1.default)(switchStrat);
-        }
-        recursivelyCreateRepresentationStreams(fnCancelSignal);
-    }
+    recursivelyCreateRepresentationStreams(true);
     /**
      * 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 {Object} fnCancelSignal - `CancellationSignal` which will abort
-     * anything this function is doing and free allocated resources.
+     * @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.
      */
-    function recursivelyCreateRepresentationStreams(fnCancelSignal) {
+    function recursivelyCreateRepresentationStreams(isFirstEstimate) {
         /**
          * `TaskCanceller` triggered when the current `RepresentationStream` is
          * terminating and as such the next one might be immediately created
          * recursively.
          */
-        const repStreamTerminatingCanceller = new task_canceller_1.default();
-        repStreamTerminatingCanceller.linkToSignal(fnCancelSignal);
-        const { representation } = estimateRef.getValue();
+        var repStreamTerminatingCanceller = new TaskCanceller();
+        repStreamTerminatingCanceller.linkToSignal(adapStreamCanceller.signal);
+        var _a = estimateRef.getValue(), representation = _a.representation, manual = _a.manual;
         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 });
+            });
+        }
         /**
-         * 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.
+         * Emit when the current RepresentationStream should be terminated to make
+         * place for a new one (e.g. when switching quality).
          */
-        const terminateCurrentStream = new reference_1.default(null, repStreamTerminatingCanceller.signal);
+        var terminateCurrentStream = new SharedReference(null, repStreamTerminatingCanceller.signal);
         /** Allows to stop listening to estimateRef on the following line. */
-        estimateRef.onUpdate((estimate) => {
+        estimateRef.onUpdate(function (estimate) {
             if (estimate.representation === null ||
                 estimate.representation.id === representation.id) {
                 return;
             }
             if (estimate.urgent) {
-                log_1.default.info("Stream: urgent Representation switch", adaptation.type);
+                log.info("Stream: urgent Representation switch", adaptation.type);
                 return terminateCurrentStream.setValue({ urgent: true });
             }
             else {
-                log_1.default.info("Stream: slow Representation switch", adaptation.type);
+                log.info("Stream: slow Representation switch", adaptation.type);
                 return terminateCurrentStream.setValue({ urgent: false });
             }
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
-        const repInfo = { type: adaptation.type, period, representation };
+        /**
+         * "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).
+         */
+        var fastSwitchThreshold = new SharedReference(0);
+        if (options.enableFastSwitching) {
+            estimateRef.onUpdate(function (estimate) {
+                fastSwitchThreshold.setValueIfChanged(estimate === null || estimate === void 0 ? void 0 : estimate.knownStableBitrate);
+            }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
+        }
+        var repInfo = { type: adaptation.type, period: period, representation: representation };
         currentRepresentation.setValue(representation);
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
@@ -218,56 +192,60 @@ function AdaptationStream({ playbackObserver, content, options, representationEs
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
-        const representationStreamCallbacks = {
+        var representationStreamCallbacks = {
             streamStatusUpdate: callbacks.streamStatusUpdate,
             encryptionDataEncountered: callbacks.encryptionDataEncountered,
             manifestMightBeOufOfSync: callbacks.manifestMightBeOufOfSync,
             needsManifestRefresh: callbacks.needsManifestRefresh,
             inbandEvent: callbacks.inbandEvent,
             warning: callbacks.warning,
-            error(err) {
+            error: function (err) {
                 adapStreamCanceller.cancel();
                 callbacks.error(err);
             },
-            addedSegment(segmentInfo) {
+            addedSegment: function (segmentInfo) {
                 abrCallbacks.addedSegment(segmentInfo);
+                if (adapStreamCanceller.isUsed()) {
+                    return;
+                }
+                callbacks.addedSegment(segmentInfo);
             },
-            terminating() {
+            terminating: function () {
                 if (repStreamTerminatingCanceller.isUsed()) {
                     return; // Already handled
                 }
                 repStreamTerminatingCanceller.cancel();
-                return recursivelyCreateRepresentationStreams(fnCancelSignal);
+                return recursivelyCreateRepresentationStreams(false);
             },
         };
-        createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
+        createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
     }
     /**
      * Create and returns a new `RepresentationStream`, linked to the
      * given Representation.
-     * @param {Object} representation - The Representation the
-     * `RepresentationStream` has to be created for.
-     * @param {Object} terminateCurrentStream - Gives termination orders,
-     * indicating that the `RepresentationStream` should stop what it's doing.
-     * @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.
+     * @param {Object} representation
+     * @param {Object} terminateCurrentStream
+     * @param {Object} fastSwitchThreshold
+     * @param {Object} representationStreamCallbacks
      */
-    function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal) {
-        const bufferGoalCanceller = new task_canceller_1.default();
-        bufferGoalCanceller.linkToSignal(fnCancelSignal);
-        const bufferGoal = (0, reference_1.createMappedReference)(wantedBufferAhead, prev => {
+    function createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks) {
+        /**
+         * `TaskCanceller` triggered when the `RepresentationStream` calls its
+         * `terminating` callback.
+         */
+        var terminatingRepStreamCanceller = new TaskCanceller();
+        terminatingRepStreamCanceller.linkToSignal(adapStreamCanceller.signal);
+        var bufferGoal = createMappedReference(wantedBufferAhead, function (prev) {
             return prev * getBufferGoalRatio(representation);
-        }, bufferGoalCanceller.signal);
-        const maxBufferSize = adaptation.type === "video" ?
+        }, terminatingRepStreamCanceller.signal);
+        var maxBufferSize = adaptation.type === "video" ?
             maxVideoBufferSize :
-            new reference_1.default(Infinity);
-        log_1.default.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
-        const updatedCallbacks = (0, object_assign_1.default)({}, representationStreamCallbacks, {
-            error(err) {
+            new SharedReference(Infinity);
+        log.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
+        var updatedCallbacks = objectAssign({}, representationStreamCallbacks, {
+            error: function (err) {
                 var _a;
-                const formattedError = (0, errors_1.formatError)(err, {
+                var formattedError = formatError(err, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `RepresentationStream` error",
                 });
@@ -275,73 +253,36 @@ function AdaptationStream({ playbackObserver, content, options, representationEs
                     representationStreamCallbacks.error(err);
                 }
                 else {
-                    const wba = wantedBufferAhead.getValue();
-                    const lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
+                    var wba = wantedBufferAhead.getValue();
+                    var lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
                     // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%
-                    const newBufferGoalRatio = lastBufferGoalRatio * 0.7;
+                    var newBufferGoalRatio = lastBufferGoalRatio * 0.7;
                     if (newBufferGoalRatio <= 0.05 || wba * newBufferGoalRatio <= 2) {
                         throw formattedError;
                     }
                     bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
                     // We wait 4 seconds to let the situation evolve by itself before
                     // retrying loading segments with a lower buffer goal
-                    (0, cancellable_sleep_1.default)(4000, adapStreamCanceller.signal).then(() => {
-                        return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
-                    }).catch(noop_1.default);
+                    cancellableSleep(4000, adapStreamCanceller.signal).then(function () {
+                        return createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
+                    }).catch(noop);
                 }
             },
-            terminating() {
-                bufferGoalCanceller.cancel();
+            terminating: function () {
+                terminatingRepStreamCanceller.cancel();
                 representationStreamCallbacks.terminating();
             },
         });
-        (0, representation_1.default)({ playbackObserver,
-            content: { representation,
-                adaptation,
-                period,
-                manifest },
-            segmentBuffer,
-            segmentFetcher,
-            terminate: terminateCurrentStream,
-            options: { bufferGoal,
-                maxBufferSize,
-                drmSystemId: options.drmSystemId,
-                fastSwitchThreshold } }, updatedCallbacks, fnCancelSignal);
-        // reload if the Representation disappears from the Manifest
-        manifest.addEventListener("manifestUpdate", updates => {
-            for (const element of updates.updatedPeriods) {
-                if (element.period.id === period.id) {
-                    for (const updated of element.result.updatedAdaptations) {
-                        if (updated.adaptation.id === adaptation.id) {
-                            for (const rep of updated.removedRepresentations) {
-                                if (rep.id === representation.id) {
-                                    if (fnCancelSignal.isCancelled()) {
-                                        return;
-                                    }
-                                    return callbacks.waitingMediaSourceReload({
-                                        bufferType: adaptation.type,
-                                        period,
-                                        timeOffset: 0,
-                                        stayInPeriod: true,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-                else if (element.period.start > period.start) {
-                    break;
-                }
-            }
-        }, fnCancelSignal);
+        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);
     }
     /**
      * @param {Object} representation
      * @returns {number}
      */
     function getBufferGoalRatio(representation) {
-        const oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
-        const bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio :
+        var oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
+        var bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio :
             1;
         if (oldBufferGoalRatio === undefined) {
             bufferGoalRatioMap.set(representation.id, bufferGoalRatio);
@@ -349,4 +290,3 @@ function AdaptationStream({ playbackObserver, content, options, representationEs
         return bufferGoalRatio;
     }
 }
-exports.default = AdaptationStream;

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,21 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const adaptation_stream_1 = require("./adaptation_stream");
-__exportStar(require("./types"), exports);
-exports.default = adaptation_stream_1.default;
+import AdaptationStream from "./adaptation_stream";
+export * from "./types";
+export default AdaptationStream;

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

@@ -1,15 +1,14 @@
 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 { IRepresentationsChoice, IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
+import { IRepresentationStreamCallbacks, IRepresentationStreamPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
-export interface IAdaptationStreamCallbacks extends Omit<IRepresentationStreamCallbacks, "terminating" | "addedSegment"> {
+export interface IAdaptationStreamCallbacks<T> extends Omit<IRepresentationStreamCallbacks<T>, "terminating"> {
     /** Called as new bitrate estimates are done. */
-    bitrateEstimateChange(payload: IBitrateEstimateChangePayload): void;
+    bitrateEstimationChange(payload: IBitrateEstimationChangePayload): void;
     /**
      * Called when a new `RepresentationStream` is created to load segments from a
      * `Representation`.
@@ -18,22 +17,11 @@ export interface IAdaptationStreamCallbacks extends Omit<IRepresentationStreamCa
     /**
      * Callback called when a stream cannot go forward loading segments because it
      * needs the `MediaSource` to be reloaded first.
-     *
-     * The MediaSource will only be reloaded once the communicated Period is the
-     * current one.
      */
     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 `bitrateEstimateChange` callback. */
-export interface IBitrateEstimateChangePayload {
+/** Payload for the `bitrateEstimationChange` callback. */
+export interface IBitrateEstimationChangePayload {
     /** The type of buffer for which the estimation is done. */
     type: IBufferType;
     /**
@@ -56,12 +44,7 @@ export interface IRepresentationChangePayload {
 }
 /** Payload for the `waitingMediaSourceReload` callback. */
 export interface IWaitingMediaSourceReloadPayload {
-    /**
-     * Period asking for the reload.
-     *
-     * The MediaSource will only be reloaded if that Period becomes the current
-     * one.
-     */
+    /** Period concerned. */
     period: Period;
     /** Buffer type concerned. */
     bufferType: IBufferType;
@@ -130,7 +113,6 @@ export interface IAdaptationStreamArguments {
         manifest: Manifest;
         period: Period;
         adaptation: Adaptation;
-        representations: IReadOnlySharedReference<IRepresentationsChoice>;
     };
     options: IAdaptationStreamOptions;
     /** Estimate the right Representation to play. */
@@ -170,6 +152,15 @@ 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
@@ -185,16 +176,3 @@ 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/adaptation/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};