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

package/dist/es2017/core/segment_buffers/inventory/segment_inventory.js

@@ -96,7 +96,9 @@ export default class SegmentInventory {
                 log.debug(`SI: ${numberOfSegmentToDelete} segments GCed.`, bufferType);
                 const removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
                 for (const seg of removed) {
-                    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);
                     }
                 }
@@ -154,7 +156,9 @@ export default class SegmentInventory {
             log.debug("SI: last segments have been GCed", bufferType, inventoryIndex, inventory.length);
             const removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
             for (const seg of removed) {
-                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);
                 }
             }
@@ -171,7 +175,7 @@ export default class SegmentInventory {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }) {
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }, succeed) {
         if (segment.isInit) {
             return;
         }
@@ -181,7 +185,8 @@ export default class SegmentInventory {
             return;
         }
         const inventory = this._inventory;
-        const newSegment = { partiallyPushed: true,
+        const newSegment = { status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ :
+                2 /* ChunkStatus.Failed */,
             chunkSize,
             splitted: false,
             start,
@@ -379,7 +384,7 @@ export default class SegmentInventory {
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
                             log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
-                            const nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                            const nextSegment = { status: segmentI.status,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -537,7 +542,9 @@ export default class SegmentInventory {
                     this._inventory.splice(firstI + 1, length);
                     i -= length;
                 }
-                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;
@@ -552,8 +559,10 @@ export default class SegmentInventory {
             this.synchronizeBuffered(newBuffered);
             for (const seg of resSegments) {
                 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);
@@ -596,7 +605,7 @@ export default class SegmentInventory {
  */
 function bufferedStartLooksCoherent(thisSegment) {
     if (thisSegment.bufferedStart === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     const { start, end } = thisSegment;
@@ -617,7 +626,7 @@ function bufferedStartLooksCoherent(thisSegment) {
  */
 function bufferedEndLooksCoherent(thisSegment) {
     if (thisSegment.bufferedEnd === undefined ||
-        thisSegment.partiallyPushed) {
+        thisSegment.status !== 1 /* ChunkStatus.Complete */) {
         return false;
     }
     const { start, end } = thisSegment;

package/dist/es2017/core/stream/adaptation/get_representations_switch_strategy.d.ts

@@ -16,8 +16,8 @@
 import { Adaptation, Period } from "../../../manifest";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationsChoice } from "../representation";
-export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<unknown>): IRepresentationSwitchStrategy;
+import { IRepresentationStreamPlaybackObservation, IRepresentationsChoice } from "../representation";
+export default function getRepresentationsSwitchingStrategy(period: Period, adaptation: Adaptation, settings: IRepresentationsChoice, segmentBuffer: SegmentBuffer, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>): IRepresentationSwitchStrategy;
 export type IRepresentationSwitchStrategy = {
     type: "continue";
     value: undefined;

package/dist/es2017/core/stream/adaptation/get_representations_switch_strategy.js

@@ -45,16 +45,22 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    const currentTime = playbackObserver.getCurrentTime();
     const readyState = playbackObserver.getReadyState();
-    if (settings.switchingMode === "reload" &&
-        // We're playing the current Period
-        isTimeInRange({ start, end }, currentTime) &&
-        // There is data for the current position
-        readyState > 1 &&
-        // We're not playing the current wanted video Adaptation
-        !isTimeInRanges(rangesWithReps, currentTime)) {
-        return { type: "needs-reload", value: undefined };
+    if (settings.switchingMode === "reload" && readyState > 1) {
+        const lastObservation = playbackObserver.getReference().getValue();
+        if (lastObservation.position.isAwaitingFuturePosition()) {
+            // We are not at the position we want to reach (e.g. initial seek, tizen
+            // seek-back...), just reload as checks here would be too complex
+            return { type: "needs-reload", value: undefined };
+        }
+        else {
+            const currentTime = playbackObserver.getCurrentTime();
+            if (isTimeInRange({ start, end }, currentTime) &&
+                // We're not playing the current wanted video Adaptation
+                !isTimeInRanges(rangesWithReps, currentTime)) {
+                return { type: "needs-reload", value: undefined };
+            }
+        }
     }
     // From here, clean-up data from the previous Adaptation, if one
     const shouldFlush = settings.switchingMode === "direct";
@@ -85,6 +91,7 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
         if (paddingAfter == null) {
             paddingAfter = 0;
         }
+        const currentTime = playbackObserver.getCurrentTime();
         rangesToExclude.push({ start: currentTime - paddingBefore,
             end: currentTime + paddingAfter });
     }

package/dist/es2017/core/stream/orchestrator/stream_orchestrator.js

@@ -69,22 +69,23 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
 export default function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
     const { manifest, initialPeriod } = content;
     const { maxBufferAhead, maxBufferBehind, wantedBufferAhead, maxVideoBufferSize } = options;
-    const { MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND } = config.getCurrent();
+    const { MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND } = config.getCurrent();
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
     const garbageCollectors = new WeakMapMemory((segmentBuffer) => {
+        var _a, _b;
         const { bufferType } = segmentBuffer;
-        const defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_BEHIND[bufferType] :
-            Infinity;
-        const defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
-            MAXIMUM_MAX_BUFFER_AHEAD[bufferType] :
-            Infinity;
+        const defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
+        const maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return (gcCancelSignal) => {
             BufferGarbageCollector({ segmentBuffer,
                 playbackObserver,
                 maxBufferBehind: createMappedReference(maxBufferBehind, (val) => Math.min(val, defaultMaxBehind), gcCancelSignal),
-                maxBufferAhead: createMappedReference(maxBufferAhead, (val) => Math.min(val, defaultMaxAhead), gcCancelSignal) }, gcCancelSignal);
+                maxBufferAhead: createMappedReference(maxBufferAhead, (val) => {
+                    var _a;
+                    const lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
+                    return Math.min(lowerBound, maxAheadHigherBound);
+                }, gcCancelSignal) }, gcCancelSignal);
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
@@ -117,8 +118,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
         playbackObserver.listen(({ position }) => {
-            var _a, _b;
-            const time = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+            var _a;
+            const time = position.getWanted();
             if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
                 return;
             }
@@ -132,7 +133,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             currentCanceller.cancel();
             currentCanceller = new TaskCanceller();
             currentCanceller.linkToSignal(orchestratorCancelSignal);
-            const nextPeriod = (_b = manifest.getPeriodForTime(time)) !== null && _b !== void 0 ? _b : manifest.getNextPeriod(time);
+            const nextPeriod = (_a = manifest.getPeriodForTime(time)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
                 log.warn("Stream: The wanted position is not found in the Manifest.");
                 return;
@@ -266,7 +267,6 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             // to reduce the risk of race conditions where the next observation
             // was going to be emitted synchronously.
             queueMicrotask(() => {
-                var _a;
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
                 }
@@ -284,7 +284,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                         return;
                     }
                 }
-                const lastPosition = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+                const lastPosition = observation.position.getWanted();
                 const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
                 if (newInitialPeriod == null) {
                     callbacks.error(new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
@@ -338,10 +338,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
         playbackObserver.listen(({ position }, stopListeningObservations) => {
-            var _a, _b;
-            if (basePeriod.end !== undefined &&
-                ((_a = position.pending) !== null && _a !== void 0 ? _a : position.last) >= basePeriod.end) {
-                log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_b = position.pending) !== null && _b !== void 0 ? _b : position.last, basePeriod.end);
+            if (basePeriod.end !== undefined && position.getWanted() >= basePeriod.end) {
+                log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, position.getWanted(), basePeriod.end);
                 stopListeningObservations();
                 consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
                     manifest,
@@ -476,7 +474,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     if (cleanedRanges.length === 0) {
         return false;
     }
-    const curPos = observation.position.last;
+    const curPos = observation.position.getPolled();
     // Based on the playback direction, we just check whether we may encounter
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.

package/dist/es2017/core/stream/period/period_stream.js

@@ -152,11 +152,8 @@ export default function PeriodStream({ bufferType, content, garbageCollectors, p
             if (streamCanceller.isUsed()) {
                 return; // Previous call has provoken cancellation by side-effect
             }
-            const readyState = playbackObserver.getReadyState();
             const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-            const playbackInfos = { currentTime: playbackObserver.getCurrentTime(),
-                readyState };
-            const strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackInfos, options);
+            const strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackObserver, options);
             if (strategy.type === "needs-reload") {
                 return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
             }
@@ -315,7 +312,7 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segment
         function constructAdaptationStreamPlaybackObservation() {
             const baseObservation = observationRef.getValue();
             const buffered = segmentBuffer.getBufferedRanges();
-            const bufferGap = getLeftSizeOfBufferedTimeRange(buffered, baseObservation.position.last);
+            const bufferGap = getLeftSizeOfBufferedTimeRange(buffered, baseObservation.position.getWanted());
             return objectAssign({}, baseObservation, { bufferGap });
         }
         function emitAdaptationStreamPlaybackObservation() {
@@ -343,15 +340,15 @@ function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, buffer
     function sendStatus() {
         const observation = playbackObserver.getReference().getValue();
         const wba = wantedBufferAhead.getValue();
-        const position = observation.position.last;
+        const position = observation.position.getWanted();
         if (period.end !== undefined && position + wba >= period.end) {
             log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
             hasFinishedLoading = true;
         }
         callbacks.streamStatusUpdate({ period,
             bufferType,
-            position,
             imminentDiscontinuity: null,
+            position,
             isEmptyStream: true,
             hasFinishedLoading,
             neededSegments: [] });

package/dist/es2017/core/stream/period/types.d.ts

@@ -3,11 +3,10 @@ import SharedReference, { IReadOnlySharedReference } from "../../../utils/refere
 import { CancellationSignal } from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
 import { IAdaptationChoice, IAdaptationStreamCallbacks, IAdaptationStreamOptions, IPausedPlaybackObservation } from "../adaptation";
-import { IPositionPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks {
     /**
@@ -65,7 +64,7 @@ export interface IPeriodStreamPlaybackObservation {
      * Information on the current media position in seconds at the time of the
      * Observation.
      */
-    position: IPositionPlaybackObservation;
+    position: IObservationPosition;
     /** `duration` property of the HTMLMediaElement. */
     duration: number;
     /** `readyState` property of the HTMLMediaElement. */

package/dist/es2017/core/stream/period/utils/get_adaptation_switch_strategy.d.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 import { Adaptation, Period } from "../../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../../api";
 import { SegmentBuffer } from "../../../segment_buffers";
 import { ITrackSwitchingMode } from "../../adaptation";
+import { IPeriodStreamPlaybackObservation } from "../types";
 export type IAdaptationSwitchStrategy = 
 /** Do nothing special. */
 {
@@ -59,10 +61,7 @@ export interface IAdaptationSwitchOptions {
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
-export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer, period: Period, adaptation: Adaptation, switchingMode: ITrackSwitchingMode, playbackInfo: {
-    currentTime: number;
-    readyState: number;
-}, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;
+export default function getAdaptationSwitchStrategy(segmentBuffer: SegmentBuffer, period: Period, adaptation: Adaptation, switchingMode: ITrackSwitchingMode, playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>, options: IAdaptationSwitchOptions): IAdaptationSwitchStrategy;

package/dist/es2017/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -23,10 +23,10 @@ import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../.
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
-export default function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
+export default function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackObserver, options) {
     if (segmentBuffer.codec !== undefined &&
         options.onCodecSwitch === "reload" &&
         !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
@@ -62,16 +62,20 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    const { currentTime } = playbackInfo;
-    if (switchingMode === "reload" &&
-        // We're playing the current Period
-        isTimeInRange({ start, end }, currentTime) &&
-        // There is data for the current position or the codecs are differents
-        (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-            .some(rep => { var _a; return areCodecsCompatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
-        // We're not playing the current wanted video Adaptation
-        !isTimeInRanges(adaptationInBuffer, currentTime)) {
-        return { type: "needs-reload", value: undefined };
+    const currentTime = playbackObserver.getCurrentTime();
+    const readyState = playbackObserver.getReadyState();
+    if (switchingMode === "reload" && readyState > 1) {
+        const lastObservation = playbackObserver.getReference().getValue();
+        if (lastObservation.position.isAwaitingFuturePosition()) {
+            // We are not at the position we want to reach (e.g. initial seek, tizen
+            // seek-back...), just reload as checks here would be too complex
+            return { type: "needs-reload", value: undefined };
+        }
+        else if (isTimeInRange({ start, end }, currentTime) &&
+            // We're not playing the current wanted video Adaptation
+            !isTimeInRanges(adaptationInBuffer, currentTime)) {
+            return { type: "needs-reload", value: undefined };
+        }
     }
     // From here, clean-up data from the previous Adaptation, if one
     const shouldCleanAll = switchingMode === "direct";
@@ -139,7 +143,7 @@ function hasCompatibleCodec(adaptation, segmentBufferCodec) {
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
  * in the SegmentBuffer.
- * @param {Object} segmentBuffer
+ * @param {Array.<Object>} inventory
  * @param {Object} period
  * @param {Object} adaptation
  * @returns {Array.<Object>}

package/dist/es2017/core/stream/representation/representation_stream.js

@@ -183,12 +183,11 @@ export default function RepresentationStream({ content, options, playbackObserve
      * issues at the current time, calling the right callbacks if necessary.
      */
     function checkStatus() {
-        var _a, _b;
         if (segmentsLoadingCanceller.isUsed()) {
             return; // Stop all buffer status checking if load operations are stopped
         }
         const observation = playbackObserver.getReference().getValue();
-        const initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+        const initialWantedTime = observation.position.getWanted();
         const status = getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
         const { neededSegments } = status;
         let neededInitSegment = null;
@@ -202,7 +201,7 @@ export default function RepresentationStream({ content, options, playbackObserve
                     "initialization segment");
             }
             else {
-                const wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
+                const wantedStart = observation.position.getWanted();
                 neededInitSegment = { segment: initSegmentState.segment,
                     priority: getSegmentPriority(period.start, wantedStart) };
             }
@@ -253,7 +252,7 @@ export default function RepresentationStream({ content, options, playbackObserve
             }
         }
         callbacks.streamStatusUpdate({ period,
-            position: observation.position.last,
+            position: observation.position.getWanted(),
             bufferType,
             imminentDiscontinuity: status.imminentDiscontinuity,
             isEmptyStream: false,

package/dist/es2017/core/stream/representation/types.d.ts

@@ -2,7 +2,7 @@ import Manifest, { Adaptation, ISegment, Period, Representation } from "../../..
 import { IEMSG } from "../../../parsers/containers/isobmff";
 import { IAudioRepresentationsSwitchingMode, IPlayerError, IVideoRepresentationsSwitchingMode } from "../../../public_types";
 import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { IContentProtection } from "../../decrypt";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { IBufferType, SegmentBuffer } from "../../segment_buffers";
@@ -163,7 +163,7 @@ export interface IRepresentationStreamPlaybackObservation {
      * Information on the current media position in seconds at the time of a
      * Playback Observation.
      */
-    position: IPositionPlaybackObservation;
+    position: IObservationPosition;
 }
 /** Position-related information linked to an emitted Playback observation. */
 export interface IPositionPlaybackObservation {

package/dist/es2017/core/stream/representation/utils/append_segment_to_buffer.js

@@ -30,7 +30,6 @@ import forceGarbageCollection from "./force_garbage_collection";
  * @returns {Promise}
  */
 export default async function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
-    var _a;
     try {
         await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
     }
@@ -46,7 +45,7 @@ export default async function appendSegmentToBuffer(playbackObserver, segmentBuf
             throw new MediaError("BUFFER_APPEND_ERROR", reason, { adaptations: [dataInfos.inventoryInfos.adaptation] });
         }
         const { position } = playbackObserver.getReference().getValue();
-        const currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+        const currentPos = position.getWanted();
         try {
             await forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal);
             await segmentBuffer.pushChunk(dataInfos, cancellationSignal);

package/dist/es2017/core/stream/representation/utils/get_buffer_status.js

@@ -74,7 +74,7 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
      * needed segments for this Representation until the end of the Period.
      */
     const hasFinishedLoading = representation.index.isInitialized() &&
-        representation.index.isFinished() &&
+        !representation.index.isStillAwaitingFutureSegments() &&
         neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
         segmentsOnHold.length === 0;
@@ -128,7 +128,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         SegmentBuffersStore.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
-        representationIndex.isFinished() &&
+        !representationIndex.isStillAwaitingFutureSegments() &&
         isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
         wantedStartPosition = lastIndexPosition - 1;
     }
@@ -138,7 +138,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     const wantedEndPosition = wantedStartPosition + bufferGoal;
     let hasReachedPeriodEnd;
     if (!representation.index.isInitialized() ||
-        !representation.index.isFinished() ||
+        representation.index.isStillAwaitingFutureSegments() ||
         period.end === undefined) {
         hasReachedPeriodEnd = false;
     }
@@ -194,7 +194,7 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
     for (let i = segmentInventory.length - 1; i >= 0; i--) {
         const eltInventory = segmentInventory[i];
         const { representation } = eltInventory.infos;
-        if (!eltInventory.partiallyPushed &&
+        if (eltInventory.status === 1 /* ChunkStatus.Complete */ &&
             representation.decipherable !== false &&
             representation.isSupported) {
             const inventorySegment = eltInventory.infos.segment;

package/dist/es2017/core/stream/representation/utils/get_needed_segments.js

@@ -320,7 +320,7 @@ function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     }
     if (minimumEndTime > currentSeg.bufferedEnd &&
         currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+        log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.end, currentSeg.bufferedEnd);
         return true;
     }
     return false;

package/dist/es2017/default_config.d.ts

@@ -21,6 +21,11 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: number;
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: number;
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element
@@ -141,6 +146,13 @@ declare const DEFAULT_CONFIG: {
      * @type {Object}
      */
     MAXIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "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.
@@ -203,22 +215,6 @@ declare const DEFAULT_CONFIG: {
      * @type {Number}
      */
     BUFFER_DISCONTINUITY_THRESHOLD: number;
-    /**
-     * When encountering small discontinuities, the RxPlayer may want, in specific
-     * conditions, ignore those and let the browser seek over them iself (this
-     * allows for example to avoid conflicts when both the browser and the
-     * RxPlayer want to seek at a different position, sometimes leading to a
-     * seeking loop).
-     * In this case, we however still want to seek it ourselves if the browser
-     * doesn't take the opportunity soon enough.
-     *
-     * This value specifies a delay after which a discontinuity ignored by the
-     * RxPlayer is finally considered.
-     * We want to maintain high enough to be sure the browser will not seek yet
-     * small enough so this (arguably rare) situation won't lead to too much
-     * waiting time.
-     */
-    FORCE_DISCONTINUITY_SEEK_DELAY: number;
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/dist/es2017/default_config.js

@@ -21,6 +21,11 @@ const DEFAULT_CONFIG = {
      * @type {Number}
      */
     DEFAULT_REQUEST_TIMEOUT: 30 * 1000,
+    /**
+     * Default connection time after which a request will timeout, in ms.
+     * @type {Number}
+     */
+    DEFAULT_CONNECTION_TIMEOUT: 15 * 1000,
     /**
      * Can be either:
      *   - "native": Subtitles are all displayed in a <track> element
@@ -144,6 +149,22 @@ const 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.
@@ -209,22 +230,6 @@ const DEFAULT_CONFIG = {
      * @type {Number}
      */
     BUFFER_DISCONTINUITY_THRESHOLD: 0.2,
-    /**
-     * When encountering small discontinuities, the RxPlayer may want, in specific
-     * conditions, ignore those and let the browser seek over them iself (this
-     * allows for example to avoid conflicts when both the browser and the
-     * RxPlayer want to seek at a different position, sometimes leading to a
-     * seeking loop).
-     * In this case, we however still want to seek it ourselves if the browser
-     * doesn't take the opportunity soon enough.
-     *
-     * This value specifies a delay after which a discontinuity ignored by the
-     * RxPlayer is finally considered.
-     * We want to maintain high enough to be sure the browser will not seek yet
-     * small enough so this (arguably rare) situation won't lead to too much
-     * waiting time.
-     */
-    FORCE_DISCONTINUITY_SEEK_DELAY: 5000,
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/dist/es2017/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.js

@@ -128,7 +128,9 @@ export default class VideoThumbnailLoader {
             {}, { baseDelay: 0,
                 maxDelay: 0,
                 maxRetry: 0,
-                requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT });
+                requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+            });
             const initSegment = content.representation.index.getInitSegment();
             const initSegmentUniqueId = initSegment !== null ?
                 content.representation.uniqueId :

package/dist/es2017/experimental/tools/createMetaplaylist/get_duration_from_manifest.js

@@ -69,6 +69,7 @@ async function getDurationFromManifest(url, transport) {
             url,
             responseType: "document",
             timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+            connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
             // We won't cancel
             cancelSignal: new TaskCanceller().signal,
         });
@@ -106,6 +107,7 @@ async function getDurationFromManifest(url, transport) {
         url,
         responseType: "text",
         timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+        connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
         // We won't cancel
         cancelSignal: new TaskCanceller().signal,
     });

package/dist/es2017/manifest/adaptation.js

@@ -78,7 +78,8 @@ export default class Adaptation {
                 const 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,