rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/CHANGELOG.md

@@ -1,9 +1,19 @@
 # Changelog
 
-## v3.28.1-dev.2022083000 (2022-08-30)
+## v3.29.0-dev.2022090500 (2022-09-05)
+
+### Features
+
+  - add `networkConfig.segmentRequestTimeout` and `networkConfig.manifestRequestTimeout` options to loadVideo to configure the timeout of respectively segment and manifest requests [#1156]
+  - add `timeout` property to the first argument communicated to a `segmentLoader` (from `loadVideo`'s `transportOptions`) [#1156]
+  - add `timeout` property to a new third argument communicated to a `manifestLoader` (from `loadVideo`'s `transportOptions`) [#1156]
 
 ### Bug fixes
 
+  - Compat/Directfile: Fix an issue with LG TV when playing multiple directfile contents with the `stopAtEnd` player option set to `true` [#1154]
+  - Compat: To work around an issue on LG TVs, also specify a request timeout manually through a `setTimeout` call when XMLHttpRequests are created for Manifest and segment requests [#1152]
+  - Compat: Fix issue with Samsung TVs where starting playback on a discontinuity could lead to infinite rebuffering [#1140]
+  - Better handle valid reverse playback use cases by not skipping gaps when the playback rate has been set to `0` or a negative value [#1138]
   - DRM: When using persistent licenses, create new MediaKeySession when `load` resolves with `false`, instead of relying the same, to fix issues with such persistent sessions [#1139]
 
 ### Other improvements

package/VERSION

@@ -1 +1 @@
-3.28.1-dev.2022083000
+3.29.0-dev.2022090500

package/dist/_esm5.processed/compat/event_listeners.d.ts

@@ -42,7 +42,8 @@ export interface IPictureInPictureEvent {
 }
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
+ * @param {Object} stopListening
  * @returns {Observable}
  */
 declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListening: CancellationSignal): IReadOnlySharedReference<IPictureInPictureEvent>;
@@ -151,6 +152,21 @@ declare const onKeyError$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Event>;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onSeeking: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onSeeked: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -162,4 +178,4 @@ declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Ev
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

package/dist/_esm5.processed/compat/event_listeners.js

@@ -70,6 +70,52 @@ function eventPrefixed(eventNames, prefixes) {
             .map(function (p) { return p + name; }));
     }, []);
 }
+/**
+ * Returns a function allowing to add event listeners for particular event(s)
+ * optionally automatically adding browser prefixes if needed.
+ * @param {Array.<string>} eventNames - The event(s) to listen to. If multiple
+ * events are set, the event listener will be triggered when any of them emits.
+ * @returns {Function} - Returns function allowing to easily add a callback to
+ * be triggered when that event is emitted on a given event target.
+ */
+function createCompatibleEventListener(eventNames) {
+    var mem;
+    var prefixedEvents = eventPrefixed(eventNames);
+    return function (element, listener, cancelSignal) {
+        if (cancelSignal.isCancelled) {
+            return;
+        }
+        // if the element is a HTMLElement we can detect
+        // the supported event, and memoize it in `mem`
+        if (element instanceof HTMLElement) {
+            if (typeof mem === "undefined") {
+                mem = findSupportedEvent(element, prefixedEvents);
+            }
+            if (isNonEmptyString(mem)) {
+                element.addEventListener(mem, listener);
+                cancelSignal.register(function () {
+                    if (mem !== undefined) {
+                        element.removeEventListener(mem, listener);
+                    }
+                });
+            }
+            else {
+                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                    log.warn("compat: element ".concat(element.tagName) +
+                        " does not support any of these events: " +
+                        prefixedEvents.join(", "));
+                }
+                return;
+            }
+        }
+        prefixedEvents.forEach(function (eventName) {
+            element.addEventListener(eventName, listener);
+            cancelSignal.register(function () {
+                element.removeEventListener(eventName, listener);
+            });
+        });
+    };
+}
 /**
  * @param {Array.<string>} eventNames
  * @param {Array.<string>|undefined} prefixes
@@ -186,7 +232,8 @@ function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
 }
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
+ * @param {Object} stopListening
  * @returns {Observable}
  */
 function getPictureOnPictureStateRef(elt, stopListening) {
@@ -397,6 +444,21 @@ var onKeyError$ = compatibleListener(["keyerror", "error"]);
  * @returns {Observable}
  */
 var onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onSeeking = createCompatibleEventListener(["seeking"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onSeeked = createCompatibleEventListener(["seeked"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onEnded = createCompatibleEventListener(["ended"]);
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -413,4 +475,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

package/dist/_esm5.processed/compat/on_height_width_change.d.ts

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../utils/reference";
+import { CancellationSignal } from "../utils/task_canceller";
 export interface IResolution {
     width: number;
     height: number;
 }
 /**
- * Emit the current height and width of the given `element` on subscribtion
- * and each time it changes.
+ * Emit the current height and width of the given `element` each time it
+ * changes.
  *
  * On some browsers, we might not be able to rely on a native API to know when
  * it changes, the `interval` argument allow us to provide us an inverval in
@@ -29,4 +30,4 @@ export interface IResolution {
  * @param {number} interval
  * @returns {Observable}
  */
-export default function onHeightWidthChange(element: HTMLElement, interval: number): Observable<IResolution>;
+export default function onHeightWidthChange(element: HTMLElement, interval: number, cancellationSignal: CancellationSignal): IReadOnlySharedReference<IResolution>;

package/dist/_esm5.processed/compat/on_height_width_change.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, distinctUntilChanged, interval as observableInterval, map, Observable, startWith, } from "rxjs";
 import log from "../log";
+import createSharedReference from "../utils/reference";
 import isNode from "./is_node";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
@@ -23,8 +23,8 @@ var _ResizeObserver = isNode ? undefined :
 /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 /* eslint-enable @typescript-eslint/no-unsafe-assignment */
 /**
- * Emit the current height and width of the given `element` on subscribtion
- * and each time it changes.
+ * Emit the current height and width of the given `element` each time it
+ * changes.
  *
  * On some browsers, we might not be able to rely on a native API to know when
  * it changes, the `interval` argument allow us to provide us an inverval in
@@ -33,36 +33,45 @@ var _ResizeObserver = isNode ? undefined :
  * @param {number} interval
  * @returns {Observable}
  */
-export default function onHeightWidthChange(element, interval) {
-    return observableDefer(function () {
-        if (_ResizeObserver !== undefined) {
-            var lastHeight_1 = -1;
-            var lastWidth_1 = -1;
-            return new Observable(function (obs) {
-                var resizeObserver = new _ResizeObserver(function (entries) {
-                    if (entries.length === 0) {
-                        log.error("Compat: Resized but no observed element.");
-                        return;
-                    }
-                    var entry = entries[0];
-                    var _a = entry.contentRect, height = _a.height, width = _a.width;
-                    if (height !== lastHeight_1 || width !== lastWidth_1) {
-                        lastHeight_1 = height;
-                        lastWidth_1 = width;
-                        obs.next({ height: height, width: width });
-                    }
-                });
-                resizeObserver.observe(element);
-                return function () {
-                    resizeObserver.disconnect();
-                };
-            });
-        }
-        return observableInterval(interval).pipe(startWith(null), map(function () {
-            var _a = element.getBoundingClientRect(), height = _a.height, width = _a.width;
-            return { height: height, width: width };
-        }), distinctUntilChanged(function (o, n) {
-            return o.height === n.height && o.width === n.width;
-        }));
+export default function onHeightWidthChange(element, interval, cancellationSignal) {
+    var _a = element.getBoundingClientRect(), initHeight = _a.height, initWidth = _a.width;
+    var ref = createSharedReference({
+        height: initHeight,
+        width: initWidth,
     });
+    var lastHeight = initHeight;
+    var lastWidth = initWidth;
+    if (_ResizeObserver !== undefined) {
+        var resizeObserver_1 = new _ResizeObserver(function (entries) {
+            if (entries.length === 0) {
+                log.error("Compat: Resized but no observed element.");
+                return;
+            }
+            var entry = entries[0];
+            var _a = entry.contentRect, height = _a.height, width = _a.width;
+            if (height !== lastHeight || width !== lastWidth) {
+                lastHeight = height;
+                lastWidth = width;
+                ref.setValue({ height: height, width: width });
+            }
+        });
+        resizeObserver_1.observe(element);
+        cancellationSignal.register(function () {
+            resizeObserver_1.disconnect();
+        });
+    }
+    else {
+        var intervalId_1 = setInterval(function () {
+            var _a = element.getBoundingClientRect(), height = _a.height, width = _a.width;
+            if (height !== lastHeight || width !== lastWidth) {
+                lastHeight = height;
+                lastWidth = width;
+                ref.setValue({ height: height, width: width });
+            }
+        }, interval);
+        cancellationSignal.register(function () {
+            clearInterval(intervalId_1);
+        });
+    }
+    return ref;
 }

package/dist/_esm5.processed/core/api/playback_observer.d.ts

@@ -54,7 +54,7 @@ export default class PlaybackObserver {
      * This allows us to correctly characterize seeking events: if the counter is
      * superior to `0`, it is probably due to an internal "seek".
      */
-    private _internalSeekingEventsIncomingCounter;
+    private _internalSeeksIncoming;
     /**
      * Stores the last playback observation produced by the `PlaybackObserver`.:
      */
@@ -92,6 +92,11 @@ export default class PlaybackObserver {
      * @returns {number}
      */
     getCurrentTime(): number;
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    getPlaybackRate(): number;
     /**
      * Returns the current `paused` status advertised by the `HTMLMediaElement`.
      *
@@ -272,7 +277,7 @@ export interface IPlaybackObservation extends IMediaInfos {
      * If `true`, an "internal seek" (a seeking operation triggered by the
      * RxPlayer code) is currently pending.
      */
-    internalSeeking: boolean;
+    pendingInternalSeek: number | null;
 }
 /**
  * Interface providing a generic and read-only version of a `PlaybackObserver`.
@@ -289,6 +294,11 @@ export interface IPlaybackObservation extends IMediaInfos {
 export interface IReadOnlyPlaybackObserver<TObservationType> {
     /** Get the current playing position, in seconds. */
     getCurrentTime(): number;
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    getPlaybackRate(): number;
     /** Get the HTMLMediaElement's current `readyState`. */
     getReadyState(): number;
     /**

package/dist/_esm5.processed/core/api/playback_observer.js

@@ -58,7 +58,7 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {Object} options
      */
     function PlaybackObserver(mediaElement, options) {
-        this._internalSeekingEventsIncomingCounter = 0;
+        this._internalSeeksIncoming = [];
         this._mediaElement = mediaElement;
         this._withMediaSource = options.withMediaSource;
         this._lowLatencyMode = options.lowLatencyMode;
@@ -86,6 +86,13 @@ var PlaybackObserver = /** @class */ (function () {
     PlaybackObserver.prototype.getCurrentTime = function () {
         return this._mediaElement.currentTime;
     };
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    PlaybackObserver.prototype.getPlaybackRate = function () {
+        return this._mediaElement.playbackRate;
+    };
     /**
      * Returns the current `paused` status advertised by the `HTMLMediaElement`.
      *
@@ -107,7 +114,7 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {number} time
      */
     PlaybackObserver.prototype.setCurrentTime = function (time) {
-        this._internalSeekingEventsIncomingCounter += 1;
+        this._internalSeeksIncoming.push(time);
         this._mediaElement.currentTime = time;
     };
     /**
@@ -180,24 +187,29 @@ var PlaybackObserver = /** @class */ (function () {
         var _a = config.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
         var getCurrentObservation = function (event) {
             var tmpEvt = event;
-            if (tmpEvt === "seeking" && _this._internalSeekingEventsIncomingCounter > 0) {
+            var startedInternalSeekTime;
+            if (tmpEvt === "seeking" && _this._internalSeeksIncoming.length > 0) {
                 tmpEvt = "internal-seeking";
-                _this._internalSeekingEventsIncomingCounter -= 1;
+                startedInternalSeekTime = _this._internalSeeksIncoming.shift();
             }
             var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
             var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt);
-            var internalSeeking = mediaTimings.seeking &&
-                // We've just received the event for internally seeking
-                (tmpEvt === "internal-seeking" ||
-                    // or We're still waiting on the previous internal-seek
-                    (_lastObservation.internalSeeking && tmpEvt !== "seeking"));
+            var pendingInternalSeek = null;
+            if (mediaTimings.seeking) {
+                if (typeof startedInternalSeekTime === "number") {
+                    pendingInternalSeek = startedInternalSeekTime;
+                }
+                else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
+                    pendingInternalSeek = _lastObservation.pendingInternalSeek;
+                }
+            }
             var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
                 withMediaSource: _this._withMediaSource });
             var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
             var timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus, internalSeeking: internalSeeking }, mediaTimings);
+                freezing: freezingStatus, pendingInternalSeek: pendingInternalSeek }, mediaTimings);
             if (log.hasLevel("DEBUG")) {
-                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeeking", timings.internalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
             }
             return timings;
         };
@@ -242,7 +254,7 @@ var PlaybackObserver = /** @class */ (function () {
     PlaybackObserver.prototype._generateInitialObservation = function () {
         return objectAssign(getMediaInfos(this._mediaElement, "init"), { rebuffering: null,
             freezing: null,
-            internalSeeking: false });
+            pendingInternalSeek: null });
     };
     return PlaybackObserver;
 }());
@@ -504,6 +516,9 @@ function generateReadOnlyObserver(src, transform, cancellationSignal) {
         getReadyState: function () {
             return src.getReadyState();
         },
+        getPlaybackRate: function () {
+            return src.getPlaybackRate();
+        },
         getIsPaused: function () {
             return src.getIsPaused();
         },

package/dist/_esm5.processed/core/api/public_api.js

@@ -88,7 +88,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.28.1-dev.2022083000";
+        _this.version = /* PLAYER_VERSION */ "3.29.0-dev.2022090500";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -373,13 +373,15 @@ var Player = /** @class */ (function (_super) {
                 throw new Error("transport \"".concat(transport, "\" not supported"));
             }
             var transportPipelines = transportFn(transportOptions);
-            var offlineRetry = networkConfig.offlineRetry, segmentRetry = networkConfig.segmentRetry, manifestRetry = networkConfig.manifestRetry;
+            var offlineRetry = networkConfig.offlineRetry, segmentRetry = networkConfig.segmentRetry, manifestRetry = networkConfig.manifestRetry, manifestRequestTimeout = networkConfig.manifestRequestTimeout, segmentRequestTimeout = networkConfig.segmentRequestTimeout;
             /** Interface used to load and refresh the Manifest. */
             var manifestFetcher = new ManifestFetcher(url, transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryRegular: manifestRetry,
-                maxRetryOffline: offlineRetry });
+                maxRetryOffline: offlineRetry,
+                requestTimeout: manifestRequestTimeout });
             /** Interface used to download segments. */
             var segmentFetcherCreator = new SegmentFetcherCreator(transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryOffline: offlineRetry,
-                maxRetryRegular: segmentRetry });
+                maxRetryRegular: segmentRetry,
+                requestTimeout: segmentRequestTimeout });
             /** Observable emitting the initial Manifest */
             var manifest$ = void 0;
             if (initialManifest instanceof Manifest) {
@@ -587,15 +589,13 @@ var Player = /** @class */ (function (_super) {
         // Handle state updates
         playerState$
             .pipe(takeUntil(stoppedContent$))
-            .subscribe(function (x) { return _this._priv_setPlayerState(x); });
-        var endedEvent$ = observation$.pipe(filter(function (o) {
-            return o.event === "ended";
-        }));
-        (this._priv_stopAtEnd ? endedEvent$ :
-            EMPTY)
-            .pipe(takeUntil(stoppedContent$))
-            .subscribe(function () {
-            currentContentCanceller.cancel();
+            .subscribe(function (newState) {
+            _this._priv_setPlayerState(newState);
+            // Previous call could have performed all kind of side-effects, thus,
+            // we re-check the current state associated to the RxPlayer
+            if (_this.state === "ENDED" && _this._priv_stopAtEnd) {
+                currentContentCanceller.cancel();
+            }
         });
         // Link playback events to the corresponding callbacks
         playback$.subscribe({
@@ -2295,5 +2295,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.28.1-dev.2022083000";
+Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022090500";
 export default Player;

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.d.ts

@@ -74,6 +74,13 @@ export interface IManifestFetcherSettings {
     maxRetryRegular: number | undefined;
     /** Maximum number of time a request be retried when the user is offline. */
     maxRetryOffline: number | undefined;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     * `undefined` will lead to a default, large, timeout being used.
+     */
+    requestTimeout: number | undefined;
 }
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest.

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

@@ -54,6 +54,7 @@ import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import assert from "../../../utils/assert";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
@@ -106,6 +107,7 @@ var ManifestFetcher = /** @class */ (function () {
     ManifestFetcher.prototype.fetch = function (url) {
         var _this = this;
         return new Observable(function (obs) {
+            var settings = _this._settings;
             var pipelines = _this._pipelines;
             var requestUrl = url !== null && url !== void 0 ? url : _this._manifestUrl;
             /** `true` if the loading pipeline is already completely executed. */
@@ -160,12 +162,18 @@ var ManifestFetcher = /** @class */ (function () {
              * Call the loader part of the pipeline, retrying if it fails according
              * to the current settings.
              * Returns the Promise of the last attempt.
-             * @param {string | undefined}  resolverUrl
+             * @param {string | undefined} manifestUrl
              * @returns {Promise}
              */
             function callLoaderWithRetries(manifestUrl) {
                 var loadManifest = pipelines.loadManifest;
-                var callLoader = function () { return loadManifest(manifestUrl, canceller.signal); };
+                var requestTimeout = isNullOrUndefined(settings.requestTimeout) ?
+                    config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
+                    settings.requestTimeout;
+                if (requestTimeout < 0) {
+                    requestTimeout = undefined;
+                }
+                var callLoader = function () { return loadManifest(manifestUrl, { timeout: requestTimeout }, canceller.signal); };
                 return tryRequestPromiseWithBackoff(callLoader, backoffSettings, canceller.signal);
             }
         });

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -123,14 +123,21 @@ export interface ISegmentFetcherOptions {
      * currently offline.
      */
     maxRetryOffline: number;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     */
+    requestTimeout: number;
 }
 /**
  * @param {string} bufferType
  * @param {Object}
  * @returns {Object}
  */
-export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode }: {
+export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode, requestTimeout }: {
     maxRetryRegular?: number | undefined;
     maxRetryOffline?: number | undefined;
+    requestTimeout?: number | undefined;
     lowLatencyMode: boolean;
 }): ISegmentFetcherOptions;

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -40,6 +40,10 @@ var generateRequestID = idGenerator();
  * @returns {Function}
  */
 export default function createSegmentFetcher(bufferType, pipeline, callbacks, options) {
+    var requestOptions = {
+        timeout: options.requestTimeout < 0 ? undefined :
+            options.requestTimeout,
+    };
     /**
      * Cache audio and video initialization segments.
      * This allows to avoid doing too many requests for what are usually very
@@ -203,7 +207,7 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
              * @returns {Promise}
              */
             function callLoaderWithUrl(url, cancellationSignal) {
-                return loadSegment(url, content, cancellationSignal, loaderCallbacks);
+                return loadSegment(url, content, requestOptions, cancellationSignal, loaderCallbacks);
             }
             /**
              * Generate function allowing to parse a loaded segment.
@@ -272,13 +276,15 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
  * @returns {Object}
  */
 export function getSegmentFetcherOptions(bufferType, _a) {
-    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
-    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
+    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode, requestTimeout = _a.requestTimeout;
+    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT = _b.DEFAULT_REQUEST_TIMEOUT, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
     return { maxRetryRegular: bufferType === "image" ? 0 :
             maxRetryRegular !== null && maxRetryRegular !== void 0 ? maxRetryRegular : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
         maxRetryOffline: maxRetryOffline !== null && maxRetryOffline !== void 0 ? maxRetryOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
         baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR,
         maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR };
+            MAX_BACKOFF_DELAY_BASE.REGULAR,
+        requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
+            requestTimeout };
 }

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.d.ts

@@ -91,4 +91,11 @@ export interface ISegmentFetcherCreatorBackoffOptions {
     maxRetryRegular: number | undefined;
     /** Maximum number of time a request be retried when the user is offline. */
     maxRetryOffline: number | undefined;
+    /**
+     * Timeout after which request are aborted and, depending on other options,
+     * retried.
+     * To set to `-1` for no timeout.
+     * `undefined` will lead to a default, large, timeout being used.
+     */
+    requestTimeout: number | undefined;
 }

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

@@ -108,7 +108,7 @@ export default function initializeDirectfileContent(_a) {
      * Observable trying to avoid various stalling situations, emitting "stalled"
      * events when it cannot, as well as "unstalled" events when it get out of one.
      */
-    var stallAvoider$ = StallAvoider(playbackObserver, null, EMPTY, EMPTY);
+    var stallAvoider$ = StallAvoider(playbackObserver, null, speed, EMPTY, EMPTY);
     /**
      * Emit a "loaded" events once the initial play has been performed and the
      * media can begin playback.

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

@@ -106,7 +106,7 @@ export default function createMediaSourceLoader(_a) {
          * Observable trying to avoid various stalling situations, emitting "stalled"
          * events when it cannot, as well as "unstalled" events when it get out of one.
          */
-        var stallAvoider$ = StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$);
+        var stallAvoider$ = StallAvoider(playbackObserver, manifest, speed, lockedStream$, discontinuityUpdate$);
         /**
          * Emit a "loaded" events once the initial play has been performed and the
          * media can begin playback.

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

@@ -15,6 +15,7 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Period } from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { PlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
 import { IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
@@ -67,9 +68,10 @@ export interface IDiscontinuityTimeInfo {
  * encountered and exited.
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
+ * @param {Object} speed - The last speed set by the user
+ * @param {Observable} lockedStream$
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
- * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;
+export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, speed: IReadOnlySharedReference<number>, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;