rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

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

@@ -0,0 +1,414 @@
+/**
+ * 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 (_) 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 { isOffline } from "../../../compat";
+import { CustomLoaderError, isKnownError, NetworkErrorTypes, RequestError, } from "../../../errors";
+import log from "../../../log";
+import cancellableSleep from "../../../utils/cancellable_sleep";
+import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import noop from "../../../utils/noop";
+import TaskCanceller from "../../../utils/task_canceller";
+/**
+ * Called on a loader error.
+ * Returns whether the loader request should be retried.
+ *
+ * TODO the notion of retrying or not could be transport-specific (e.g. 412 are
+ * mainly used for Smooth contents) and thus as part of the transport code (e.g.
+ * by rejecting with an error always having a `canRetry` property?).
+ * Or not, to ponder.
+ *
+ * @param {Error} error
+ * @returns {Boolean} - If true, the request can be retried.
+ */
+function shouldRetry(error) {
+    if (error instanceof RequestError) {
+        if (error.type === NetworkErrorTypes.ERROR_HTTP_CODE) {
+            return error.status >= 500 ||
+                error.status === 404 ||
+                error.status === 415 || // some CDN seems to use that code when
+                // requesting low-latency segments too much
+                // in advance
+                error.status === 412;
+        }
+        return error.type === NetworkErrorTypes.TIMEOUT ||
+            error.type === NetworkErrorTypes.ERROR_EVENT;
+    }
+    else if (error instanceof CustomLoaderError) {
+        if (typeof error.canRetry === "boolean") {
+            return error.canRetry;
+        }
+        if (error.xhr !== undefined) {
+            return error.xhr.status >= 500 ||
+                error.xhr.status === 404 ||
+                error.xhr.status === 415 || // some CDN seems to use that code when
+                // requesting low-latency segments too much
+                // in advance
+                error.xhr.status === 412;
+        }
+        return false;
+    }
+    return isKnownError(error) && error.code === "INTEGRITY_ERROR";
+}
+/**
+ * Returns true if we're pretty sure that the current error is due to the
+ * user being offline.
+ * @param {Error} error
+ * @returns {Boolean}
+ */
+function isOfflineRequestError(error) {
+    if (error instanceof RequestError) {
+        return error.type === NetworkErrorTypes.ERROR_EVENT &&
+            isOffline();
+    }
+    else if (error instanceof CustomLoaderError) {
+        return error.isOfflineError;
+    }
+    return false; // under doubt, return false
+}
+/**
+ * Guess the type of error obtained.
+ * @param {*} error
+ * @returns {number}
+ */
+function getRequestErrorType(error) {
+    return isOfflineRequestError(error) ? 2 /* REQUEST_ERROR_TYPES.Offline */ :
+        1 /* REQUEST_ERROR_TYPES.Regular */;
+}
+/**
+ * Specific algorithm used to perform segment and manifest requests.
+ *
+ * Here how it works:
+ *
+ *   1. You give it one or multiple of the CDN available for the resource you
+ *      want to request (from the most important one to the least important),
+ *      a callback doing the request with the chosen CDN in argument, and some
+ *      options.
+ *
+ *   2. it tries to call the request callback with the most prioritized CDN
+ *      first:
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error, un-prioritize that CDN and try with the new
+ *          most prioritized CDN.
+ *
+ *      Each CDN might be retried multiple times, depending on the nature of the
+ *      error and the Configuration given.
+ *
+ *      Multiple retries of the same CDN are done after a delay to avoid
+ *      overwhelming it, this is what we call a "backoff". That delay raises
+ *      exponentially as multiple consecutive errors are encountered on this
+ *      CDN.
+ *
+ * @param {Array.<string>|null} cdns - The different CDN on which the
+ * wanted resource is available. `scheduleRequestWithCdns` will call the
+ * `performRequest` callback with the right element from that array if different
+ * from `null`.
+ *
+ * Can be set to `null` when that resource is not reachable through a CDN, in
+ * which case the `performRequest` callback may be called with `null`.
+ * @param {Object|null} cdnPrioritizer - Interface allowing to give the priority
+ * between multiple CDNs.
+ * @param {Function} performRequest - Callback implementing the request in
+ * itself. Resolving when the resource request succeed and rejecting with the
+ * corresponding error when the request failed.
+ * @param {Object} options - Configuration allowing to tweak the number on which
+ * the algorithm behind `scheduleRequestWithCdns` bases itself.
+ * @param {Object} cancellationSignal - CancellationSignal allowing to cancel
+ * the logic of `scheduleRequestWithCdns`.
+ * To trigger if the resource is not needed anymore.
+ * @returns {Promise} - Promise resolving, with the corresponding
+ * `performRequest`'s data, when the resource request succeed and rejecting in
+ * the following scenarios:
+ *   - `scheduleRequestWithCdns` has been cancelled due to `cancellationSignal`
+ *     being triggered. In that case a `CancellationError` is thrown.
+ *
+ *   - The resource request(s) failed and will not be retried anymore.
+ */
+export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, options, cancellationSignal) {
+    return __awaiter(this, void 0, void 0, function () {
+        /**
+         * Returns what is now the most prioritary CDN to request the wanted resource.
+         *
+         * A return value of `null` indicates that the resource can be requested
+         * through another mean than by doing an HTTP request.
+         *
+         * A return value of `undefined` indicates that there's no CDN left to request
+         * the resource.
+         * @returns {Object|null|undefined}
+         */
+        function getCdnToRequest() {
+            if (cdns === null) {
+                var nullAttemptObject = missedAttempts.get(null);
+                if (nullAttemptObject !== undefined && nullAttemptObject.isBlacklisted) {
+                    return undefined;
+                }
+                return null;
+            }
+            else if (cdnPrioritizer === null) {
+                return getPrioritaryRequestableCdnFromSortedList(cdns);
+            }
+            else {
+                var prioritized = cdnPrioritizer.getCdnPreferenceForResource(cdns);
+                return getPrioritaryRequestableCdnFromSortedList(prioritized);
+            }
+        }
+        /**
+         * Perform immediately the request for the given CDN.
+         *
+         * If it fails, forbid the CDN from being used - optionally and in some
+         * conditions, only temporarily, then try the next CDN according to
+         * previously-set delays (with a potential sleep before to respect them).
+         *
+         * Reject if both the request fails and there's no CDN left to use.
+         * @param {string|null} cdn
+         * @returns {Promise}
+         */
+        function requestCdn(cdn) {
+            return __awaiter(this, void 0, void 0, function () {
+                var res, error_1, currentErrorType, missedAttemptsObj, maxRetry, errorCounter, delay, fuzzedDelay;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, performRequest(cdn, cancellationSignal)];
+                        case 1:
+                            res = _a.sent();
+                            return [2 /*return*/, res];
+                        case 2:
+                            error_1 = _a.sent();
+                            if (TaskCanceller.isCancellationError(error_1)) {
+                                throw error_1;
+                            }
+                            if (cdn !== null && cdnPrioritizer !== null) {
+                                // We failed requesting the resource on this CDN.
+                                // Globally give priority to the next CDN through the CdnPrioritizer.
+                                cdnPrioritizer.downgradeCdn(cdn);
+                            }
+                            currentErrorType = getRequestErrorType(error_1);
+                            missedAttemptsObj = missedAttempts.get(cdn);
+                            if (missedAttemptsObj === undefined) {
+                                missedAttemptsObj = { errorCounter: 1,
+                                    lastErrorType: currentErrorType,
+                                    blockedUntil: undefined,
+                                    isBlacklisted: false };
+                                missedAttempts.set(cdn, missedAttemptsObj);
+                            }
+                            else {
+                                if (currentErrorType !== missedAttemptsObj.lastErrorType) {
+                                    missedAttemptsObj.errorCounter = 1;
+                                    missedAttemptsObj.lastErrorType = currentErrorType;
+                                }
+                                else {
+                                    missedAttemptsObj.errorCounter++;
+                                }
+                            }
+                            if (!shouldRetry(error_1)) {
+                                missedAttemptsObj.blockedUntil = undefined;
+                                missedAttemptsObj.isBlacklisted = true;
+                                return [2 /*return*/, retryWithNextCdn(error_1)];
+                            }
+                            maxRetry = currentErrorType === 2 /* REQUEST_ERROR_TYPES.Offline */ ?
+                                maxRetryOffline :
+                                maxRetryRegular;
+                            if (missedAttemptsObj.errorCounter > maxRetry) {
+                                missedAttemptsObj.blockedUntil = undefined;
+                                missedAttemptsObj.isBlacklisted = true;
+                            }
+                            else {
+                                errorCounter = missedAttemptsObj.errorCounter;
+                                delay = Math.min(baseDelay * Math.pow(2, errorCounter - 1), maxDelay);
+                                fuzzedDelay = getFuzzedDelay(delay);
+                                missedAttemptsObj.blockedUntil = performance.now() + fuzzedDelay;
+                            }
+                            return [2 /*return*/, retryWithNextCdn(error_1)];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        /**
+         * After a request error, find the new most prioritary CDN and perform the
+         * request with it, optionally after a delay.
+         *
+         * If there's no CDN left to test, reject the original request error.
+         * @param {*} prevRequestError
+         * @returns {Promise}
+         */
+        function retryWithNextCdn(prevRequestError) {
+            return __awaiter(this, void 0, void 0, function () {
+                var nextCdn;
+                return __generator(this, function (_a) {
+                    nextCdn = getCdnToRequest();
+                    if (cancellationSignal.isCancelled) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    if (nextCdn === undefined) {
+                        throw prevRequestError;
+                    }
+                    onRetry(prevRequestError);
+                    if (cancellationSignal.isCancelled) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    return [2 /*return*/, waitPotentialBackoffAndRequest(nextCdn, prevRequestError)];
+                });
+            });
+        }
+        /**
+         * Request the corresponding CDN after the optional backoff needed before
+         * requesting it.
+         *
+         * If a new CDN become prioritary in the meantime, request it instead, again
+         * awaiting its optional backoff delay if it exists.
+         * @param {string|null} nextWantedCdn
+         * @param {*} prevRequestError
+         * @returns {Promise}
+         */
+        function waitPotentialBackoffAndRequest(nextWantedCdn, prevRequestError) {
+            var nextCdnAttemptObj = missedAttempts.get(nextWantedCdn);
+            if (nextCdnAttemptObj === undefined ||
+                nextCdnAttemptObj.blockedUntil === undefined) {
+                return requestCdn(nextWantedCdn);
+            }
+            var now = performance.now();
+            var blockedFor = nextCdnAttemptObj.blockedUntil - now;
+            if (blockedFor <= 0) {
+                return requestCdn(nextWantedCdn);
+            }
+            var canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            return new Promise(function (res, rej) {
+                /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+                cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", function () {
+                    var updatedPrioritaryCdn = getCdnToRequest();
+                    if (cancellationSignal.isCancelled) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    if (updatedPrioritaryCdn === undefined) {
+                        return rej(prevRequestError);
+                    }
+                    if (updatedPrioritaryCdn !== nextWantedCdn) {
+                        canceller.cancel();
+                        waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
+                            .then(res, rej);
+                    }
+                }, canceller.signal);
+                cancellableSleep(blockedFor, canceller.signal)
+                    .then(function () { return requestCdn(nextWantedCdn).then(res, rej); }, noop);
+            });
+        }
+        /**
+         * Takes in input the list of CDN that can be used to request the resource, in
+         * a general preference order.
+         *
+         * Returns the actual most prioritary Cdn to request, based on the current
+         * attempts already done for that resource.
+         *
+         * Returns `undefined` if there's no Cdn left to request the resource.
+         * @param {Array.<Object>}
+         * @returns {Object|undefined}
+         */
+        function getPrioritaryRequestableCdnFromSortedList(sortedCdns) {
+            var _a;
+            if (missedAttempts.size === 0) {
+                return sortedCdns[0];
+            }
+            var now = performance.now();
+            return (_a = sortedCdns
+                .filter(function (c) { var _a; return ((_a = missedAttempts.get(c)) === null || _a === void 0 ? void 0 : _a.isBlacklisted) !== true; })
+                .reduce(function (acc, x) {
+                var _a;
+                var blockedUntil = (_a = missedAttempts.get(x)) === null || _a === void 0 ? void 0 : _a.blockedUntil;
+                if (blockedUntil !== undefined && blockedUntil <= now) {
+                    blockedUntil = undefined;
+                }
+                if (acc === undefined) {
+                    return [x, blockedUntil];
+                }
+                if (blockedUntil === undefined) {
+                    if (acc[1] === undefined) {
+                        return acc;
+                    }
+                    return [x, undefined];
+                }
+                return acc[1] === undefined ? acc :
+                    blockedUntil < acc[1] ? [x, blockedUntil] :
+                        acc;
+            }, undefined)) === null || _a === void 0 ? void 0 : _a[0];
+        }
+        var baseDelay, maxDelay, maxRetryRegular, maxRetryOffline, onRetry, missedAttempts, initialCdnToRequest;
+        return __generator(this, function (_a) {
+            if (cancellationSignal.cancellationError !== null) {
+                return [2 /*return*/, Promise.reject(cancellationSignal.cancellationError)];
+            }
+            baseDelay = options.baseDelay, maxDelay = options.maxDelay, maxRetryRegular = options.maxRetryRegular, maxRetryOffline = options.maxRetryOffline, onRetry = options.onRetry;
+            if (cdns !== null && cdns.length === 0) {
+                log.warn("Fetchers: no CDN given to `scheduleRequestWithCdns`.");
+            }
+            missedAttempts = new Map();
+            initialCdnToRequest = getCdnToRequest();
+            if (initialCdnToRequest === undefined) {
+                throw new Error("No CDN to request");
+            }
+            return [2 /*return*/, requestCdn(initialCdnToRequest)];
+        });
+    });
+}
+/**
+ * Lightweight version of the request algorithm, this time with only a simple
+ * Promise given.
+ * @param {Function} performRequest
+ * @param {Object} options
+ * @returns {Promise}
+ */
+export function scheduleRequestPromise(performRequest, options, cancellationSignal) {
+    // same than for a single unknown CDN
+    return scheduleRequestWithCdns(null, null, performRequest, options, cancellationSignal);
+}

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

