rx-player 3.27.0-dev.2022032800 → 3.27.1-dev.2022040500

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## v3.27.0-dev.2022032800 (2022-03-28)
+## v3.27.1-dev.2022040500 (2022-04-05)
+
+### Bug fixes
+
+ - When creating SourceBuffers, use the first _supported_ codec of the chosen `Adaptation`, not the lowest-bitrate one [#1094]
+
+
+## v3.27.0 (2022-03-31)
 
 ### Features
 
@@ -16,6 +23,7 @@
   - avoid performing a small seek when changing the audio track [#1080]
   - api: allow switching to RELOADING state synchronously after LOADED [#1083]
   - Safari Mobile: Improve decryption support on Safari mobile by relying on the vendored `WebKitMediaKeys` API [#1072]
+  - DASH: Fix issue which prevented the integrity check of most MP4 DASH segments when `transportOptions.checkMediaSegmentIntegrity` was set to `true`
   - avoid unnecessary warning logs when loading some initialization segments [#1049]
   - TypeScript: Add forgotten TypeScript types in the exposed segment and manifest loader APIs [#1057]
   - DRM: Avoid decryption issues when a license is persisted in a `singleLicensePer` `"init-data"` mode but loaded in a `"content"` mode [#1031, #1042]
@@ -26,7 +34,7 @@
   - DASH: always consider that the non-last Period is finished when it contains SegmentTimeline elements [#1047]
   - add better buffer cleaning logic on a browser's `QuotaExceededError` to better handle memory limitations [#1065]
   - DASH: Prioritize selectionPriority attribute over a "main" Role when ordering AdaptationSets [#1082]
-  - directfile/Safari: use the `getStartDate` method in `getWallClockTime` when available to obtain true offseted times when playing HLS contents on Safari [#1055]
+  - directfile/Safari: use the `getStartDate` method in `getWallClockTime`, `seekTo` and the `positionUpdate` event when available to obtain true offseted "wall-clock" times when playing HLS contents on Safari [#1055]
   - DRM: Improve DRM Session caches performance when `singleLicensePer` is set to `"content"`
   - DRM: Stop retrying closing MediaKeySessions multiple times when it fails, instead doing it only once when it should work [#1093]
   - TypeScript: Add IBitrateEstimate, IPositionUpdate and IPlayerState types to the exported types [#1084]

package/VERSION

@@ -1 +1 @@
-3.27.0-dev.2022032800
+3.27.1-dev.2022040500

package/dist/_esm5.processed/compat/get_start_date.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+/**
+ * Calculating a live-offseted media position necessitate to obtain first an
+ * offset, and then adding that offset to the wanted position.
+ *
+ * That offset is in most case present inside the Manifest file, yet in cases
+ * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
+ * won't know that offset.
+ *
+ * Thankfully Safari declares a `getStartDate` method allowing to obtain that
+ * offset when available. This logic is mainly useful when playing HLS contents
+ * in directfile mode on Safari.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {number|undefined}
+ */
+export default function getStartDate(mediaElement: HTMLMediaElement): number | undefined;

package/dist/_esm5.processed/compat/get_start_date.js

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+/**
+ * Calculating a live-offseted media position necessitate to obtain first an
+ * offset, and then adding that offset to the wanted position.
+ *
+ * That offset is in most case present inside the Manifest file, yet in cases
+ * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
+ * won't know that offset.
+ *
+ * Thankfully Safari declares a `getStartDate` method allowing to obtain that
+ * offset when available. This logic is mainly useful when playing HLS contents
+ * in directfile mode on Safari.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {number|undefined}
+ */
+export default function getStartDate(mediaElement) {
+    var _mediaElement = mediaElement;
+    if (typeof _mediaElement.getStartDate === "function") {
+        var startDate = _mediaElement.getStartDate();
+        if (typeof startDate === "object" && startDate !== null) {
+            var startDateNum = +startDate;
+            if (!isNaN(startDateNum)) {
+                return startDateNum / 1000;
+            }
+        }
+        else if (typeof startDate === "number" && !isNaN(startDate)) {
+            return startDate;
+        }
+    }
+}

package/dist/_esm5.processed/compat/index.d.ts

@@ -22,6 +22,7 @@ import clearElementSrc from "./clear_element_src";
 import { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, ICustomMediaKeys, ICustomMediaKeySession, ICustomMediaKeySystemAccess, loadSession, requestMediaKeySystemAccess, setMediaKeys } from "./eme";
 import * as events from "./event_listeners";
 import { exitFullscreen, isFullscreen, requestFullscreen } from "./fullscreen";
+import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
@@ -38,4 +39,4 @@ import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
 import whenLoadedMetadata$ from "./when_loaded_metadata";
 import whenMediaSourceOpen$ from "./when_media_source_open";
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, ICompatTextTrack, ICompatVTTCue, ICustomMediaKeySession, ICustomMediaKeySystemAccess, ICustomMediaKeys, ICompatSourceBuffer, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };

package/dist/_esm5.processed/compat/index.js

@@ -22,6 +22,7 @@ import clearElementSrc from "./clear_element_src";
 import { closeSession, CustomMediaKeySystemAccess, generateKeyRequest, getInitData, loadSession, requestMediaKeySystemAccess, setMediaKeys, } from "./eme";
 import * as events from "./event_listeners";
 import { exitFullscreen, isFullscreen, requestFullscreen, } from "./fullscreen";
+import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
@@ -44,4 +45,4 @@ import whenMediaSourceOpen$ from "./when_media_source_open";
 // we  would prefer to disallow (both for the understandability of the code and
 // to better exploit tree shaking.
 patchWebkitSourceBuffer();
-export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };
+export { addClassName, addTextTrack, canPatchISOBMFFSegment, clearElementSrc, closeSession, CustomMediaKeySystemAccess, events, exitFullscreen, generateKeyRequest, getInitData, getStartDate, hasEMEAPIs, isCodecSupported, isFullscreen, isNode, isOffline, isVTTCue, loadSession, makeVTTCue, MediaSource_, onHeightWidthChange, play, requestFullscreen, requestMediaKeySystemAccess, setElementSrc$, setMediaKeys, shouldReloadMediaSourceOnDecipherabilityUpdate, shouldRenewMediaKeys, shouldUnsetMediaKeys, shouldValidateMetadata, shouldWaitForDataBeforeLoaded, tryToChangeSourceBufferType, whenLoadedMetadata$, whenMediaSourceOpen$, };

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

@@ -175,8 +175,7 @@ declare class ConfigHandler {
         DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR: number;
         BUFFERED_HISTORY_RETENTION_TIME: number;
         BUFFERED_HISTORY_MAXIMUM_ENTRIES: number;
-        MIN_BUFFER_LENGTH: number;
-        MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: number;
+        MIN_BUFFER_AHEAD: number;
         UPTO_CURRENT_POSITION_CLEANUP: number;
     };
     update(config: Partial<IDefaultConfig>): void;

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

@@ -44,7 +44,7 @@ var __assign = (this && this.__assign) || function () {
  * It also starts the different sub-parts of the player on various API calls.
  */
 import { combineLatest as observableCombineLatest, concat as observableConcat, connectable, distinctUntilChanged, EMPTY, filter, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, share, shareReplay, skipWhile, startWith, Subject, switchMap, take, takeUntil, } from "rxjs";
-import { events, exitFullscreen, isFullscreen, requestFullscreen, } from "../../compat";
+import { events, exitFullscreen, getStartDate, isFullscreen, requestFullscreen, } from "../../compat";
 /* eslint-disable-next-line max-len */
 import canRelyOnVideoVisibilityAndSize from "../../compat/can_rely_on_video_visibility_and_size";
 import config from "../../config";
@@ -87,7 +87,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.27.0-dev.2022032800";
+        _this.version = /* PLAYER_VERSION */ "3.27.1-dev.2022040500";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -805,22 +805,8 @@ var Player = /** @class */ (function (_super) {
         }
         var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
         if (isDirectFile) {
-            // Calculating the "wall-clock time" necessitate to obtain first an offset,
-            // and then adding that offset to the HTMLMediaElement's current position.
-            // That offset is in most case present inside the Manifest file, yet in
-            // directfile mode, the RxPlayer won't parse that file, the browser does it.
-            //
-            // Thankfully Safari declares a `getStartDate` method allowing to obtain
-            // that offset when available. This logic is thus mainly useful when
-            // playing HLS contents in directfile mode on Safari.
-            var mediaElement = this.videoElement;
-            if (typeof mediaElement.getStartDate === "function") {
-                var startDate = mediaElement.getStartDate();
-                if (typeof startDate === "number" && !isNaN(startDate)) {
-                    return startDate + mediaElement.currentTime;
-                }
-            }
-            return mediaElement.currentTime;
+            var startDate = getStartDate(this.videoElement);
+            return (startDate !== null && startDate !== void 0 ? startDate : 0) + this.videoElement.currentTime;
         }
         if (manifest !== null) {
             var currentTime = this.videoElement.currentTime;
@@ -1069,13 +1055,14 @@ var Player = /** @class */ (function (_super) {
      * @returns {Number} - The time the player has seek to
      */
     Player.prototype.seekTo = function (time) {
+        var _a;
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
         if (this._priv_contentInfos === null) {
             throw new Error("player: no content loaded");
         }
-        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
         if (!isDirectFile && manifest === null) {
             throw new Error("player: the content did not load yet");
         }
@@ -1093,11 +1080,18 @@ var Player = /** @class */ (function (_super) {
                 positionWanted = timeObj.position;
             }
             else if (!isNullOrUndefined(timeObj.wallClockTime)) {
-                positionWanted = (isDirectFile || manifest === null) ?
-                    timeObj.wallClockTime :
-                    timeObj.wallClockTime - (manifest.availabilityStartTime !== undefined ?
-                        manifest.availabilityStartTime :
-                        0);
+                if (manifest !== null) {
+                    positionWanted = timeObj.wallClockTime - ((_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0);
+                }
+                else if (isDirectFile && this.videoElement !== null) {
+                    var startDate = getStartDate(this.videoElement);
+                    if (startDate !== undefined) {
+                        positionWanted = timeObj.wallClockTime - startDate;
+                    }
+                }
+                if (positionWanted === undefined) {
+                    positionWanted = timeObj.wallClockTime;
+                }
             }
             else {
                 throw new Error("invalid time object. You must set one of the " +
@@ -2261,6 +2255,12 @@ var Player = /** @class */ (function (_super) {
             positionData.wallClockTime = observation.position + ast;
             positionData.liveGap = maximumPosition - observation.position;
         }
+        else if (isDirectFile && this.videoElement !== null) {
+            var startDate = getStartDate(this.videoElement);
+            if (startDate !== undefined) {
+                positionData.wallClockTime = startDate + observation.position;
+            }
+        }
         this.trigger("positionUpdate", positionData);
     };
     /**
@@ -2302,5 +2302,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.27.0-dev.2022032800";
+Player.version = /* PLAYER_VERSION */ "3.27.1-dev.2022040500";
 export default Player;

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, } from "rxjs";
+import { combineLatest as observableCombineLatest, concatAll, EMPTY, from as observableFrom, ignoreElements, mergeMap, of as observableOf, } from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 /**
@@ -105,6 +105,9 @@ function clearBuffer(segmentBuffer, position, maxBufferBehind, maxBufferAhead) {
     collectBufferAhead();
     var clean$ = observableFrom(cleanedupRanges.map(function (range) {
         log.debug("GC: cleaning range from SegmentBuffer", range);
+        if (range.start >= range.end) {
+            return observableOf(null);
+        }
         return segmentBuffer.removeBuffer(range.start, range.end);
     })).pipe(concatAll(), 
     // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default

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

@@ -240,7 +240,8 @@ export default function StreamOrchestrator(content, playbackObserver, abrManager
             destroyStreams$.next();
             return observableConcat.apply(void 0, __spreadArray(__spreadArray([], rangesToClean.map(function (_a) {
                 var start = _a.start, end = _a.end;
-                return segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
+                return start >= end ? EMPTY :
+                    segmentBuffer.removeBuffer(start, end).pipe(ignoreElements());
             }), false), [playbackObserver.observe(true).pipe(take(1), mergeMap(function (observation) {
                     return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position, !observation.isPaused, observation.duration)), observableDefer(function () {
                         var lastPosition = observation.position +

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -15,7 +15,7 @@
  */
 import { catchError, concat as observableConcat, defer as observableDefer, EMPTY, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, startWith, switchMap, } from "rxjs";
 import config from "../../../config";
-import { formatError } from "../../../errors";
+import { formatError, MediaError, } from "../../../errors";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
@@ -63,9 +63,15 @@ export default function PeriodStream(_a) {
                 if (SegmentBuffersStore.isNative(bufferType)) {
                     return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
                 }
-                cleanBuffer$ = segmentBufferStatus.value
-                    .removeBuffer(period.start, period.end == null ? Infinity :
-                    period.end);
+                if (period.end === undefined) {
+                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, Infinity);
+                }
+                else if (period.end <= period.start) {
+                    cleanBuffer$ = observableOf(null);
+                }
+                else {
+                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, period.end);
+                }
             }
             else {
                 if (segmentBufferStatus.type === "uninitialized") {
@@ -160,9 +166,11 @@ function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation,
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation) {
-    var representations = adaptation.representations;
-    if (representations[0] == null) {
-        return "";
+    var representations = adaptation.getPlayableRepresentations();
+    if (representations.length === 0) {
+        var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
+            adaptation.type + " Adaptation can be played");
+        throw noRepErr;
     }
     return representations[0].getMimeTypeString();
 }

package/dist/_esm5.processed/core/stream/representation/force_garbage_collection.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concatAll, defer as observableDefer, from as observableFrom, } from "rxjs";
+import { concatAll, defer as observableDefer, from as observableFrom, of as observableOf, } from "rxjs";
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
@@ -41,7 +41,8 @@ export default function forceGarbageCollection(currentPosition, bufferingQueue)
         log.debug("Stream: GC cleaning", cleanedupRanges);
         return observableFrom(cleanedupRanges.map(function (_a) {
             var start = _a.start, end = _a.end;
-            return bufferingQueue.removeBuffer(start, end);
+            return start >= end ? observableOf(null) :
+                bufferingQueue.removeBuffer(start, end);
         })).pipe(concatAll());
     });
 }

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.d.ts

@@ -43,8 +43,8 @@ export interface IBufferStatus {
      */
     shouldRefreshManifest: boolean;
     /**
-     * If 'true', the buffer memory is saturated before being able to download
-     * at least MIN_REQUIRED_BUFFER_AHEAD ( default : 10sec )
+     * If 'true', the buffer memory is saturated, thus we may have issues loading
+     * new segments.
      */
     isBufferFull: boolean;
 }

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

@@ -55,8 +55,8 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), neededSegments = _b.neededSegments, isBufferFull = _b.isBufferFull;
-    var prioritizedNeededSegments = neededSegments.map(function (segment) { return ({
+    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _b.segmentsToLoad, segmentsOnHold = _b.segmentsOnHold, isBufferFull = _b.isBufferFull;
+    var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
         priority: getSegmentPriority(segment.time, wantedStartPosition),
         segment: segment,
     }); });
@@ -68,7 +68,8 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     var lastPosition = representation.index.getLastPosition();
     if (!representation.index.isInitialized() ||
         period.end === undefined ||
-        prioritizedNeededSegments.length > 0) {
+        prioritizedNeededSegments.length > 0 ||
+        segmentsOnHold.length > 0) {
         hasFinishedLoading = false;
     }
     else {
@@ -112,6 +113,11 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
         if (segmentsBeingPushed.length > 0) {
             nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
         }
+        if (segmentsOnHold.length > 0) {
+            nextSegmentStart = nextSegmentStart !== null ?
+                Math.min(nextSegmentStart, segmentsOnHold[0].time) :
+                segmentsOnHold[0].time;
+        }
         if (prioritizedNeededSegments.length > 0) {
             nextSegmentStart = nextSegmentStart !== null ?
                 Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.d.ts

@@ -65,7 +65,17 @@ export interface IGetNeededSegmentsArguments {
     getBufferedHistory: (context: IChunkContext) => IBufferedHistoryEntry[];
 }
 interface INeededSegments {
-    neededSegments: ISegment[];
+    /** Segments that should be loaded right now, by chronological order. */
+    segmentsToLoad: ISegment[];
+    /**
+     * Segments that should be loaded, but not right now, due to some other
+     * constraints, such as memory limitations.
+     */
+    segmentsOnHold: ISegment[];
+    /**
+     * If `true` the buffer is currently full according to the given limits.
+     * Memory should be freed if possible, for example by cleaning the buffers.
+     */
     isBufferFull: boolean;
 }
 /**

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.js

@@ -32,8 +32,6 @@ export default function getNeededSegments(_a) {
     var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed, maxBufferSize = _a.maxBufferSize;
     var representation = content.representation;
     var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
-    // Current buffer length in seconds
-    var bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
     var availableSegmentsForRange = representation.index
         .getSegments(neededRange.start, neededRange.end - neededRange.start);
     // Remove from `bufferedSegments` any segments we would prefer to replace:
@@ -63,15 +61,16 @@ export default function getNeededSegments(_a) {
         }
         return true;
     });
-    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_LENGTH = _b.MIN_BUFFER_LENGTH, MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP = _b.MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP;
-    var isMemorySaturated = false;
+    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_AHEAD = _b.MIN_BUFFER_AHEAD;
+    var shouldStopLoadingSegments = false;
     /**
      * Epsilon compensating for rounding errors when comparing the start and end
      * time of multiple segments.
      */
     var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
     var isBufferFull = false;
-    var neededSegments = availableSegmentsForRange.filter(function (segment) {
+    var segmentsOnHold = [];
+    var segmentsToLoad = availableSegmentsForRange.filter(function (segment) {
         var contentObject = objectAssign({ segment: segment }, content);
         // First, check that the segment is not already being pushed
         if (segmentsBeingPushed.length > 0) {
@@ -85,17 +84,8 @@ export default function getNeededSegments(_a) {
         if (segment.isInit) {
             return true; // never skip initialization segments
         }
-        if (isMemorySaturated) {
-            // If we are so saturated in memory
-            // That we cannot download atleast till
-            // NeededRange.Start ( current position ) + a CONST
-            // Then the buffer is full
-            if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
-                isBufferFull = true;
-            }
-        }
-        if (isMemorySaturated &&
-            bufferLength > MIN_BUFFER_LENGTH) {
+        if (shouldStopLoadingSegments) {
+            segmentsOnHold.push(segment);
             return false;
         }
         if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
@@ -138,27 +128,34 @@ export default function getNeededSegments(_a) {
                 }
             }
         }
+        var estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
+        if (availableBufferSize - estimatedSegmentSize < 0) {
+            isBufferFull = true;
+            if (time > neededRange.start + MIN_BUFFER_AHEAD) {
+                shouldStopLoadingSegments = true;
+                segmentsOnHold.push(segment);
+                return false;
+            }
+        }
         // check if there is an hole in place of the segment currently
         for (var i = 0; i < segmentsToKeep.length; i++) {
             var completeSeg = segmentsToKeep[i];
-            if (completeSeg.end > time) {
-                // `true` if `completeSeg` starts too far after `time`
-                return completeSeg.start > time + ROUNDING_ERROR ||
-                    // `true` if `completeSeg` ends too soon before `end`
-                    getLastContiguousSegment(segmentsToKeep, i).end < end - ROUNDING_ERROR;
+            // For the first already-loaded segment, take the first one ending after
+            // this one' s start
+            if ((completeSeg.end + ROUNDING_ERROR) > time) {
+                var shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
+                    getLastContiguousSegment(segmentsToKeep, i).end <
+                        end - ROUNDING_ERROR;
+                if (shouldLoad) {
+                    availableBufferSize -= estimatedSegmentSize;
+                }
+                return shouldLoad;
             }
         }
-        var estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
-        if (availableBufferSize - estimatedSegmentSize < 0 &&
-            bufferLength > MIN_BUFFER_LENGTH) {
-            isMemorySaturated = true;
-            return false;
-        }
         availableBufferSize -= estimatedSegmentSize;
-        bufferLength += duration;
         return true;
     });
-    return { neededSegments: neededSegments, isBufferFull: isBufferFull };
+    return { segmentsToLoad: segmentsToLoad, segmentsOnHold: segmentsOnHold, isBufferFull: isBufferFull };
 }
 /**
  * Compute the estimated available buffer size in memory in kilobytes
@@ -178,28 +175,13 @@ function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoB
     }, 0);
     return bufferedSegments.reduce(function (size, chunk) {
         if (chunk.chunkSize !== undefined) {
-            return size - (chunk.chunkSize / 8000);
+            return size - (chunk.chunkSize / 1000);
         }
         else {
             return size;
         }
     }, availableBufferSize);
 }
-/**
- * Compute the length of the buffer in seconds
- * @param bufferedSegments
- * @param segmentsBeingPushed
- * @returns bufferLength in seconds
- */
-function getBufferLength(bufferedSegments, segmentsBeingPushed) {
-    var bufferLength = bufferedSegments.reduce(function (length, segment) {
-        return length + (segment.end - segment.start);
-    }, 0);
-    var bufferBeingPushed = segmentsBeingPushed.reduce(function (length, segment) {
-        return length + segment.segment.duration;
-    }, 0);
-    return bufferLength + bufferBeingPushed;
-}
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
  * buffered chunk contiguous with the one at the `startIndex` index given.

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -166,10 +166,12 @@ export default function RepresentationStream(_a) {
         var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
             var gcedPosition = Math.max(0, wantedStartPosition - UPTO_CURRENT_POSITION_CLEANUP);
-            bufferRemoval = segmentBuffer
-                .removeBuffer(0, gcedPosition)
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                .pipe(ignoreElements());
+            if (gcedPosition > 0) {
+                bufferRemoval = segmentBuffer
+                    .removeBuffer(0, gcedPosition)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    .pipe(ignoreElements());
+            }
         }
         return status.shouldRefreshManifest ?
             observableConcat(observableOf(EVENTS.needsManifestRefresh()), bufferStatusEvt, bufferRemoval) :

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

@@ -1065,17 +1065,11 @@ declare const DEFAULT_CONFIG: {
      * there can be in that history.
      */
     BUFFERED_HISTORY_MAXIMUM_ENTRIES: number;
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-    MIN_BUFFER_LENGTH: number;
     /**
      * Minimum buffer in seconds ahead relative to current time
-     * we should be able to download
-     * Before trying to agressively free up memory
+     * we should be able to download, even in cases of saturated memory.
      */
-    MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: number;
+    MIN_BUFFER_AHEAD: number;
     /**
      * Distance in seconds behind the current position
      * the player will free up to in the case we agressively free up memory

package/dist/_esm5.processed/default_config.js

@@ -1097,17 +1097,11 @@ var DEFAULT_CONFIG = {
      * there can be in that history.
      */
     BUFFERED_HISTORY_MAXIMUM_ENTRIES: 200,
-    /**
-     * Minimum buffer (in seconds) we should have, regardless of memory
-     * constraints
-     */
-    MIN_BUFFER_LENGTH: 5,
     /**
      * Minimum buffer in seconds ahead relative to current time
-     * we should be able to download
-     * Before trying to agressively free up memory
+     * we should be able to download, even in cases of saturated memory.
      */
-    MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP: 10,
+    MIN_BUFFER_AHEAD: 5,
     /**
      * Distance in seconds behind the current position
      * the player will free up to in the case we agressively free up memory