rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

package/dist/es2017/config.d.ts

@@ -18,6 +18,7 @@ declare class ConfigHandler {
     _config: {
         DEFAULT_UNMUTED_VOLUME: number;
         DEFAULT_REQUEST_TIMEOUT: number;
+        DEFAULT_CONNECTION_TIMEOUT: number;
         DEFAULT_TEXT_TRACK_MODE: "native" | "html";
         DEFAULT_ENABLE_FAST_SWITCHING: boolean;
         DELTA_POSITION_AFTER_RELOAD: {
@@ -35,6 +36,7 @@ declare class ConfigHandler {
         DEFAULT_MAX_BUFFER_BEHIND: number;
         DEFAULT_MAX_VIDEO_BUFFER_SIZE: number;
         MAXIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "text", number>>;
+        MINIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
         MAXIMUM_MAX_BUFFER_BEHIND: Partial<Record<"audio" | "video" | "text", number>>;
         DEFAULT_BASE_BANDWIDTH: number;
         INACTIVITY_DELAY: number;
@@ -45,7 +47,6 @@ declare class ConfigHandler {
             LOW_LATENCY: number;
         };
         BUFFER_DISCONTINUITY_THRESHOLD: number;
-        FORCE_DISCONTINUITY_SEEK_DELAY: number;
         BITRATE_REBUFFERING_RATIO: number;
         BUFFER_GC_GAPS: {
             CALM: number;

package/dist/es2017/core/adaptive/adaptive_representation_selector.d.ts

@@ -16,7 +16,7 @@
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../manifest";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { IReadOnlyPlaybackObserver } from "../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
 import BandwidthEstimator from "./utils/bandwidth_estimator";
 import { IResolutionInfo } from "./utils/filter_by_resolution";
@@ -99,24 +99,7 @@ export interface IRepresentationEstimatorPlaybackObservation {
      * Information on the current media position in seconds at the time of a
      * Playback Observation.
      */
-    position: {
-        /**
-         * Known position at the time the Observation was emitted, in seconds.
-         *
-         * Note that it might have changed since. If you want truly precize
-         * information, you should recuperate it from the HTMLMediaElement directly
-         * through another mean.
-         */
-        last: number;
-        /**
-         * Actually wanted position in seconds that is not yet reached.
-         *
-         * This might for example be set to the initial position when the content is
-         * loading (and thus potentially at a `0` position) but which will be seeked
-         * to a given position once possible.
-         */
-        pending: number | undefined;
-    };
+    position: IObservationPosition;
     /**
      * Last "playback rate" set by the user. This is the ideal "playback rate" at
      * which the media should play.

package/dist/es2017/core/adaptive/adaptive_representation_selector.js

@@ -197,7 +197,7 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
             }
             const { position, speed } = lastPlaybackObservation;
             const timeRanges = val.buffered;
-            const bufferGap = getLeftSizeOfBufferedTimeRange(timeRanges, position.last);
+            const bufferGap = getLeftSizeOfBufferedTimeRange(timeRanges, position.getWanted());
             const { representation } = val.content;
             const currentScore = scoreCalculator.getEstimate(representation);
             const currentBitrate = representation.bitrate;
@@ -288,7 +288,7 @@ function getEstimateReference({ bandwidthEstimator, context, currentRepresentati
             if (lowLatencyMode &&
                 currentRepresentationVal !== null &&
                 context.manifest.isDynamic &&
-                maximumPosition - position.last < 40) {
+                maximumPosition - position.getWanted() < 40) {
                 chosenRepFromGuessMode = guessBasedChooser
                     .getGuess(sortedRepresentations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
             }

package/dist/es2017/core/adaptive/network_analyzer.js

@@ -120,7 +120,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     const { bufferGap, speed, position } = playbackInfo;
     const realBufferGap = isFinite(bufferGap) ? bufferGap :
         0;
-    const nextNeededPosition = position.last + realBufferGap;
+    const nextNeededPosition = position.getWanted() + realBufferGap;
     const concernedRequests = getConcernedRequests(pendingRequests, nextNeededPosition);
     if (concernedRequests.length !== 1) { // 0  == no request
         // 2+ == too complicated to calculate
@@ -188,7 +188,7 @@ function shouldDirectlySwitchToLowBitrate(playbackInfo, requests, lowLatencyMode
     }
     const realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
         0;
-    const nextNeededPosition = playbackInfo.position.last + realBufferGap;
+    const nextNeededPosition = playbackInfo.position.getWanted() + realBufferGap;
     const nextRequest = arrayFind(requests, ({ content }) => content.segment.duration > 0 &&
         (content.segment.time + content.segment.duration) > nextNeededPosition);
     if (nextRequest === undefined) {
@@ -261,7 +261,7 @@ export default class NetworkAnalyzer {
         const { ABR_STARVATION_DURATION_DELTA } = config.getCurrent();
         // check if should get in/out of starvation mode
         if (isNaN(duration) ||
-            realBufferGap + position.last < duration - ABR_STARVATION_DURATION_DELTA) {
+            realBufferGap + position.getWanted() < duration - ABR_STARVATION_DURATION_DELTA) {
             if (!this._inStarvationMode && realBufferGap <= localConf.starvationGap) {
                 log.info("ABR: enter starvation mode.");
                 this._inStarvationMode = true;

package/dist/es2017/core/api/debug/buffer_graph.js

@@ -1,4 +1,4 @@
-const BUFFER_WIDTH_IN_SECONDS = 10000;
+const BUFFER_WIDTH_IN_SECONDS = 30 * 60;
 const COLORS = [
     "#2ab7ca",
     "#fed766",
@@ -65,11 +65,7 @@ export default class SegmentBufferGraph {
         let minimumPosition;
         let maximumPosition;
         if (maximumPoint - minimumPoint > BUFFER_WIDTH_IN_SECONDS) {
-            if (currentTime === undefined) {
-                minimumPosition = minimumPoint;
-                maximumPosition = maximumPoint;
-            }
-            else if (maximumPoint - currentTime < BUFFER_WIDTH_IN_SECONDS / 2) {
+            if (maximumPoint - currentTime < BUFFER_WIDTH_IN_SECONDS / 2) {
                 maximumPosition = maximumPoint;
                 minimumPosition = maximumPoint - BUFFER_WIDTH_IN_SECONDS;
             }

package/dist/es2017/core/api/debug/modules/general_info.js

@@ -141,23 +141,30 @@ export default function constructDebugGeneralInfo(instance, parentElt, cancelSig
                 ]);
                 adaptationsElt.appendChild(textAdaps);
             }
-            const videoBitrates = (_c = (_b = instance.getVideoTrack()) === null || _b === void 0 ? void 0 : _b.representations.map(r => {
-                return r.bitrate;
-            }).filter(bitrate => bitrate !== undefined)) !== null && _c !== void 0 ? _c : [];
-            const audioBitrates = (_e = (_d = instance.getAudioTrack()) === null || _d === void 0 ? void 0 : _d.representations.map(r => {
-                return r.bitrate;
-            }).filter(bitrate => bitrate !== undefined)) !== null && _e !== void 0 ? _e : [];
+            const adaptations = instance.__priv_getCurrentAdaptation();
+            const videoBitratesStr = (_c = (_b = adaptations === null || adaptations === void 0 ? void 0 : adaptations.video) === null || _b === void 0 ? void 0 : _b.representations.map((r) => {
+                var _a;
+                return String((_a = r.bitrate) !== null && _a !== void 0 ? _a : "N/A") +
+                    (r.isSupported ? "" : " U!") +
+                    (r.decipherable !== false ? "" : " E!");
+            })) !== null && _c !== void 0 ? _c : [];
+            const audioBitratesStr = (_e = (_d = adaptations === null || adaptations === void 0 ? void 0 : adaptations.video) === null || _d === void 0 ? void 0 : _d.representations.map((r) => {
+                var _a;
+                return String((_a = r.bitrate) !== null && _a !== void 0 ? _a : "N/A") +
+                    (r.isSupported ? "" : " U!") +
+                    (r.decipherable !== false ? "" : " E!");
+            })) !== null && _e !== void 0 ? _e : [];
             representationsElt.innerHTML = "";
-            if (videoBitrates.length > 0) {
+            if (videoBitratesStr.length > 0) {
                 representationsElt.appendChild(createMetricTitle("vb"));
                 representationsElt.appendChild(createElement("span", {
-                    textContent: videoBitrates.join(" ") + " ",
+                    textContent: videoBitratesStr.join(" ") + " ",
                 }));
             }
-            if (audioBitrates.length > 0) {
+            if (audioBitratesStr.length > 0) {
                 representationsElt.appendChild(createMetricTitle("ab"));
                 representationsElt.appendChild(createElement("span", {
-                    textContent: audioBitrates.join(" ") + " ",
+                    textContent: audioBitratesStr.join(" ") + " ",
                 }));
             }
         }

package/dist/es2017/core/api/index.d.ts

@@ -16,5 +16,5 @@
 import PlaybackObserver from "./playback_observer";
 import Player from "./public_api";
 export { PlaybackObserver };
-export { IPlaybackObservation, IPlaybackObserverEventType, IReadOnlyPlaybackObserver, IFreezingStatus, IRebufferingStatus, } from "./playback_observer";
+export { IObservationPosition, IPlaybackObservation, IPlaybackObserverEventType, IReadOnlyPlaybackObserver, IFreezingStatus, IRebufferingStatus, } from "./playback_observer";
 export default Player;

package/dist/es2017/core/api/option_utils.d.ts

@@ -23,6 +23,8 @@ export type IParsedStartAtOption = {
     percentage: number;
 } | {
     fromLastPosition: number;
+} | {
+    fromLivePosition: number;
 } | {
     fromFirstPosition: number;
 };

package/dist/es2017/core/api/option_utils.js

@@ -259,9 +259,8 @@ function parseLoadVideoOptions(options) {
             "an \"html\" textTrackMode. It will be ignored.");
     }
     if (!isNullOrUndefined(options.startAt)) {
-        // TODO Better way to express that in TypeScript?
-        if (options.startAt.wallClockTime
-            instanceof Date) {
+        if ("wallClockTime" in options.startAt
+            && options.startAt.wallClockTime instanceof Date) {
             const wallClockTime = options.startAt
                 .wallClockTime.getTime() / 1000;
             startAt = objectAssign({}, options.startAt, { wallClockTime });

package/dist/es2017/core/api/playback_observer.d.ts

@@ -39,6 +39,13 @@ export default class PlaybackObserver {
      * influence on some chosen interval values here.
      */
     private _lowLatencyMode;
+    /**
+     * If set, position which could not yet be seeked to as the HTMLMediaElement
+     * had a readyState of `0`.
+     * This position should be seeked to as soon as the HTMLMediaElement is able
+     * to handle it.
+     */
+    private _pendingSeek;
     /**
      * The RxPlayer usually wants to differientate when a seek was sourced from
      * the RxPlayer's internal logic vs when it was sourced from an outside
@@ -64,6 +71,21 @@ export default class PlaybackObserver {
      * observations.
      */
     private _canceller;
+    /**
+     * On some devices (right now only seen on Tizen), seeking through the
+     * `currentTime` property can lead to the browser re-seeking once the
+     * segments have been loaded to improve seeking performances (for
+     * example, by seeking right to an intra video frame).
+     * In that case, we risk being in a conflict with that behavior: if for
+     * example we encounter a small discontinuity at the position the browser
+     * seeks to, we will seek over it, the browser would seek back and so on.
+     *
+     * This variable allows to store the maximum known position we were seeking to
+     * so we can detect when the browser seeked back (to avoid performing another
+     * seek after that). When browsers seek back to a position behind a
+     * discontinuity, they are usually able to skip them without our help.
+     */
+    private _expectedSeekingPosition;
     /**
      * Create a new `PlaybackObserver`, which allows to produce new "playback
      * observations" on various media events and intervals.
@@ -164,18 +186,22 @@ export default class PlaybackObserver {
      * @returns {Object}
      */
     deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    private _actuallySetCurrentTime;
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
      * observations.
      * @returns {Object}
      */
     private _createSharedReference;
-    private _generateInitialObservation;
+    private _getCurrentObservation;
+    private _generateObservationForEvent;
 }
 /** "Event" that triggered the playback observation. */
 export type IPlaybackObserverEventType = 
 /** First playback observation automatically emitted. */
-"init" | // set once on first emit
+"init" | 
+/** Observation manually forced by the PlaybackObserver. */
+"manual" | 
 /** Regularly emitted playback observation when no event happened in a long time. */
 "timeupdate" | 
 /** On the HTML5 event with the same name */
@@ -236,8 +262,18 @@ interface IMediaInfos {
     readyState: number;
     /** Current `seeking` value on the mediaElement. */
     seeking: boolean;
-    /** Event that triggered this playback observation. */
-    event: IPlaybackObserverEventType;
+}
+/** Categorize a pending seek operation. */
+export declare const enum SeekingState {
+    /** We're not currently seeking. */
+    None = 0,
+    /**
+     * We're currently seeking due to an internal logic of the RxPlayer (e.g.
+     * discontinuity skipping).
+     */
+    Internal = 1,
+    /** We're currently seeking due to a regular seek wanted by the application. */
+    External = 2
 }
 /**
  * Describes when the player is "rebuffering" and what event started that
@@ -277,7 +313,16 @@ export interface IFreezingStatus {
     timestamp: number;
 }
 /** Information emitted on each playback observation. */
-export interface IPlaybackObservation extends IMediaInfos {
+export interface IPlaybackObservation extends Omit<IMediaInfos, "position" | "seeking"> {
+    /** Event that triggered this playback observation. */
+    event: IPlaybackObserverEventType;
+    /** Current seeking state. */
+    seeking: SeekingState;
+    /**
+     * Information on the current position being played, the position for which
+     * media is wanted etc.
+     */
+    position: IObservationPosition;
     /**
      * Set if the player is short on audio and/or video media data and is a such,
      * rebuffering.
@@ -292,11 +337,86 @@ export interface IPlaybackObservation extends IMediaInfos {
      * `null` if the player is not frozen.
      */
     freezing: IFreezingStatus | null;
+}
+export type IObservationPosition = ObservationPosition;
+declare class ObservationPosition {
+    /**
+     * Known position at the time the Observation was emitted, in seconds.
+     *
+     * Note that it might have changed since. If you want truly precize
+     * information, you should recuperate it from the HTMLMediaElement directly
+     * through another mean.
+     */
+    private _last;
+    /**
+     * Actually wanted position in seconds that is not yet reached.
+     *
+     * This might for example be set to the initial position when the content is
+     * loading (and thus potentially at a `0` position) but which will be seeked
+     * to a given position once possible. It may also be the position of a seek
+     * that has not been properly accounted for by the current device.
+     */
+    private _wanted;
+    constructor(last: number, wanted: number | null);
+    /**
+     * Returns the playback position actually observed on the media element at
+     * the time the playback observation was made.
+     *
+     * Note that it may be different than the position for which media data is
+     * wanted in rare scenarios where the goal position is not yet set on the
+     * media element.
+     *
+     * You should use this value when you want to obtain the actual position set
+     * on the media element for browser compatibility purposes. Note that this
+     * position was calculated at observation time, it might thus not be
+     * up-to-date if what you want is milliseconds-accuracy.
+     *
+     * If what you want is the actual position which the player is intended to
+     * play, you should rely on `getWanted` instead`.
+     * @returns {number}
+     */
+    getPolled(): number;
+    /**
+     * Returns the position which the player should consider to load media data
+     * at the time the observation was made.
+     *
+     * It can be different than the value returned by `getPolled` in rare
+     * scenarios:
+     *
+     *   - When the initial position has not been set yet.
+     *
+     *   - When the current device do not let the RxPlayer peform precize seeks,
+     *     usually for perfomance reasons by seeking to a previous IDR frame
+     *     instead (for now only Tizen may be like this), in which case we
+     *     prefer to generally rely on the position wanted by the player (this
+     *     e.g. prevents issues where the RxPlayer logic and the device are
+     *     seeking back and forth in a loop).
+     *
+     *   - When a wanted position has been "forced" (@see forceWantedPosition).
+     * @returns {number}
+     */
+    getWanted(): number;
+    /**
+     * Method to call if you want to overwrite the currently wanted position.
+     * @param {number} pos
+     */
+    forceWantedPosition(pos: number): void;
     /**
-     * If `true`, an "internal seek" (a seeking operation triggered by the
-     * RxPlayer code) is currently pending.
+     * Returns `true` when the position wanted returned by `getWanted` and the
+     * actual position returned by `getPolled` may be different, meaning that
+     * we're currently not at the position we want to reach.
+     *
+     * This is a relatively rare situation which only happens when either the
+     * initial seek has not yet been performed. on specific targets where the
+     * seeking behavior is a little broken (@see getWanted) or when the wanted
+     * position has been forced (@see forceWantedPosition).
+     *
+     * In those situations, you might temporarily refrain from acting upon the
+     * actual current media position, as it may change soon.
+     *
+     * @returns {boolean}
      */
-    pendingInternalSeek: number | null;
+    isAwaitingFuturePosition(): boolean;
 }
 /**
  * Interface providing a generic and read-only version of a `PlaybackObserver`.