rx-player 3.27.0-dev.20220317 → 3.27.0-dev.2022032800

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.js

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -49,10 +60,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import PPromise from "pinkie";
-import { closeSession, } from "../../../compat";
-import { onKeyMessage$, onKeyStatusesChange$, } from "../../../compat/event_listeners";
-import config from "../../../config";
+import { closeSession, generateKeyRequest, loadSession, } from "../../../compat";
 import log from "../../../log";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import KeySessionRecord from "./key_session_record";
@@ -76,7 +84,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     }
     /**
      * Create a new MediaKeySession and store it in this store.
-     * @param {Object} initializationData
+     * @param {Object} initData
      * @param {string} sessionType
      * @returns {Object}
      */
@@ -84,7 +92,9 @@ var LoadedSessionsStore = /** @class */ (function () {
         var _this = this;
         var keySessionRecord = new KeySessionRecord(initData);
         var mediaKeySession = this._mediaKeys.createSession(sessionType);
-        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord };
+        var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord, isGeneratingRequest: false,
+            isLoadingPersistentSession: false,
+            closingStatus: { type: "none" } };
         if (!isNullOrUndefined(mediaKeySession.closed)) {
             mediaKeySession.closed
                 .then(function () {
@@ -100,7 +110,7 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         }
         log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
-        this._storage.push({ keySessionRecord: keySessionRecord, mediaKeySession: mediaKeySession, sessionType: sessionType });
+        this._storage.push(__assign({}, entry));
         return entry;
     };
     /**
@@ -121,23 +131,41 @@ var LoadedSessionsStore = /** @class */ (function () {
             if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
                 this._storage.splice(i, 1);
                 this._storage.push(stored);
-                return { keySessionRecord: stored.keySessionRecord,
-                    mediaKeySession: stored.mediaKeySession,
-                    sessionType: stored.sessionType };
+                return __assign({}, stored);
             }
         }
         return null;
     };
     /**
-     * Close a MediaKeySession and remove its related stored information from the
+     * Get `LoadedSessionsStore`'s entry for a given MediaKeySession.
+     * Returns `null` if the given MediaKeySession is not stored in the
      * `LoadedSessionsStore`.
-     * Emit when done.
+     * @param {MediaKeySession} mediaKeySession
+     * @returns {Object|null}
+     */
+    LoadedSessionsStore.prototype.getEntryForSession = function (mediaKeySession) {
+        for (var i = this._storage.length - 1; i >= 0; i--) {
+            var stored = this._storage[i];
+            if (stored.mediaKeySession === mediaKeySession) {
+                return __assign({}, stored);
+            }
+        }
+        return null;
+    };
+    /**
+     * Generate a license request on the given MediaKeySession, while indicating
+     * to the LoadedSessionsStore that a license-request is pending so
+     * session-closing orders are properly scheduled after it is done.
      * @param {Object} mediaKeySession
+     * @param {string} initializationDataType - Initialization data type given
+     * e.g. by the "encrypted" event for the corresponding request.
+     * @param {Uint8Array} initializationData - Initialization data given e.g. by
+     * the "encrypted" event for the corresponding request.
      * @returns {Promise}
      */
-    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+    LoadedSessionsStore.prototype.generateLicenseRequest = function (mediaKeySession, initializationDataType, initializationData) {
         return __awaiter(this, void 0, void 0, function () {
-            var entry, _i, _a, stored;
+            var entry, _i, _a, stored, err_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -149,18 +177,132 @@ var LoadedSessionsStore = /** @class */ (function () {
                             }
                         }
                         if (entry === undefined) {
-                            log.warn("DRM-LSS: No MediaKeySession found with " +
+                            log.error("DRM-LSS: generateRequest error. No MediaKeySession found with " +
                                 "the given initData and initDataType");
-                            return [2 /*return*/, PPromise.resolve(false)];
+                            return [2 /*return*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
                         }
-                        return [4 /*yield*/, safelyCloseMediaKeySession(entry.mediaKeySession)];
+                        entry.isGeneratingRequest = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
                     case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, generateKeyRequest(mediaKeySession, initializationDataType, initializationData)];
+                    case 2:
                         _b.sent();
-                        return [2 /*return*/, PPromise.resolve(true)];
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_1;
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_1;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        entry.isGeneratingRequest = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/];
                 }
             });
         });
     };