@@ -15,8 +15,9 @@
  */
 import { Observable } from "rxjs";
 import Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { IReadOnlyPlaybackObserver } from "../api";
-import { IStreamOrchestratorEvent, IStreamOrchestratorPlaybackObservation } from "../stream";
+import { IAdaptationChangeEvent, IStreamOrchestratorPlaybackObservation } from "../stream";
 import { IWarningEvent } from "./types";
 /**
  * Observes the position and Adaptations being played and deduce various events
@@ -27,11 +28,11 @@ import { IWarningEvent } from "./types";
  *    theoretically playable.
  *
  * @param {Object} manifest
- * @param {Observable} streams
+ * @param {Object} lastAdaptationChange
  * @param {Object} playbackObserver
  * @returns {Observable}
  */
-export default function ContentTimeBoundariesObserver(manifest: Manifest, streams: Observable<IStreamOrchestratorEvent>, playbackObserver: IReadOnlyPlaybackObserver<IContentTimeObserverPlaybackObservation>): Observable<IContentDurationUpdateEvent | IWarningEvent>;
+export default function ContentTimeBoundariesObserver(manifest: Manifest, lastAdaptationChange: IReadOnlySharedReference<IAdaptationChangeEvent | null>, playbackObserver: IReadOnlyPlaybackObserver<IContentTimeObserverPlaybackObservation>): Observable<IContentDurationUpdateEvent | IWarningEvent>;
 /**
  * Emitted when the duration of the full content (== the last playable position)
  * has changed.

package/dist/_esm5.processed/core/init/content_time_boundaries_observer.js

@@ -34,11 +34,11 @@ import EVENTS from "./events_generators";
  *    theoretically playable.
  *
  * @param {Object} manifest
- * @param {Observable} streams
+ * @param {Object} lastAdaptationChange
  * @param {Object} playbackObserver
  * @returns {Observable}
  */
