rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -17,12 +17,10 @@
  * This file provides browser-agnostic event listeners under the form of
  * RxJS Observables
  */
-import { combineLatest as observableCombineLatest, defer as observableDefer, fromEvent as observableFromEvent, interval as observableInterval, merge as observableMerge, NEVER, of as observableOf, } from "rxjs";
-import { delay, distinctUntilChanged, map, mapTo, startWith, switchMap, throttleTime, } from "rxjs/operators";
+import { NEVER, combineLatest as observableCombineLatest, defer as observableDefer, delay, distinctUntilChanged, fromEvent as observableFromEvent, interval as observableInterval, map, merge as observableMerge, of as observableOf, startWith, switchMap, throttleTime, } from "rxjs";
 import config from "../config";
 import log from "../log";
 import isNonEmptyString from "../utils/is_non_empty_string";
-import { HTMLElement_, } from "./browser_compatibility_types";
 import isNode from "./is_node";
 import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
@@ -45,7 +43,6 @@ function isEventSupported(element, eventNameSuffix) {
     }
     else {
         clone.setAttribute(eventName, "return;");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         return typeof clone[eventName] === "function";
     }
 }
@@ -82,7 +79,7 @@ function compatibleListener(eventNames, prefixes) {
     return function (element) {
         // if the element is a HTMLElement we can detect
         // the supported event, and memoize it in `mem`
-        if (element instanceof HTMLElement_) {
+        if (element instanceof HTMLElement) {
             if (typeof mem === "undefined") {
                 mem = findSupportedEvent(element, prefixedEvents);
             }
@@ -90,8 +87,8 @@ function compatibleListener(eventNames, prefixes) {
                 return observableFromEvent(element, mem);
             }
             else {
-                if (false) {
-                    log.warn("compat: element " + element.tagName +
+                if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
+                    log.warn("compat: element ".concat(element.tagName) +
                         " does not support any of these events: " +
                         prefixedEvents.join(", "));
                 }
@@ -136,19 +133,13 @@ function visibilityChange() {
             .pipe(map(function () { return !(document[hidden]); }), startWith(!isHidden), distinctUntilChanged());
     });
 }
-/**
- * @returns {Observable}
- */
-function videoSizeChange() {
-    return observableFromEvent(window, "resize");
-}
 /**
  * Emit `true` if the page is considered active.
  * `false` when considered inactive.
  * Emit the original value on subscription.
  * @returns {Observable}
  */
-function isActive() {
+function isPageActive() {
     return visibilityChange().pipe(switchMap(function (x) {
         if (!x) {
             return observableOf(x).pipe(delay(INACTIVITY_DELAY));
@@ -173,33 +164,28 @@ function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-function onPictureInPictureEvent$(mediaElement) {
+function onPictureInPictureEvent$(elt) {
     return observableDefer(function () {
-        /* eslint-disable @typescript-eslint/strict-boolean-expressions */
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        if (mediaElement.webkitSupportsPresentationMode &&
+        var mediaElement = elt;
+        if (mediaElement.webkitSupportsPresentationMode === true &&
             typeof mediaElement.webkitSetPresentationMode === "function") {
             var isWebKitPIPEnabled = mediaElement.webkitPresentationMode === "picture-in-picture";
             return observableFromEvent(mediaElement, "webkitpresentationmodechanged").pipe(map(function () { return ({
-                isEnabled: mediaElement
-                    .webkitPresentationMode === "picture-in-picture",
+                isEnabled: mediaElement.webkitPresentationMode === "picture-in-picture",
                 pipWindow: null,
             }); }), startWith({ isEnabled: isWebKitPIPEnabled, pipWindow: null }));
         }
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-        var isPIPEnabled = (document.pictureInPictureElement &&
-            document.pictureInPictureElement === mediaElement);
+        var isPIPEnabled = (document.pictureInPictureElement === mediaElement);
         var initialState = { isEnabled: isPIPEnabled, pipWindow: null };
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
         return observableMerge(observableFromEvent(mediaElement, "enterpictureinpicture")
-            .pipe(map(function (evt) { return ({
-            isEnabled: true,
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            pipWindow: evt.pictureInPictureWindow,
-        }); })), observableFromEvent(mediaElement, "leavepictureinpicture")
-            .pipe(mapTo({ isEnabled: false, pipWindow: null }))).pipe(startWith(initialState));
-        /* eslint-enable @typescript-eslint/strict-boolean-expressions */
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+            .pipe(map(function (evt) {
+            var _a;
+            return ({
+                isEnabled: true,
+                pipWindow: (_a = evt.pictureInPictureWindow) !== null && _a !== void 0 ? _a : null,
+            });
+        })), observableFromEvent(mediaElement, "leavepictureinpicture")
+            .pipe(map(function () { return ({ isEnabled: false, pipWindow: null }); }))).pipe(startWith(initialState));
     });
 }
 /**
@@ -222,13 +208,14 @@ function isVideoVisible(pip$) {
  * Get video width from HTML video element, or video estimated dimensions
  * when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
+ * @param {Observable} pip$
  * @returns {Observable}
  */
 function videoWidth$(mediaElement, pip$) {
     return observableCombineLatest([
         pip$,
         observableInterval(20000).pipe(startWith(null)),
-        videoSizeChange().pipe(throttleTime(500), startWith(null)),
+        observableFromEvent(window, "resize").pipe(throttleTime(500), startWith(null)),
     ]).pipe(switchMap(function (_a) {
         var pip = _a[0];
         if (!pip.isEnabled) {
@@ -237,7 +224,6 @@ function videoWidth$(mediaElement, pip$) {
         else if (pip.pipWindow != null) {
             var pipWindow_1 = pip.pipWindow;
             var firstWidth = getVideoWidthFromPIPWindow(mediaElement, pipWindow_1);
-            // RxJS typing issue (for the "as any")
             return observableFromEvent(pipWindow_1, "resize").pipe(startWith(firstWidth * pixelRatio), map(function () { return getVideoWidthFromPIPWindow(mediaElement, pipWindow_1) * pixelRatio; }));
         }
         else {
@@ -342,4 +328,4 @@ var onKeyError$ = compatibleListener(["keyerror", "error"]);
  * @returns {Observable}
  */
 var onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
-export { isActive, isVideoVisible, videoWidth$, onPlayPause$, onTextTrackChanges$, onLoadedMetadata$, onSeeking$, onSeeked$, onEnded$, onTimeUpdate$, onFullscreenChange$, onSourceOpen$, onSourceClose$, onSourceEnded$, onUpdate$, onRemoveSourceBuffers$, onEncrypted$, onKeyMessage$, onKeyAdded$, onKeyError$, onKeyStatusesChange$, onPictureInPictureEvent$, };
+export { isPageActive, isVideoVisible, videoWidth$, onPlayPause$, onTextTrackChanges$, onLoadedMetadata$, onSeeking$, onSeeked$, onEnded$, onTimeUpdate$, onFullscreenChange$, onSourceOpen$, onSourceClose$, onSourceEnded$, onUpdate$, onRemoveSourceBuffers$, onEncrypted$, onKeyMessage$, onKeyAdded$, onKeyError$, onKeyStatusesChange$, onPictureInPictureEvent$, };

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

@@ -34,11 +34,7 @@ function requestFullscreen(element) {
             elt.mozRequestFullScreen();
         }
         else if (typeof elt.webkitRequestFullscreen === "function") {
-            (
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-            elt.webkitRequestFullscreen
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            )(Element.ALLOW_KEYBOARD_INPUT);
+            elt.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
         }
     }
 }

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

@@ -15,7 +15,7 @@
  */
 import addClassName from "./add_class_name";
 import addTextTrack from "./add_text_track";
-import { ICompatTextTrack, ICompatVTTCue, MediaSource_, VTTCue_ } from "./browser_compatibility_types";
+import { ICompatTextTrack, ICompatVTTCue, MediaSource_ } from "./browser_compatibility_types";
 import canPatchISOBMFFSegment from "./can_patch_isobmff";
 import tryToChangeSourceBufferType, { ICompatSourceBuffer } from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
@@ -26,11 +26,10 @@ import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
 import isOffline from "./is_offline";
-import isPlaybackStuck from "./is_playback_stuck";
 import isVTTCue from "./is_vtt_cue";
 import makeVTTCue from "./make_vtt_cue";
 import onHeightWidthChange from "./on_height_width_change";
-import play$ from "./play";
+import play from "./play";
 import setElementSrc$ from "./set_element_src";
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "./should_reload_media_source_on_decipherability_update";
 import shouldRenewMediaKeys from "./should_renew_media_keys";
@@ -39,4 +38,4 @@ import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import whenLoadedMetadata$ from "./when_loaded_metadata";
 import whenMediaSourceOpen$ from "./when_media_source_open";
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isPlaybackStuck, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play$, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, VTTCue_, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };

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

@@ -15,7 +15,7 @@
  */
 import addClassName from "./add_class_name";
 import addTextTrack from "./add_text_track";
-import { MediaSource_, VTTCue_, } from "./browser_compatibility_types";
+import { MediaSource_, } from "./browser_compatibility_types";
 import canPatchISOBMFFSegment from "./can_patch_isobmff";
 import tryToChangeSourceBufferType from "./change_source_buffer_type";
 import clearElementSrc from "./clear_element_src";
@@ -26,12 +26,11 @@ import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
 import isOffline from "./is_offline";
-import isPlaybackStuck from "./is_playback_stuck";
 import isVTTCue from "./is_vtt_cue";
 import makeVTTCue from "./make_vtt_cue";
 import onHeightWidthChange from "./on_height_width_change";
 import patchWebkitSourceBuffer from "./patch_webkit_source_buffer";
-import play$ from "./play";
+import play from "./play";
 import setElementSrc$ from "./set_element_src";
 // eslint-disable-next-line max-len
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "./should_reload_media_source_on_decipherability_update";
@@ -45,4 +44,4 @@ import whenMediaSourceOpen$ from "./when_media_source_open";
 // we  would prefer to disallow (both for the understandability of the code and
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isPlaybackStuck, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play$, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, VTTCue_, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };

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

@@ -20,7 +20,6 @@
  */
 export default function isVTTCue(cue) {
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    return typeof window.VTTCue === "function" &&
-        cue instanceof window.VTTCue;
+    return typeof window.VTTCue === "function" && cue instanceof window.VTTCue;
     /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import log from "../log";
-import { VTTCue_, } from "./browser_compatibility_types";
+import isNullOrUndefined from "../utils/is_null_or_undefined";
 /**
  * Creates a cue using the best platform-specific interface available.
  *
@@ -25,14 +25,19 @@ import { VTTCue_, } from "./browser_compatibility_types";
  * were invalid.
  */
 export default function makeCue(startTime, endTime, payload) {
-    if (VTTCue_ == null) {
-        throw new Error("VTT cues not supported in your target");
-    }
     if (startTime >= endTime) {
         // IE/Edge will throw in this case.
         // See issue #501
-        log.warn("Compat: Invalid cue times: " + startTime + " - " + endTime);
+        log.warn("Compat: Invalid cue times: ".concat(startTime, " - ").concat(endTime));
         return null;
     }
-    return new VTTCue_(startTime, endTime, payload);
+    if (isNullOrUndefined(window.VTTCue)) {
+        if (isNullOrUndefined(window.TextTrackCue)) {
+            throw new Error("VTT cues not supported in your target");
+        }
+        return new TextTrackCue(startTime, endTime, payload);
+    }
+    else {
+        return new VTTCue(startTime, endTime, payload);
+    }
 }

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, interval as observableInterval, Observable, } from "rxjs";
-import { distinctUntilChanged, map, startWith, } from "rxjs/operators";
+import { defer as observableDefer, distinctUntilChanged, interval as observableInterval, map, Observable, startWith, } from "rxjs";
 import log from "../log";
 import isNode from "./is_node";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */

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

@@ -21,15 +21,18 @@ import isNode from "./is_node";
 export default function patchWebkitSourceBuffer() {
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-explicit-any */
     // old WebKit SourceBuffer implementation,
     // where a synchronous append is used instead of appendBuffer
     if (!isNode && window.WebKitSourceBuffer != null &&
         window.WebKitSourceBuffer.prototype.addEventListener === undefined) {
+        /* eslint-enable @typescript-eslint/no-explicit-any */
         /* eslint-disable @typescript-eslint/no-unsafe-assignment */
         var sourceBufferWebkitRef = window.WebKitSourceBuffer;
         var sourceBufferWebkitProto = sourceBufferWebkitRef.prototype;
         for (var fnName in EventEmitter.prototype) {
             if (EventEmitter.prototype.hasOwnProperty(fnName)) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 sourceBufferWebkitProto[fnName] = EventEmitter.prototype[fnName];
             }
         }

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

@@ -20,4 +20,4 @@ import { Observable } from "rxjs";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export default function play$(mediaElement: HTMLMediaElement): Observable<unknown>;
+export default function play(mediaElement: HTMLMediaElement): Observable<unknown>;

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

@@ -22,7 +22,7 @@ import tryCatch from "../utils/rx-try_catch";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export default function play$(mediaElement) {
+export default function play(mediaElement) {
     return observableDefer(function () {
         // mediaElement.play is not always a Promise. In the improbable case it
         // throws, I prefer still to catch to return the error wrapped in an

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

@@ -27,7 +27,7 @@ import clearElementSrc from "./clear_element_src";
  */
 export default function setElementSrc$(mediaElement, url) {
     return new Observable(function (observer) {
-        log.info("Setting URL to Element", url, mediaElement);
+        log.info("Setting URL to HTMLMediaElement", url);
         mediaElement.src = url;
         observer.next(undefined);
         return function () {

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
-import { take } from "rxjs/operators";
+import { of as observableOf, take, } from "rxjs";
 import { READY_STATES } from "./browser_compatibility_types";
 import { onLoadedMetadata$ } from "./event_listeners";
 /**

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
-import { take } from "rxjs/operators";
+import { of as observableOf, take, } from "rxjs";
 import { onSourceOpen$ } from "./event_listeners";
 /**
  * Wait for the MediaSource's sourceopen event and emit. Emit immediatelly if

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

@@ -385,17 +385,12 @@ declare const _default: {
         LOW_LATENCY: number;
     };
     /**
-     * Minimum interval at which timeupdate events will be "constructed". This
+     * Minimum interval at which playback information samples will be taken. This
      * variable is for the "regular" mediasource strategy (that is, not for the
      * directfile API.
      *
-     * Those events are the base of various important mechanisms in the player:
-     *   - set the clock used to regularly check which segments should be loaded
-     *   - set the clock for the ABR strategy.
-     *   - used to trigger positionUpdate events.
-     *
-     * This common logic is for performance reasons, as we call multiple browser's
-     * APIs which are useful for most of these.
+     * At each of these interval, various different modules in the RxPlayer will
+     * run based on the information communicated.
      *
      * Keep in mind this is the minimum interval. This logic will also be
      * triggered when various events of the media element are received.
@@ -516,7 +511,7 @@ declare const _default: {
     };
     /**
      * Number of seconds ahead in the buffer after which playback will resume when
-     * the player was stalled due to a low readyState.
+     * the player was rebuffering due to a low readyState.
      * @type {Number}
      */
     RESUME_GAP_AFTER_NOT_ENOUGH_DATA: {
@@ -533,17 +528,61 @@ declare const _default: {
         LOW_LATENCY: number;
     };
     /**
-     * Maximum number of seconds in the buffer based on which a "stalling"
+     * Maximum number of seconds in the buffer based on which a "rebuffering"
      * strategy will be considered:
      * The player will pause playback to get enough time building a sufficient
-     * buffer. This mostly happen when seeking in an unbuffered part or when
-     * buffering.
+     * buffer. This mostly happen when seeking in an unbuffered part or when not
+     * enough buffer is ahead of the current position.
      * @type {Number}
      */
-    STALL_GAP: {
+    REBUFFERING_GAP: {
         DEFAULT: number;
         LOW_LATENCY: number;
     };
+    /**
+     * Amount of time (in seconds) with data ahead of the current position, at
+     * which we always consider the browser to be able to play.
+     *
+     * If the media element has this amount of data in advance or more but
+     * playback cannot begin, the player will consider it "freezing".
+     */
+    MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING: number;
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * If the media is still "freezing" after waiting for `UNFREEZING_SEEK_DELAY`
+     * milliseconds, the RxPlayer will try to un-freeze the situation by interacting
+     * with the media element.
+     *
+     * Those interactions can be costly in time before playback continue, so it
+     * should be set at a sufficiently high value to avoid false positives.
+     */
+    UNFREEZING_SEEK_DELAY: number;
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * A small freezing interval may be normal as the browser may take time before
+     * playing, e.g. after a seek.
+     *
+     * If the media is still "freezing" after waiting for `FREEZING_STALLED_DELAY`
+     * milliseconds, the RxPlayer will emit a BUFFERING state through its API to
+     * notify that the player cannot currently advance.
+     */
+    FREEZING_STALLED_DELAY: number;
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * If the media is frozen for a sufficiently large time
+     * (@see UNFREEZING_SEEK_DELAY), the RxPlayer will perform a seek corresponding
+     * to its current position plus `UNFREEZING_DELTA_POSITION` seconds.
+     *
+     * This should be kept short enough as the goal is just to un-freeze lower-level
+     * buffers.
+     */
+    UNFREEZING_DELTA_POSITION: number;
     /**
      * Maximum authorized difference between what we calculated to be the
      * beginning or end of the segment in a media buffer and what we
@@ -1031,6 +1070,26 @@ declare const _default: {
      * and not significant from the media loss perspective.
      */
     DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR: number;
+    /**
+     * RxPlayer's media buffers have a linked history registering recent events
+     * that happened on those.
+     * The reason is to implement various heuristics in case of weird browser
+     * behavior.
+     *
+     * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
+     * that history can have before being removed from the history.
+     */
+    BUFFERED_HISTORY_RETENTION_TIME: number;
+    /**
+     * RxPlayer's media buffers have a linked history registering recent events
+     * that happened on those.
+     * The reason is to implement various heuristics in case of weird browser
+     * behavior.
+     *
+     * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
+     * there can be in that history.
+     */
+    BUFFERED_HISTORY_MAXIMUM_ENTRIES: number;
 };
 /**
  * Configuration file for the whole player.

package/dist/_esm5.processed/config.js

@@ -295,7 +295,7 @@ export default {
      */
     DEFAULT_LIVE_GAP: {
         DEFAULT: 10,
-        LOW_LATENCY: 3,
+        LOW_LATENCY: 3.5,
     },
     /**
      * Maximum time, in seconds, the player should automatically skip when stalled
@@ -418,17 +418,12 @@ export default {
         LOW_LATENCY: 1000,
     },
     /**
-     * Minimum interval at which timeupdate events will be "constructed". This
+     * Minimum interval at which playback information samples will be taken. This
      * variable is for the "regular" mediasource strategy (that is, not for the
      * directfile API.
      *
-     * Those events are the base of various important mechanisms in the player:
-     *   - set the clock used to regularly check which segments should be loaded
-     *   - set the clock for the ABR strategy.
-     *   - used to trigger positionUpdate events.
-     *
-     * This common logic is for performance reasons, as we call multiple browser's
-     * APIs which are useful for most of these.
+     * At each of these interval, various different modules in the RxPlayer will
+     * run based on the information communicated.
      *
      * Keep in mind this is the minimum interval. This logic will also be
      * triggered when various events of the media element are received.
@@ -549,7 +544,7 @@ export default {
     },
     /**
      * Number of seconds ahead in the buffer after which playback will resume when
-     * the player was stalled due to a low readyState.
+     * the player was rebuffering due to a low readyState.
      * @type {Number}
      */
     RESUME_GAP_AFTER_NOT_ENOUGH_DATA: {
@@ -566,17 +561,61 @@ export default {
         LOW_LATENCY: 0.5,
     },
     /**
-     * Maximum number of seconds in the buffer based on which a "stalling"
+     * Maximum number of seconds in the buffer based on which a "rebuffering"
      * strategy will be considered:
      * The player will pause playback to get enough time building a sufficient
-     * buffer. This mostly happen when seeking in an unbuffered part or when
-     * buffering.
+     * buffer. This mostly happen when seeking in an unbuffered part or when not
+     * enough buffer is ahead of the current position.
      * @type {Number}
      */
-    STALL_GAP: {
+    REBUFFERING_GAP: {
         DEFAULT: 0.5,
         LOW_LATENCY: 0.2,
     },
+    /**
+     * Amount of time (in seconds) with data ahead of the current position, at
+     * which we always consider the browser to be able to play.
+     *
+     * If the media element has this amount of data in advance or more but
+     * playback cannot begin, the player will consider it "freezing".
+     */
+    MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING: 2,
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * If the media is still "freezing" after waiting for `UNFREEZING_SEEK_DELAY`
+     * milliseconds, the RxPlayer will try to un-freeze the situation by interacting
+     * with the media element.
+     *
+     * Those interactions can be costly in time before playback continue, so it
+     * should be set at a sufficiently high value to avoid false positives.
+     */
+    UNFREEZING_SEEK_DELAY: 6000,
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * A small freezing interval may be normal as the browser may take time before
+     * playing, e.g. after a seek.
+     *
+     * If the media is still "freezing" after waiting for `FREEZING_STALLED_DELAY`
+     * milliseconds, the RxPlayer will emit a BUFFERING state through its API to
+     * notify that the player cannot currently advance.
+     */
+    FREEZING_STALLED_DELAY: 600,
+    /**
+     * A media whose position inexplicably does not increment despite playing is
+     * called as "freezing" in the RxPlayer.
+     *
+     * If the media is frozen for a sufficiently large time
+     * (@see UNFREEZING_SEEK_DELAY), the RxPlayer will perform a seek corresponding
+     * to its current position plus `UNFREEZING_DELTA_POSITION` seconds.
+     *
+     * This should be kept short enough as the goal is just to un-freeze lower-level
+     * buffers.
+     */
+    UNFREEZING_DELTA_POSITION: 0.001,
     /**
      * Maximum authorized difference between what we calculated to be the
      * beginning or end of the segment in a media buffer and what we
@@ -1072,4 +1111,24 @@ export default {
      * and not significant from the media loss perspective.
      */
     DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR: 1 / 1000,
+    /**
+     * RxPlayer's media buffers have a linked history registering recent events
+     * that happened on those.
+     * The reason is to implement various heuristics in case of weird browser
+     * behavior.
+     *
+     * The `BUFFERED_HISTORY_RETENTION_TIME` is the minimum age an entry of
+     * that history can have before being removed from the history.
+     */
+    BUFFERED_HISTORY_RETENTION_TIME: 60000,
+    /**
+     * RxPlayer's media buffers have a linked history registering recent events
+     * that happened on those.
+     * The reason is to implement various heuristics in case of weird browser
+     * behavior.
+     *
+     * The `BUFFERED_HISTORY_RETENTION_TIME` is the maximum number of entries
+     * there can be in that history.
+     */
+    BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
 };

package/dist/_esm5.processed/core/abr/abr_manager.d.ts

@@ -15,9 +15,10 @@
  */
 import { Observable } from "rxjs";
 import { Representation } from "../../manifest";
+import { ISharedReference } from "../../utils/reference";
 import { IBufferType } from "../segment_buffers";
-import { IABREstimate, IABRStreamEvents, IRepresentationEstimatorClockTick } from "./representation_estimator";
-export declare type IABRManagerClockTick = IRepresentationEstimatorClockTick;
+import { IABREstimate, IABRStreamEvents, IRepresentationEstimatorPlaybackObservation } from "./representation_estimator";
+export declare type IABRManagerPlaybackObservation = IRepresentationEstimatorPlaybackObservation;
 interface IRepresentationEstimatorsThrottlers {
     limitWidth: Partial<Record<IBufferType, Observable<number>>>;
     throttle: Partial<Record<IBufferType, Observable<number>>>;
@@ -27,12 +28,12 @@ export interface IABRManagerArguments {
     initialBitrates: Partial<Record<IBufferType, // Initial bitrate chosen, per
     number>>;
     lowLatencyMode: boolean;
-    minAutoBitrates: Partial<Record<IBufferType, // Minimum bitrate chosen
-    Observable<number>>>;
-    maxAutoBitrates: Partial<Record<IBufferType, // Maximum bitrate chosen
-    Observable<number>>>;
-    manualBitrates: Partial<Record<IBufferType, // Manual bitrate set for
-    Observable<number>>>;
+    /** Minimum bitrate chosen when in auto mode, per type (0 by default) */
+    minAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+    /** Maximum bitrate chosen when in auto mode, per type (0 by default) */
+    maxAutoBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
+    /** Manually forced bitrate set for a given type (`-1` for auto mode */
+    manualBitrates: Partial<Record<IBufferType, ISharedReference<number>>>;
     throttlers: IRepresentationEstimatorsThrottlers;
 }
 /**
@@ -60,11 +61,11 @@ export default class ABRManager {
      * state).
      * @param {string} type
      * @param {Array.<Representation>} representations
-     * @param {Observable<Object>} clock$
+     * @param {Observable<Object>} observation$
      * @param {Observable<Object>} streamEvents$
      * @returns {Observable}
      */
-    get$(type: IBufferType, representations: Representation[], clock$: Observable<IABRManagerClockTick>, streamEvents$: Observable<IABRStreamEvents>): Observable<IABREstimate>;
+    get$(type: IBufferType, representations: Representation[], observation$: Observable<IABRManagerPlaybackObservation>, streamEvents$: Observable<IABRStreamEvents>): Observable<IABREstimate>;
     /**
      * @param {string} bufferType
      * @returns {Object}