+    /**
+     * @param {Object} mediaKeySession
+     * @param {string} sessionId
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.loadPersistentSession = function (mediaKeySession, sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored, ret, err_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                            stored = _a[_i];
+                            if (stored.mediaKeySession === mediaKeySession) {
+                                entry = stored;
+                                break;
+                            }
+                        }
+                        if (entry === undefined) {
+                            log.error("DRM-LSS: loadPersistentSession error. No MediaKeySession found with " +
+                                "the given initData and initDataType");
+                            return [2 /*return*/, loadSession(mediaKeySession, sessionId)];
+                        }
+                        entry.isLoadingPersistentSession = true;
+                        // Note the `as string` is needed due to TypeScript not understanding that
+                        // the `closingStatus` might change in the next checks
+                        if (entry.closingStatus.type !== "none") {
+                            throw new Error("The `MediaKeySession` is being closed.");
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, loadSession(mediaKeySession, sessionId)];
+                    case 2:
+                        ret = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _b.sent();
+                        if (entry === undefined) {
+                            throw err_2;
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        throw err_2;
+                    case 4:
+                        if (entry === undefined) {
+                            return [2 /*return*/, ret];
+                        }
+                        entry.isLoadingPersistentSession = false;
+                        if (entry.closingStatus.type === "awaiting") {
+                            entry.closingStatus.start();
+                        }
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    };
+    /**
+     * Close a MediaKeySession and remove its related stored information from the
+     * `LoadedSessionsStore`.
+     * Emit when done.
+     * @param {Object} mediaKeySession
+     * @returns {Promise}
+     */
+    LoadedSessionsStore.prototype.closeSession = function (mediaKeySession) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, _i, _a, stored;
+            return __generator(this, function (_b) {
+                for (_i = 0, _a = this._storage; _i < _a.length; _i++) {
+                    stored = _a[_i];
+                    if (stored.mediaKeySession === mediaKeySession) {
+                        entry = stored;
+                        break;
+                    }
+                }
+                if (entry === undefined) {
+                    log.warn("DRM-LSS: No MediaKeySession found with " +
+                        "the given initData and initDataType");
+                    return [2 /*return*/, Promise.resolve(false)];
+                }
+                return [2 /*return*/, this._closeEntry(entry)];
+            });
+        });
+    };
     /**
      * Returns the number of stored MediaKeySessions in this LoadedSessionsStore.
      * @returns {number}
@@ -184,6 +326,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     LoadedSessionsStore.prototype.closeAllSessions = function () {
         return __awaiter(this, void 0, void 0, function () {
             var allEntries, closingProms;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -194,8 +337,8 @@ var LoadedSessionsStore = /** @class */ (function () {
                         // process of removing
                         this._storage = [];
                         closingProms = allEntries
-                            .map(function (entry) { return safelyCloseMediaKeySession(entry.mediaKeySession); });
-                        return [4 /*yield*/, PPromise.all(closingProms)];
+                            .map(function (entry) { return _this._closeEntry(entry); });
+                        return [4 /*yield*/, Promise.all(closingProms)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -203,6 +346,13 @@ var LoadedSessionsStore = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Get the index of a stored MediaKeySession entry based on its
+     * `KeySessionRecord`.
+     * Returns -1 if not found.
+     * @param {Object} record
+     * @returns {number}
+     */
     LoadedSessionsStore.prototype.getIndex = function (record) {
         for (var i = 0; i < this._storage.length; i++) {
             var stored = this._storage[i];
@@ -212,92 +362,82 @@ var LoadedSessionsStore = /** @class */ (function () {
         }
         return -1;
     };
+    /**
+     * Prepare the closure of a `MediaKeySession` stored as an entry of the
+     * `LoadedSessionsStore`.
+     * Allows to postpone the closure action if another MediaKeySession action
+     * is already pending.
+     * @param {Object} entry
+     * @returns {Promise.<boolean>}
+     */
+    LoadedSessionsStore.prototype._closeEntry = function (entry) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mediaKeySession;
+            return __generator(this, function (_a) {
+                mediaKeySession = entry.mediaKeySession;
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (entry !== undefined &&
+                            (entry.isLoadingPersistentSession || entry.isGeneratingRequest)) {
+                            entry.closingStatus = { type: "awaiting",
+                                start: tryClosingEntryAndResolve };
+                        }
+                        else {
+                            tryClosingEntryAndResolve();
+                        }
+                        function tryClosingEntryAndResolve() {
+                            if (entry !== undefined) {
+                                entry.closingStatus = { type: "pending" };
+                            }
+                            safelyCloseMediaKeySession(mediaKeySession)
+                                .then(function () {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "done" };
+                                }
+                                resolve(true);
+                            })
+                                .catch(function (err) {
+                                if (entry !== undefined) {
+                                    entry.closingStatus = { type: "failed" };
+                                }
+                                reject(err);
+                            });
+                        }
+                    })];
+            });
+        });
+    };
     return LoadedSessionsStore;
 }());
 export default LoadedSessionsStore;
 /**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
+ * Close a MediaKeySession and just log an error if it fails (while resolving).
  * Emits then complete when done.
  * @param {MediaKeySession} mediaKeySession
  * @returns {Observable}
  */
 function safelyCloseMediaKeySession(mediaKeySession) {
-    return recursivelyTryToCloseMediaKeySession(0);
-    /**
-     * Perform a new attempt at closing the MediaKeySession.
-     * If this operation fails due to a not-"callable" (an EME term)
-     * MediaKeySession, retry based on either a timer or on MediaKeySession
-     * events, whichever comes first.
-     * Emits then complete when done.
-     * @param {number} retryNb - The attempt number starting at 0.
-     * @returns {Observable}
-     */
-    function recursivelyTryToCloseMediaKeySession(retryNb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var err_1, _a, EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY, nextRetryNb, delay_1, ksChangeSub_1, ksChangeProm, ksMsgSub_1, ksMsgProm, sleepTimer_1, sleepProm;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 5]);
-                        return [4 /*yield*/, closeSession(mediaKeySession)];
-                    case 2:
-                        _b.sent();
-                        log.debug("DRM: Succeeded to close MediaKeySession");
-                        return [2 /*return*/, undefined];
-                    case 3:
-                        err_1 = _b.sent();
-                        // Unitialized MediaKeySession may not close properly until their
-                        // corresponding `generateRequest` or `load` call are handled by the
-                        // browser.
-                        // In that case the EME specification tells us that the browser is
-                        // supposed to reject the `close` call with an InvalidStateError.
-                        if (!(err_1 instanceof Error) || err_1.name !== "InvalidStateError" ||
-                            mediaKeySession.sessionId !== "") {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        _a = config.getCurrent(), EME_SESSION_CLOSING_MAX_RETRY = _a.EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY = _a.EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY = _a.EME_SESSION_CLOSING_MAX_DELAY;
-                        nextRetryNb = retryNb + 1;
-                        if (nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY) {
-                            return [2 /*return*/, failToCloseSession(err_1)];
-                        }
-                        delay_1 = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY);
-                        log.warn("DRM: attempt to close a mediaKeySession failed, " +
-                            "scheduling retry...", delay_1);
-                        ksChangeProm = new Promise(function (res) {
-                            ksChangeSub_1 = onKeyStatusesChange$(mediaKeySession).subscribe(res);
-                        });
-                        ksMsgProm = new Promise(function (res) {
-                            ksMsgSub_1 = onKeyMessage$(mediaKeySession).subscribe(res);
-                        });
-                        sleepProm = new Promise(function (res) {
-                            sleepTimer_1 = window.setTimeout(res, delay_1);
-                        });
-                        return [4 /*yield*/, PPromise.race([ksChangeProm, ksMsgProm, sleepProm])];
-                    case 4:
-                        _b.sent();
-                        ksChangeSub_1 === null || ksChangeSub_1 === void 0 ? void 0 : ksChangeSub_1.unsubscribe();
-                        ksMsgSub_1 === null || ksMsgSub_1 === void 0 ? void 0 : ksMsgSub_1.unsubscribe();
-                        clearTimeout(sleepTimer_1);
-                        return [2 /*return*/, recursivelyTryToCloseMediaKeySession(nextRetryNb)];
-                    case 5: return [2 /*return*/];
-                }
-            });
+    return __awaiter(this, void 0, void 0, function () {
+        var err_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, closeSession(mediaKeySession)];
+                case 2:
+                    _a.sent();
+                    log.debug("DRM: Succeeded to close MediaKeySession");
+                    return [2 /*return*/];
+                case 3:
+                    err_3 = _a.sent();
+                    log.error("DRM: Could not close MediaKeySession: " +
+                        (err_3 instanceof Error ? err_3.toString() :
+                            "Unknown error"));
+                    return [2 /*return*/];
+                case 4: return [2 /*return*/];
+            }
         });
