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

package/dist/commonjs/manifest/adaptation.js

@@ -82,7 +82,8 @@ var Adaptation = /** @class */ (function () {
                 var reprObject = {
                     id: representation.id,
                     bitrate: representation.bitrate,
-                    codec: representation.codec,
+                    codecs: representation.codec === undefined ? [] :
+                        [representation.codec],
                     height: representation.height,
                     width: representation.width,
                     frameRate: representation.frameRate,

package/dist/commonjs/parsers/texttracks/ttml/html/apply_line_height.js

@@ -24,10 +24,11 @@ var regexps_1 = require("../regexps");
  */
 function applyLineHeight(element, lineHeight) {
     var trimmedLineHeight = lineHeight.trim();
+    var splittedLineHeight = trimmedLineHeight.split(" ");
     if (trimmedLineHeight === "auto") {
         return;
     }
-    var firstLineHeight = regexps_1.REGXP_LENGTH.exec(trimmedLineHeight[0]);
+    var firstLineHeight = regexps_1.REGXP_LENGTH.exec(splittedLineHeight[0]);
     if (firstLineHeight === null) {
         return;
     }

package/dist/commonjs/public_types.d.ts

@@ -137,8 +137,35 @@ export interface IRepresentationFilterRepresentation {
     /** String identifying the Representation, unique per Adaptation. */
     id: string;
     bitrate?: number | undefined;
-    /** Codec used by the media segments of that Representation. */
-    codec?: string | undefined;
+    /**
+     * Codec(s) relied on by the media segments of that Representation.
+     *
+     * For the great majority of cases, this value will be set to either
+     * `undefined` (meaning the codec is unknown) or to an array with a
+     * single element which will be the actual codec relied on when the
+     * corresponding Representation will be played.
+     *
+     * However in some very rare scenarios, this value might be set to an array
+     * with multiple codecs, itself being a list of its candidate codecs from the
+     * most wanted to the most compatible.
+     * The conditions for this more complex format are very specific:
+     *
+     *   - It can only happen if the `representationFilter` callback is called in
+     *     an environment where it hasn't yet been possible for the RxPlayer to
+     *     check for codec support (mainly when running through the RxPlayer's
+     *     `MULTI_THREAD` feature in a browser without MSE-in-worker
+     *     capabilities).
+     *
+     *   - The corresponding Representation is compatible to a restrictive codec
+     *     yet also retro-compatible to a less restrictive one.
+     *
+     *     The main example being Dolby Vision Representations which are
+     *     retro-compatible to HDR10 HEVC codecs.
+     *     In that very specific case, we could have an array with two elements:
+     *       1. The Dolby Vision codec
+     *       2. The base HDR10 codec
+     */
+    codecs?: string[] | undefined;
     /**
      * This property makes the most sense for video Representations.
      * It defines the height of the video, in pixels.

package/dist/es2017/config.d.ts

@@ -36,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;
@@ -46,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/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/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`.