rx-player 3.30.1-dev.2023032300 → 3.30.1-dev.2023032800

package/CHANGELOG.md

@@ -1,10 +1,16 @@
 # Changelog
 
-## v3.30.1 (2023-03-23)
+## v3.30.1-dev.2023032800 (2023-03-28)
 
 ### Bug fixes
 
-  - DASH: Fix issue which could lead to infinite rebuffering when switching between multiple Periods
+  - DASH: Fix issue which could lead to infinite rebuffering when switching between multiple Periods [#1232]
+  - Return actual ending duration through the `getVideoDuration` method when playing dynamic contents whose future end is already known [#1235]
+
+### Other improvements
+
+  - adaptive: Perform various adaptive tweaks to avoid switching too much between qualities in some conditions
+
 
 ## v3.30.0 (2023-03-07)
 

package/VERSION

@@ -1 +1 @@
-3.30.1-dev.2023032300
+3.30.1-dev.2023032800

package/dist/_esm5.processed/compat/eme/load_session.js

@@ -70,7 +70,7 @@ export default function loadSession(session, sessionId) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    log.info("Compat/DRM: Load persisted session", sessionId);
+                    log.info("DRM: Load persisted session", sessionId);
                     return [4 /*yield*/, session.load(sessionId)];
                 case 1:
                     isLoaded = _a.sent();

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

@@ -77,6 +77,8 @@ declare class ConfigHandler {
         SAMPLING_INTERVAL_MEDIASOURCE: number;
         SAMPLING_INTERVAL_LOW_LATENCY: number;
         SAMPLING_INTERVAL_NO_MEDIASOURCE: number;
+        ABR_ENTER_BUFFER_BASED_ALGO: number;
+        ABR_EXIT_BUFFER_BASED_ALGO: number;
         ABR_MINIMUM_TOTAL_BYTES: number;
         ABR_MINIMUM_CHUNK_SIZE: number;
         ABR_STARVATION_FACTOR: {

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import config from "../../config";
 import log from "../../log";
 import noop from "../../utils/noop";
 import { getLeftSizeOfRange } from "../../utils/ranges";
@@ -242,12 +243,13 @@ function getEstimateReference(_a, stopAllEstimates) {
                 stableRepresentation.bitrate / (lastPlaybackObservation.speed > 0 ?
                     lastPlaybackObservation.speed :
                     1);
-            if (allowBufferBasedEstimates && bufferGap <= 5) {
+            var _b = config.getCurrent(), ABR_ENTER_BUFFER_BASED_ALGO = _b.ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO = _b.ABR_EXIT_BUFFER_BASED_ALGO;
+            if (allowBufferBasedEstimates && bufferGap <= ABR_EXIT_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = false;
             }
             else if (!allowBufferBasedEstimates &&
                 isFinite(bufferGap) &&
-                bufferGap > 10) {
+                bufferGap >= ABR_ENTER_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = true;
             }
             /**

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.js

@@ -56,10 +56,10 @@ var BufferBasedChooser = /** @class */ (function () {
             return bitrates[0];
         }
         var scaledScore;
-        if (currentScore != null) {
+        if (currentScore !== undefined) {
             scaledScore = speed === 0 ? currentScore : (currentScore / speed);
         }
-        if (scaledScore != null && scaledScore > 1) {
+        if (scaledScore !== undefined && scaledScore > 1) {
             var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
             var nextIndex = (function () {
                 for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
@@ -68,14 +68,14 @@ var BufferBasedChooser = /** @class */ (function () {
                     }
                 }
             })();
-            if (nextIndex != null) {
+            if (nextIndex !== undefined) {
                 var nextBufferLevel = bufferLevels[nextIndex];
                 if (bufferGap >= nextBufferLevel) {
                     return bitrates[nextIndex];
                 }
             }
         }
-        if (scaledScore == null || scaledScore < 1.15) {
+        if (scaledScore === undefined || scaledScore < 1.15) {
             var currentBufferLevel = bufferLevels[currentBitrateIndex];
             if (bufferGap < currentBufferLevel) {
                 for (var i = currentBitrateIndex - 1; i >= 0; i--) {

package/dist/_esm5.processed/core/adaptive/network_analyzer.js

@@ -126,6 +126,12 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     }
     var concernedRequest = concernedRequests[0];
     var now = performance.now();
+    var minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
+    minimumRequestTime = Math.min(minimumRequestTime, 3000);
+    minimumRequestTime = Math.max(minimumRequestTime, 12000);
+    if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
+        return undefined;
+    }
     var lastProgressEvent = concernedRequest.progress.length > 0 ?
         concernedRequest.progress[concernedRequest.progress.length - 1] :
         undefined;
@@ -138,7 +144,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
             // Calculate estimated time spent rebuffering if we continue doing that request.
             var expectedRebufferingTime = remainingTime -
                 (realBufferGap / speed);
-            if (expectedRebufferingTime > 2000) {
+            if (expectedRebufferingTime > 2500) {
                 return bandwidthEstimate;
             }
         }
@@ -320,12 +326,9 @@ var NetworkAnalyzer = /** @class */ (function () {
         if (currentRepresentation === null) {
             return true;
         }
-        else if (bitrate === currentRepresentation.bitrate) {
+        else if (bitrate >= currentRepresentation.bitrate) {
             return false;
         }
-        else if (bitrate > currentRepresentation.bitrate) {
-            return !this._inStarvationMode;
-        }
         return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests, this._lowLatencyMode);
     };
     return NetworkAnalyzer;

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

@@ -114,6 +114,7 @@ var PlaybackObserver = /** @class */ (function () {
      */
     PlaybackObserver.prototype.setCurrentTime = function (time) {
         this._internalSeeksIncoming.push(time);
+        log.info("API: Seeking internally", time);
         this._mediaElement.currentTime = time;
     };
     /**

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

@@ -89,7 +89,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.30.1-dev.2023032300";
+        _this.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032800";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -1165,6 +1165,7 @@ var Player = /** @class */ (function (_super) {
         if (positionWanted === undefined) {
             throw new Error("invalid time given");
         }
+        log.info("API: API Seek to", positionWanted);
         this.videoElement.currentTime = positionWanted;
         return positionWanted;
     };
@@ -2339,5 +2340,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032300";
+Player.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032800";
 export default Player;

package/dist/_esm5.processed/core/decrypt/utils/clean_old_loaded_sessions.js

@@ -49,6 +49,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+import log from "../../../log";
 /**
  * Close sessions from the loadedSessionsStore to allow at maximum `limit`
  * stored MediaKeySessions in it.
@@ -67,6 +68,7 @@ export default function cleanOldLoadedSessions(loadedSessionsStore, limit) {
                     if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
                         return [2 /*return*/];
                     }
+                    log.info("DRM: LSS cache limit exceeded", limit, loadedSessionsStore.getLength());
                     proms = [];
                     entries = loadedSessionsStore.getAll().slice();
                     toDelete = entries.length - limit;

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.js

@@ -92,6 +92,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     LoadedSessionsStore.prototype.createSession = function (initData, sessionType) {
         var _this = this;
         var keySessionRecord = new KeySessionRecord(initData);
+        log.debug("DRM-LSS: calling `createSession`", sessionType);
         var mediaKeySession = this._mediaKeys.createSession(sessionType);
         var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord, isGeneratingRequest: false,
             isLoadingPersistentSession: false,
@@ -99,6 +100,7 @@ var LoadedSessionsStore = /** @class */ (function () {
         if (!isNullOrUndefined(mediaKeySession.closed)) {
             mediaKeySession.closed
                 .then(function () {
+                log.info("DRM-LSS: session was closed, removing it.", mediaKeySession.sessionId);
                 var index = _this.getIndex(keySessionRecord);
                 if (index >= 0 &&
                     _this._storage[index].mediaKeySession === mediaKeySession) {
@@ -110,8 +112,8 @@ var LoadedSessionsStore = /** @class */ (function () {
                 log.warn("DRM-LSS: MediaKeySession.closed rejected: ".concat(e));
             });
         }
-        log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
         this._storage.push(__assign({}, entry));
+        log.debug("DRM-LSS: MediaKeySession added", entry.sessionType, this._storage.length);
         return entry;
     };
     /**
@@ -132,6 +134,7 @@ var LoadedSessionsStore = /** @class */ (function () {
             if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
                 this._storage.splice(i, 1);
                 this._storage.push(stored);
+                log.debug("DRM-LSS: Reusing session:", stored.mediaKeySession.sessionId, stored.sessionType);
                 return __assign({}, stored);
             }
         }
@@ -365,6 +368,7 @@ var LoadedSessionsStore = /** @class */ (function () {
         for (var i = this._storage.length - 1; i >= 0; i--) {
             var stored = this._storage[i];
             if (stored.mediaKeySession === mediaKeySession) {
+                log.debug("DRM-LSS: Removing session without closing it", mediaKeySession.sessionId);
                 this._storage.splice(i, 1);
                 return true;
             }

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

@@ -87,7 +87,7 @@ import getInitialTime from "./utils/get_initial_time";
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaDurationUpdater from "./utils/media_duration_updater";
+import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
 import streamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -501,9 +501,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
     MediaSourceContentInitializer.prototype._createContentTimeBoundariesObserver = function (manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
         var _this = this;
         /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        var mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+        var mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
         cancelSignal.register(function () {
-            mediaDurationUpdater.stop();
+            mediaSourceDurationUpdater.stopUpdating();
         });
         /** Allows to cancel a pending `end-of-stream` operation. */
         var endOfStreamCanceller = null;
@@ -518,8 +518,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this.trigger("activePeriodChanged", { period: period });
         });
         contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-            log.debug("Init: Duration has to be updated.", newDuration);
-            mediaDurationUpdater.updateKnownDuration(newDuration);
+            mediaSourceDurationUpdater.updateDuration(newDuration.duration, !newDuration.isEnd);
         });
         contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
             if (endOfStreamCanceller === null) {
@@ -536,6 +535,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 endOfStreamCanceller = null;
             }
         });
+        var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+        mediaSourceDurationUpdater.updateDuration(currentDuration.duration, !currentDuration.isEnd);
         return contentTimeBoundariesObserver;
     };
     /**

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

@@ -55,6 +55,11 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
      * @param {Object} playbackObserver
      */
     constructor(manifest: Manifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    getCurrentDuration(): IDurationItem;
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,9 +126,31 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
     private _addActivelyLoadedPeriod;
     private _removeActivelyLoadedPeriod;
     private _checkCurrentPeriod;
+    private _getManifestDuration;
     private _lazilyCreateActiveStreamInfo;
     private _checkEndOfStream;
 }
+export interface IDurationItem {
+    /**
+     * The new maximum known position (note that this is the ending position
+     * currently known of the current content, it might be superior to the last
+     * position at which segments are available and it might also evolve over
+     * time), in seconds.
+     */
+    duration: number;
+    /**
+     * If `true`, the communicated `duration` is the actual end of the content.
+     * It may still be updated due to a track change or to add precision, but it
+     * is still a (rough) estimate of the maximum position that content should
+     * have.
+     *
+     * If `false`, this is the currently known maximum position associated to
+     * the content, but the content is still evolving (typically, new media
+     * segments are still being generated) and as such it can still have a
+     * longer duration in the future.
+     */
+    isEnd: boolean;
+}
 /**
  * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
  * event names and the value is the payload of those events.
@@ -137,7 +164,7 @@ export interface IContentTimeBoundariesObserverEvent {
      * Triggered when the duration of the currently-playing content became known
      * or changed.
      */
-    durationUpdate: number | undefined;
+    durationUpdate: IDurationItem;
     /**
      * Triggered when the last possible chronological segment for all types of
      * buffers has either been pushed or is being pushed to the corresponding

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

@@ -82,19 +82,21 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", function () {
-            _this.trigger("durationUpdate", getManifestDuration());
+            _this.trigger("durationUpdate", _this._getManifestDuration());
             if (cancelSignal.isCancelled()) {
                 return;
             }
             _this._checkEndOfStream();
         }, cancelSignal);
-        function getManifestDuration() {
-            return manifest.isDynamic ?
-                maximumPositionCalculator.getMaximumAvailablePosition() :
-                maximumPositionCalculator.getEndingPosition();
-        }
         return _this;
     }
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    ContentTimeBoundariesObserver.prototype.getCurrentDuration = function () {
+        return this._getManifestDuration();
+    };
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,9 +123,12 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                         this._maximumPositionCalculator
                             .updateLastVideoAdaptation(adaptation);
                     }
-                    var newDuration = this._manifest.isDynamic ?
-                        this._maximumPositionCalculator.getMaximumAvailablePosition() :
-                        this._maximumPositionCalculator.getEndingPosition();
+                    var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+                    var newDuration = endingPosition !== undefined ?
+                        { isEnd: true,
+                            duration: endingPosition } :
+                        { isEnd: false,
+                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
                     this.trigger("durationUpdate", newDuration);
                 }
             }
@@ -258,6 +263,14 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                 return state_1.value;
         }
     };
+    ContentTimeBoundariesObserver.prototype._getManifestDuration = function () {
+        var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+        return endingPosition !== undefined ?
+            { isEnd: true,
+                duration: endingPosition } :
+            { isEnd: false,
+                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+    };
     ContentTimeBoundariesObserver.prototype._lazilyCreateActiveStreamInfo = function (bufferType) {
         var streamInfo = this._activeStreams.get(bufferType);
         if (streamInfo === undefined) {

package/dist/_esm5.processed/core/init/utils/media_source_duration_updater.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
+ */
+export default class MediaSourceDurationUpdater {
+    /**
+     * `MediaSource` on which we're going to update the `duration` attribute.
+     */
+    private _mediaSource;
+    /**
+     * Abort the current duration-setting logic.
+     * `null` if no such logic is pending.
+     */
+    private _currentMediaSourceDurationUpdateCanceller;
+    /**
+     * Create a new `MediaSourceDurationUpdater`,
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * played.
+     */
+    constructor(mediaSource: MediaSource);
+    /**
+     * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+     * of the content.
+     *
+     * The `MediaSourceDurationUpdater` will then use that value to determine
+     * which `duration` attribute should be set on the `MediaSource` associated
+     *
+     * @param {number} newDuration
+     * @param {boolean} addTimeMargin - If set to `true`, the current content is
+     * a dynamic content (it might evolve in the future) and the `newDuration`
+     * communicated might be greater still. In effect the
+     * `MediaSourceDurationUpdater` will actually set a much higher value to the
+     * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+     * side-effects of having a too low duration (such as the impossibility to
+     * seek over that value).
+     */
+    updateDuration(newDuration: number, addTimeMargin: boolean): void;
+    /**
+     * Abort the last duration-setting operation and free its resources.
+     */
+    stopUpdating(): void;
+}