rx-player 3.33.0-dev.2023120600 → 3.33.0

package/dist/_esm5.processed/core/segment_buffers/inventory/segment_inventory.js

@@ -49,9 +49,15 @@ var SegmentInventory = /** @class */ (function () {
      * at a time, so each `synchronizeBuffered` call should be given a TimeRanges
      * coming from the same buffer.
      * @param {TimeRanges} buffered
+     * @param {boolean|undefined} [skipLog=false] - This method normally may
+     * trigger a voluminous debug log if debug logs are enabled.
+     * As this method might be called very often in some specific debugging
+     * situations, setting this value to `true` allows to prevent the call from
+     * triggering a log.
      */
-    SegmentInventory.prototype.synchronizeBuffered = function (buffered) {
+    SegmentInventory.prototype.synchronizeBuffered = function (buffered, skipLog) {
         var _a, _b, _c, _d, _e, _f, _g;
+        if (skipLog === void 0) { skipLog = false; }
         var inventory = this._inventory;
         var inventoryIndex = 0; // Current index considered.
         var thisSegment = inventory[0]; // Current segmentInfos considered
@@ -97,7 +103,9 @@ var SegmentInventory = /** @class */ (function () {
                 var removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
                 for (var _i = 0, removed_1 = removed; _i < removed_1.length; _i++) {
                     var seg = removed_1[_i];
-                    if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+                    if (seg.bufferedStart === undefined &&
+                        seg.bufferedEnd === undefined &&
+                        seg.status !== 2 /* ChunkStatus.Failed */) {
                         this._bufferedHistory.addBufferedSegment(seg.infos, null);
                     }
                 }
@@ -156,12 +164,14 @@ var SegmentInventory = /** @class */ (function () {
             var removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
             for (var _h = 0, removed_2 = removed; _h < removed_2.length; _h++) {
                 var seg = removed_2[_h];
-                if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+                if (seg.bufferedStart === undefined &&
+                    seg.bufferedEnd === undefined &&
+                    seg.status !== 2 /* ChunkStatus.Failed */) {
                     this._bufferedHistory.addBufferedSegment(seg.infos, null);
                 }
             }
         }
-        if (bufferType !== undefined && log.hasLevel("DEBUG")) {
+        if (!skipLog && bufferType !== undefined && log.hasLevel("DEBUG")) {
             log.debug("SI: current ".concat(bufferType, " inventory timeline:\n") +
                 prettyPrintInventory(this._inventory));
         }
@@ -173,7 +183,7 @@ var SegmentInventory = /** @class */ (function () {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    SegmentInventory.prototype.insertChunk = function (_a) {
+    SegmentInventory.prototype.insertChunk = function (_a, succeed) {
         var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, chunkSize = _a.chunkSize, start = _a.start, end = _a.end;
         if (segment.isInit) {
             return;
@@ -184,7 +194,8 @@ var SegmentInventory = /** @class */ (function () {
             return;
         }
         var inventory = this._inventory;
-        var newSegment = { partiallyPushed: true, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
+        var newSegment = { status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ :
+                2 /* ChunkStatus.Failed */, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
@@ -377,7 +388,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
                             log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
-                            var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                            var nextSegment = { status: segmentI.status,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -535,7 +546,9 @@ var SegmentInventory = /** @class */ (function () {
                     this._inventory.splice(firstI + 1, length_1);
                     i -= length_1;
                 }
-                this._inventory[firstI].partiallyPushed = false;
+                if (this._inventory[firstI].status === 0 /* ChunkStatus.PartiallyPushed */) {
+                    this._inventory[firstI].status = 1 /* ChunkStatus.Complete */;
+                }
                 this._inventory[firstI].chunkSize = segmentSize;
                 this._inventory[firstI].end = lastEnd;
                 this._inventory[firstI].bufferedEnd = lastBufferedEnd;
@@ -551,8 +564,10 @@ var SegmentInventory = /** @class */ (function () {
             for (var _i = 0, resSegments_1 = resSegments; _i < resSegments_1.length; _i++) {
                 var seg = resSegments_1[_i];
                 if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
-                    this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
-                        end: seg.bufferedEnd });
+                    if (seg.status !== 2 /* ChunkStatus.Failed */) {
+                        this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
+                            end: seg.bufferedEnd });
+                    }
                 }
                 else {
                     log.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
@@ -597,7 +612,7 @@ export default SegmentInventory;
  */
 function bufferedStartLooksCoherent(thisSegment) {
     if (thisSegment.bufferedStart === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;
@@ -618,7 +633,7 @@ function bufferedStartLooksCoherent(thisSegment) {
  */
 function bufferedEndLooksCoherent(thisSegment) {
     if (thisSegment.bufferedEnd === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     var start = thisSegment.start, end = thisSegment.end;

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -125,23 +125,22 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
 export default function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
     var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
-    var _a = config.getCurrent(), MAXIMUM_MAX_BUFFER_AHEAD = _a.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _a.MAXIMUM_MAX_BUFFER_BEHIND;
+    var _a = config.getCurrent(), MINIMUM_MAX_BUFFER_AHEAD = _a.MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD = _a.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _a.MAXIMUM_MAX_BUFFER_BEHIND;
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
     var garbageCollectors = new WeakMapMemory(function (segmentBuffer) {
+        var _a, _b;
         var bufferType = segmentBuffer.bufferType;
-        var defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_BEHIND[bufferType] :
-            Infinity;
-        var defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_AHEAD[bufferType] :
-            Infinity;
+        var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
+        var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return function (gcCancelSignal) {
             BufferGarbageCollector({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: createMappedReference(maxBufferBehind, function (val) {
                     return Math.min(val, defaultMaxBehind);
                 }, gcCancelSignal),
                 maxBufferAhead: createMappedReference(maxBufferAhead, function (val) {
-                    return Math.min(val, defaultMaxAhead);
+                    var _a;
+                    var lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
+                    return Math.min(lowerBound, maxAheadHigherBound);
                 }, gcCancelSignal) }, gcCancelSignal);
         };
     });
@@ -195,6 +194,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             var nextPeriod = (_c = manifest.getPeriodForTime(time)) !== null && _c !== void 0 ? _c : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
                 log.warn("Stream: The wanted position is not found in the Manifest.");
+                enableOutOfBoundsCheck = true;
                 return;
             }
             launchConsecutiveStreamsForPeriod(nextPeriod);
@@ -258,7 +258,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         }
         /**
          * React to a Manifest's decipherability updates.
-         * @param {Array.<Object>}
+         * @param {Array.<Object>} updates
          * @returns {Promise}
          */
         function onDecipherabilityUpdates(updates) {
@@ -400,8 +400,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         playbackObserver.listen(function (_a, stopListeningObservations) {
             var _b, _c;
             var position = _a.position;
-            if (basePeriod.end !== undefined &&
-                ((_b = position.pending) !== null && _b !== void 0 ? _b : position.last) >= basePeriod.end) {
+            var wantedPosition = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;
+            if (basePeriod.end !== undefined && wantedPosition >= basePeriod.end) {
+                var nextPeriod = manifest.getPeriodAfter(basePeriod);
+                // Handle special wantedPosition === basePeriod.end cases
+                if (basePeriod.containsTime(wantedPosition, nextPeriod)) {
+                    return;
+                }
                 log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_c = position.pending) !== null && _c !== void 0 ? _c : position.last, basePeriod.end);
                 stopListeningObservations();
                 consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,

package/dist/_esm5.processed/core/stream/representation/utils/get_buffer_status.js

@@ -163,7 +163,8 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
  */
 function isPeriodTheCurrentAndLastOne(manifest, period, time) {
     var _a;
-    return period.containsTime(time) &&
+    var nextPeriod = manifest.getPeriodAfter(period);
+    return period.containsTime(time, nextPeriod) &&
         manifest.isLastPeriodKnown &&
         period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id);
 }
@@ -184,7 +185,7 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
     for (var i = segmentInventory.length - 1; i >= 0; i--) {
         var eltInventory = segmentInventory[i];
         var representation = eltInventory.infos.representation;
-        if (!eltInventory.partiallyPushed &&
+        if (eltInventory.status === 1 /* ChunkStatus.Complete */ &&
             representation.decipherable !== false &&
             representation.isSupported) {
             var inventorySegment = eltInventory.infos.segment;

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

@@ -179,6 +179,13 @@ declare const DEFAULT_CONFIG: {
      * @type {Object}
      */
     MAXIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
+    /**
+     * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+     * Collecting too much data when it would have adverse effects.
+     * Equal to `0` if not defined here.
+     * @type {Object}
+     */
+    MINIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
     /**
      * Maximum possible buffer behind for each type of buffer, to avoid too much
      * memory usage when playing for a long time.

package/dist/_esm5.processed/default_config.js

@@ -182,6 +182,22 @@ var DEFAULT_CONFIG = {
     },
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
+    /**
+     * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+     * Collecting too much data when it would have adverse effects.
+     * Equal to `0` if not defined here.
+     * @type {Object}
+     */
+    MINIMUM_MAX_BUFFER_AHEAD: {
+        // Text segments are both much lighter on resources and might
+        // actually be much larger than other types of segments in terms
+        // of duration. Let's make an exception here by authorizing a
+        // larger text buffer ahead, to avoid unnecesarily reloading the
+        // same text track.
+        text: 2 * 60,
+    },
+    /* eslint-enable @typescript-eslint/consistent-type-assertions */
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     /**
      * Maximum possible buffer behind for each type of buffer, to avoid too much
      * memory usage when playing for a long time.

package/dist/_esm5.processed/manifest/manifest.js

@@ -132,10 +132,14 @@ var Manifest = /** @class */ (function (_super) {
      * @returns {Object|undefined}
      */
     Manifest.prototype.getPeriodForTime = function (time) {
-        return arrayFind(this.periods, function (period) {
-            return time >= period.start &&
-                (period.end === undefined || period.end > time);
-        });
+        var nextPeriod = null;
+        for (var i = this.periods.length - 1; i >= 0; i--) {
+            var period = this.periods[i];
+            if (period.containsTime(time, nextPeriod)) {
+                return period;
+            }
+            nextPeriod = period;
+        }
     };
     /**
      * Returns the first Period starting strictly after the given time.

package/dist/_esm5.processed/manifest/period.d.ts

@@ -68,7 +68,9 @@ export default class Period {
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    containsTime(time: number): boolean;
+    containsTime(time: number, nextPeriod: Period | null): boolean;
 }

package/dist/_esm5.processed/manifest/period.js

@@ -130,11 +130,24 @@ var Period = /** @class */ (function () {
     /**
      * Returns true if the give time is in the time boundaries of this `Period`.
      * @param {number} time
+     * @param {object|null} nextPeriod - Period coming chronologically just
+     * after in the same Manifest. `null` if this instance is the last `Period`.
      * @returns {boolean}
      */
-    Period.prototype.containsTime = function (time) {
-        return time >= this.start && (this.end === undefined ||
-            time < this.end);
+    Period.prototype.containsTime = function (time, nextPeriod) {
+        if (time >= this.start && (this.end === undefined || time < this.end)) {
+            return true;
+        }
+        else if (time === this.end && (nextPeriod === null ||
+            nextPeriod.start > this.end)) {
+            // The last possible timed position of a Period is ambiguous as it is
+            // frequently in common with the start of the next one: is it part of
+            // the current or of the next Period?
+            // Here we only consider it part of the current Period if it is the
+            // only one with that position.
+            return true;
+        }
+        return false;
     };
     return Period;
 }());

package/dist/rx-player.d.ts

@@ -1,3 +1,3 @@
 
-import RxPlayer from "./_esm5.processed/index";
+import RxPlayer from "./_esm5.processed/core/api/index";
 export default RxPlayer;