-    }
-    /**
-     * Log error anouncing that we could not close the MediaKeySession and emits
-     * then complete through Observable.
-     * TODO Emit warning?
-     * @returns {Observable}
-     */
-    function failToCloseSession(err) {
-        log.error("DRM: Could not close MediaKeySession: " +
-            (err instanceof Error ? err.toString() :
-                "Unknown error"));
-        return PPromise.resolve(null);
-    }
+    });
 }

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.js

@@ -54,7 +54,6 @@ import config from "../../../config";
 import { formatError, } from "../../../errors";
 import log from "../../../log";
 import assert from "../../../utils/assert";
-import PPromise from "../../../utils/promise";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
@@ -337,6 +336,5 @@ export default ManifestFetcher;
  * @returns {boolean}
  */
 function isPromise(val) {
-    return val instanceof PPromise ||
-        val instanceof Promise;
+    return val instanceof Promise;
 }

package/dist/_esm5.processed/core/fetchers/utils/try_urls_with_backoff.js

@@ -54,7 +54,6 @@ import { CustomLoaderError, isKnownError, NetworkErrorTypes, RequestError, } fro
 import log from "../../../log";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
-import PPromise from "../../../utils/promise";
 import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Called on a loader error.
@@ -159,7 +158,7 @@ function getRequestErrorType(error) {
  */
 export function tryURLsWithBackoff(urls, performRequest, options, cancellationSignal) {
     if (cancellationSignal.isCancelled) {
-        return PPromise.reject(cancellationSignal.cancellationError);
+        return Promise.reject(cancellationSignal.cancellationError);
     }
     var baseDelay = options.baseDelay, maxDelay = options.maxDelay, maxRetryRegular = options.maxRetryRegular, maxRetryOffline = options.maxRetryOffline, onRetry = options.onRetry;
     var retryCount = 0;
@@ -167,7 +166,7 @@ export function tryURLsWithBackoff(urls, performRequest, options, cancellationSi
     var urlsToTry = urls.slice();
     if (urlsToTry.length === 0) {
         log.warn("Fetchers: no URL given to `tryURLsWithBackoff`.");
-        return PPromise.reject(new Error("No URL to request"));
+        return Promise.reject(new Error("No URL to request"));
     }
     return tryURLsRecursively(urlsToTry[0], 0);
     /**

package/dist/_esm5.processed/core/init/initialize_media_source.d.ts

@@ -20,6 +20,7 @@ import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../decrypt";
 import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher, SegmentFetcherCreator } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
+import { IAudioTrackSwitchingMode } from "../stream";
 import { IInitialTimeOptions } from "./get_initial_time";
 import { IInitEvent } from "./types";
 /** Arguments to give to the `InitializeOnMediaSource` function. */
@@ -46,7 +47,7 @@ export interface IInitializeArguments {
          */
         enableFastSwitching: boolean;
         /** Strategy when switching of audio track. */
-        audioTrackSwitchingMode: "seamless" | "direct";
+        audioTrackSwitchingMode: IAudioTrackSwitchingMode;
         /** Behavior when a new video and/or audio codec is encountered. */
         onCodecSwitch: "continue" | "reload";
     };

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./orchestrator";
+export { IAudioTrackSwitchingMode } from "./period";
 export * from "./types";
 export default StreamOrchestrator;
 export { IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, };

package/dist/_esm5.processed/core/stream/period/get_adaptation_switch_strategy.d.ts

@@ -35,20 +35,24 @@ export declare type IAdaptationSwitchStrategy = {
     value: undefined;
 };
 export interface IAdaptationSwitchOptions {
-    /**
-     * Strategy to adopt when manually switching of audio adaptation.
-     * Can be either:
-     *    - "seamless": transitions are smooth but could be not immediate.
-     *    - "direct": strategy will be "smart", if the mimetype and the codec,
-     *    change, we will perform a hard reload of the media source, however, if it
-     *    doesn't change, we will just perform a small flush by removing buffered range
-     *    and performing, a small seek on the media element.
-     *    Transitions are faster, but, we could see appear a reloading or seeking state.
-     */
-    audioTrackSwitchingMode: "seamless" | "direct";
+    /** RxPlayer's behavior when switching the audio track. */
+    audioTrackSwitchingMode: IAudioTrackSwitchingMode;
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch: "continue" | "reload";
 }
+/**
+ * Strategy to adopt when manually switching of audio adaptation.
+ * Can be either:
+ *    - "seamless": transitions are smooth but could be not immediate.
+ *    - "direct": strategy will be "smart", if the mimetype and the codec,
+ *    change, we will perform a hard reload of the media source, however, if it
+ *    doesn't change, we will just perform a small flush by removing buffered range
+ *    and performing, a small seek on the media element.
+ *    Transitions are faster, but, we could see appear a BUFFERING state.
+ *    - "reload": completely reload the content. This allows a direct switch
+ *    compatible with most device but may necessitate a RELOADING phase.
+ */
+export declare type IAudioTrackSwitchingMode = "seamless" | "direct" | "reload";
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.

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

@@ -62,7 +62,10 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         return { type: "continue", value: undefined };
     }
     var currentTime = playbackInfo.currentTime;
-    if (adaptation.type === "video" &&
+    var audioTrackSwitchingMode = options.audioTrackSwitchingMode;
+    var hasReloadSwitchingMode = adaptation.type === "video" ||
+        (adaptation.type === "audio" && audioTrackSwitchingMode === "reload");
+    if (hasReloadSwitchingMode &&
         // We're playing the current Period
         isTimeInRange({ start: start, end: end }, currentTime) &&
         // There is data for the current position or the codecs are differents
@@ -74,7 +77,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     }
     // From here, clean-up data from the previous Adaptation, if one
     var shouldFlush = adaptation.type === "audio" &&
-        options.audioTrackSwitchingMode === "direct";
+        audioTrackSwitchingMode === "direct";
     var rangesToExclude = [];
     // First, we don't want to accidentally remove some segments from the previous
     // Period (which overlap a little with this one)

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

@@ -14,5 +14,6 @@
  * limitations under the License.
  */
 import PeriodStream, { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "./period_stream";
+export { IAudioTrackSwitchingMode } from "./get_adaptation_switch_strategy";
 export default PeriodStream;
 export { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation, };

package/dist/_esm5.processed/core/stream/period/period_stream.d.ts

@@ -23,6 +23,7 @@ import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
 import { IAdaptationStreamOptions } from "../adaptation";
 import { IPeriodStreamEvent } from "../types";
+import { IAudioTrackSwitchingMode } from "./get_adaptation_switch_strategy";
 /** Playback observation required by the `PeriodStream`. */
 export interface IPeriodStreamPlaybackObservation {
     /** The position we are in the video in seconds at the time of the observation. */
@@ -64,17 +65,8 @@ export interface IPeriodStreamArguments {
 }
 /** Options tweaking the behavior of the PeriodStream. */
 export declare type IPeriodStreamOptions = IAdaptationStreamOptions & {
-    /**
-     * Strategy to adopt when manually switching of audio adaptation.
-     * Can be either:
-     *    - "seamless": transitions are smooth but could be not immediate.
-     *    - "direct": strategy will be "smart", if the mimetype and the codec,
-     *    change, we will perform a hard reload of the media source, however, if it
-     *    doesn't change, we will just perform a small flush by removing buffered range
-     *    and performing, a small seek on the media element.
-     *    Transitions are faster, but, we could see appear a reloading or seeking state.
-     */
-    audioTrackSwitchingMode: "seamless" | "direct";
+    /** RxPlayer's behavior when switching the audio track. */
+    audioTrackSwitchingMode: IAudioTrackSwitchingMode;
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch: "continue" | "reload";
     /** Options specific to the text SegmentBuffer. */

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

@@ -16,7 +16,7 @@
 /**
  * This file allows any Stream to push data to a SegmentBuffer.
  */
-import { catchError, concat as observableConcat, mergeMap, ignoreElements, } from "rxjs";
+import { catchError, concat as observableConcat, mergeMap, ignoreElements, take, } from "rxjs";
 import { MediaError } from "../../../errors";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
@@ -38,10 +38,11 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                 "An unknown error happened when pushing content";
             throw new MediaError("BUFFER_APPEND_ERROR", reason);
         }
-        return playbackObserver.observe(true).pipe(mergeMap(function (observation) {
+        return playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
             var currentPos = observation.position + observation.wantedTimeOffset;
             return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
-                var reason = forcedGCError instanceof Error ? forcedGCError.toString() :
+                var reason = forcedGCError instanceof Error ?
+                    forcedGCError.toString() :
                     "Could not clean the buffer";
                 throw new MediaError("BUFFER_FULL_ERROR", reason);
             }));