-export default function ContentTimeBoundariesObserver(manifest, streams, playbackObserver) {
+export default function ContentTimeBoundariesObserver(manifest, lastAdaptationChange, playbackObserver) {
     /**
      * Allows to calculate the minimum and maximum playable position on the
      * whole content.
@@ -74,27 +74,26 @@ export default function ContentTimeBoundariesObserver(manifest, streams, playbac
             maximumPositionCalculator.getMaximumAvailablePosition();
         contentDuration.setValue(duration);
     }), ignoreElements());
-    var updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(tap(function (message) {
-        if (message.type === "adaptationChange") {
-            if (!manifest.isLastPeriodKnown) {
-                return;
-            }
-            var lastPeriod = manifest.periods[manifest.periods.length - 1];
-            if (message.value.period.id === (lastPeriod === null || lastPeriod === void 0 ? void 0 : lastPeriod.id)) {
-                if (message.value.type === "audio" || message.value.type === "video") {
-                    if (message.value.type === "audio") {
-                        maximumPositionCalculator
-                            .updateLastAudioAdaptation(message.value.adaptation);
-                    }
-                    else {
-                        maximumPositionCalculator
-                            .updateLastVideoAdaptation(message.value.adaptation);
-                    }
-                    var newDuration = manifest.isDynamic ?
-                        maximumPositionCalculator.getMaximumAvailablePosition() :
-                        maximumPositionCalculator.getEndingPosition();
-                    contentDuration.setValue(newDuration);
+    var updateDurationAndTimeBoundsOnTrackChange$ = lastAdaptationChange
+        .asObservable().pipe(tap(function (message) {
+        if (message === null || !manifest.isLastPeriodKnown) {
+            return;
+        }
+        var lastPeriod = manifest.periods[manifest.periods.length - 1];
+        if (message.value.period.id === (lastPeriod === null || lastPeriod === void 0 ? void 0 : lastPeriod.id)) {
+            if (message.value.type === "audio" || message.value.type === "video") {
+                if (message.value.type === "audio") {
+                    maximumPositionCalculator
+                        .updateLastAudioAdaptation(message.value.adaptation);
+                }
+                else {
+                    maximumPositionCalculator
+                        .updateLastVideoAdaptation(message.value.adaptation);
                 }
+                var newDuration = manifest.isDynamic ?
+                    maximumPositionCalculator.getMaximumAvailablePosition() :
+                    maximumPositionCalculator.getEndingPosition();
+                contentDuration.setValue(newDuration);
             }
         }
     }), ignoreElements());

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

@@ -15,10 +15,11 @@
  */
 import { Observable } from "rxjs";
 import { IKeySystemOption } from "../../public_types";
+import { ITransportPipelines } from "../../transports";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { IAdaptiveRepresentationSelectorArguments } from "../adaptive";
 import { PlaybackObserver } from "../api";
-import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher, SegmentFetcherCreator } from "../fetchers";
+import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
 import { IAudioTrackSwitchingMode } from "../stream";
 import { IInitialTimeOptions } from "./get_initial_time";
@@ -65,8 +66,21 @@ export interface IInitializeArguments {
     mediaElement: HTMLMediaElement;
     /** Limit the frequency of Manifest updates. */
     minimumManifestUpdateInterval: number;
-    /** Interface allowing to load segments */
-    segmentFetcherCreator: SegmentFetcherCreator;
+    /** Interface allowing to interact with the transport protocol */
+    transport: ITransportPipelines;
+    /** Configuration for the segment requesting logic. */
+    segmentRequestOptions: {
+        /** Maximum number of time a request on error will be retried. */
+        regularError: number | undefined;
+        /** Maximum number of time a request be retried when the user is offline. */
+        offlineError: number | undefined;
+        /**
+         * Amount of time after which a request should be aborted.
+         * `undefined` indicates that a default value is wanted.
+         * `-1` indicates no timeout.
+         */
+        requestTimeout: number | undefined;
+    };
     /** Emit the playback rate (speed) set by the user. */
     speed: IReadOnlySharedReference<number>;
     /** The configured starting position. */
@@ -105,4 +119,4 @@ export interface IInitializeArguments {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, playbackObserver, segmentFetcherCreator, speed, startAt, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;
+export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, playbackObserver, segmentRequestOptions, speed, startAt, transport, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;

package/dist/_esm5.processed/core/init/initialize_media_source.js

@@ -21,8 +21,10 @@ import deferSubscriptions from "../../utils/defer_subscriptions";
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import objectAssign from "../../utils/object_assign";
+import TaskCanceller from "../../utils/task_canceller";
 import AdaptiveRepresentationSelector from "../adaptive";
 import { getCurrentKeySystem, } from "../decrypt";
+import { SegmentFetcherCreator, } from "../fetchers";
 import openMediaSource from "./create_media_source";
 import EVENTS from "./events_generators";
 import getInitialTime from "./get_initial_time";
@@ -62,9 +64,10 @@ import throwOnMediaError from "./throw_on_media_error";
  * @returns {Observable}
  */
 export default function InitializeOnMediaSource(_a) {
-    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, speed = _a.speed, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions;
+    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, playbackObserver = _a.playbackObserver, segmentRequestOptions = _a.segmentRequestOptions, speed = _a.speed, startAt = _a.startAt, transport = _a.transport, textTrackOptions = _a.textTrackOptions;
     /** Choose the right "Representation" for a given "Adaptation". */
     var representationEstimator = AdaptiveRepresentationSelector(adaptiveOptions);
+    var playbackCanceller = new TaskCanceller();
     /**
      * Create and open a new MediaSource object on the given media element on
      * subscription.
@@ -108,6 +111,10 @@ export default function InitializeOnMediaSource(_a) {
         log.debug("Init: Calculating initial time");
         var initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
         log.debug("Init: Initial time calculated:", initialTime);
+        var requestOptions = { lowLatencyMode: lowLatencyMode, requestTimeout: segmentRequestOptions.requestTimeout,
+            maxRetryRegular: segmentRequestOptions.regularError,
+            maxRetryOffline: segmentRequestOptions.offlineError };
+        var segmentFetcherCreator = new SegmentFetcherCreator(transport, requestOptions, playbackCanceller.signal);
         var mediaSourceLoader = createMediaSourceLoader({
             bufferOptions: objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions),
             manifest: manifest,
@@ -189,5 +196,6 @@ export default function InitializeOnMediaSource(_a) {
             return observableMerge(handleReloads$, currentLoad$);
         }
     }));
-    return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()));
+    return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()))
+        .pipe(finalize(function () { playbackCanceller.cancel(); }));
 }

package/dist/_esm5.processed/core/init/load_on_media_source.js

@@ -16,6 +16,7 @@
 import { EMPTY, filter, finalize, ignoreElements, merge as observableMerge, mergeMap, of as observableOf, Subject, switchMap, takeUntil, throwError, } from "rxjs";
 import { MediaError } from "../../errors";
 import log from "../../log";
+import createSharedReference from "../../utils/reference";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator from "../stream";
 import ContentTimeBoundariesObserver from "./content_time_boundaries_observer";
@@ -63,6 +64,8 @@ export default function createMediaSourceLoader(_a) {
         var discontinuityUpdate$ = new Subject();
         /** Emits event when streams are "locked", meaning they cannot load segments. */
         var lockedStream$ = new Subject();
+        /** Emit each time a new Adaptation is considered by the `StreamOrchestrator`. */
+        var lastAdaptationChange = createSharedReference(null);
         // Creates Observable which will manage every Stream for the given Content.
         var streams$ = StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, bufferOptions).pipe(mergeMap(function (evt) {
             switch (evt.type) {
@@ -80,11 +83,14 @@ export default function createMediaSourceLoader(_a) {
                 case "locked-stream":
                     lockedStream$.next(evt.value);
                     return EMPTY;
+                case "adaptationChange":
+                    lastAdaptationChange.setValue(evt);
+                    return observableOf(evt);
                 default:
                     return observableOf(evt);
             }
         }));
-        var contentTimeObserver = ContentTimeBoundariesObserver(manifest, streams$, streamObserver)
+        var contentTimeObserver = ContentTimeBoundariesObserver(manifest, lastAdaptationChange, streamObserver)
             .pipe(mergeMap(function (evt) {
             switch (evt.type) {
                 case "contentDurationUpdate":

package/dist/_esm5.processed/core/init/stall_avoider.js

@@ -180,7 +180,9 @@ export default function StallAvoider(playbackObserver, manifest, speed, lockedSt
         }
         /** Position at which data is awaited. */
         var stalledPosition = rebuffering.position;
-        if (stalledPosition !== null && speed.getValue() > 0) {
+        if (stalledPosition !== null &&
+            stalledPosition !== undefined &&
+            speed.getValue() > 0) {
             var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPosition);
             if (skippableDiscontinuity !== null) {
                 var realSeekTime = skippableDiscontinuity + 0.001;

package/dist/_esm5.processed/default_config.d.ts

@@ -336,6 +336,17 @@ declare const DEFAULT_CONFIG: {
      * @type Number
      */
     DEFAULT_MAX_MANIFEST_REQUEST_RETRY: number;
+    /**
+     * Default delay, in seconds, during which a CDN will be "downgraded".
+     *
+     * For example in case of media content being available on multiple CDNs, the
+     * RxPlayer may decide that a CDN is less reliable (for example, it returned a
+     * server error) and should thus be avoided, at least for some time
+     *
+     * This value is the amount of time this CDN will be "less considered" than the
+     * alternatives.
+     */
+    DEFAULT_CDN_DOWNGRADE_TIME: number;
     /**
      * The default number of times a segment request will be re-performed when
      * on error which justify a retry.