rx-player 3.33.0-dev.2023120600 → 3.33.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## v3.33.0-dev.2023120600 (2023-12-06)
+## v3.33.0 (2024-01-24)
 
 ### Features
 
@@ -8,11 +8,16 @@
   - Add `startAt.fromLivePosition` `loadVideo` option [#1300]
   - Add the possibility to set a new `keySystems` option on the `reload` API [#1308]
 
-### Bug Fixes
+### Bug fixes
 
   - Fix subtitles "blinking" in some specific conditions, especially with some DASH low-latency contents [#1314]
   - DASH: Fix Period overlap resolution logic for when the first Period is removed [#1311]
-  - Fix export of the `LOCAL_MANIFEST` experimental feature [#1305]
+  - TTML: Fix handling of the `tts:lineHeight` attribute [#1320]
+  - Fix import of the `LOCAL_MANIFEST` experimental feature
+  - Avoid very rarely skipping segments which initially were too big to be pushed due to memory limitations [#1323]
+  - Fix issue arising when using track APIs at the exact last possible position of a Period with no consecutive Period [#1337]
+  - Starting at the end (through a `startAt` `loadVideo` option) or reloading at the end led to the restart of the content [#1338]
+  - DRM/Safari: also perform Safari DRM work-arounds when the page is launched from the dock [#1351, #1356]
 
 ### Other improvements
 
@@ -21,6 +26,10 @@
   - DEBUG_ELEMENT: Add unsupported and undecipherable bitrates to the debug element [#1321]
   - DEBUG_ELEMENT: update buffer graph maximum size so it becomes more readable for lengthy contents [#1316]
   - DEBUG_ELEMENT: always synchronize inventory of segments before rendering it [#1317]
+  - Remove remaining RxPlayer dependency removing possibility of some application-side bundling errors [#1312]
+  - Add exception to text Garbage collection logic to avoid unnecessarily reload text segments frequently [#1325]
+  - Avoid logging too much the buffer's content when our debugging UI or the demo is used [#1341]
+  - Demo: Fix reporting of live position in demo page [#1313]
 
 
 ## v3.32.1 (2023-10-19)

package/README.md

@@ -179,21 +179,11 @@ Demo pages for our previous versions are also available
 
 
 
-## Your questions ##############################################################
-
-You can ask directly your questions about the project on [our
-gitter](https://gitter.im/canalplus/rx-player).
-We will try our best to answer them as quickly as possible.
-
-
-
 ## Contribute ##################################################################
 
 Details on how to contribute is written in the [CONTRIBUTING.md
 file](./CONTRIBUTING.md) at the root of this repository.
 
-If you need more information, you can contact us via our [gitter
-room](https://gitter.im/canalplus/rx-player).
 
 
 ### Dependencies ###############################################################
@@ -238,7 +228,7 @@ Canal+ Group is a media company with many advanced needs when it comes to media
 playback: it provides both live and VoD stream with multiple encryption
 requirements, supports a very large panel of devices and has many other
 specificities (like adult content restrictions, ad-insertion, Peer-To-Peer
-integration...).
+integration, low-latency live streaming...).
 
 When the time came to switch from a plugin-based web player approach to an HTML5
 one back in 2015, no media player had the key features we wanted, and including
@@ -249,7 +239,7 @@ The R&D department of Canal+ Group thus started to work on a new featureful
 media-player: the RxPlayer. To both help and profit from the community, it also
 decided to share it to everyone under a permissive open-source licence.
 
-Now, more than 6 years later, the RxPlayer continues to evolve at the same fast
+Now, more than 8 years later, the RxPlayer continues to evolve at the same fast
 pace to include a lot of features and improvements you may not find in other
 media players.
 You can look at our
@@ -296,24 +286,3 @@ them. Amongst those:
     risks always low.
 
 \* In "directfile" mode, on compatible browsers
-
-
-## Target support ##############################################################
-
-Here is a basic list of supported platforms:
-
-|             | Chrome  |  IE [1] |  Edge  |  Firefox  |  Safari  |  Opera  |
-|-------------|:-------:|:-------:|:------:|:---------:|:--------:|:-------:|
-| Windows     |  >= 30  |  >= 11  |  >= 12 |   >= 42   |   >= 8   |  >= 25  |
-| OSX         |  >= 30  |    -    |    -   |   >= 42   |   >= 8   |  >= 25  |
-| Linux       |  >= 37  |    -    |    -   |   >= 42   |    -     |  >= 25  |
-| Android [2] |  >= 30  |    -    |    -   |   >= 42   |    -     |  >= 15  |
-| iOS         |   No    |    -    |    -   |    No     |    No    |    No   |
-
-[1] Only on Windows >= 8.
-
-[2] Android version >= 4.2
-
-And more. A good way to know if the browser should be supported by our player is
-to go on the page https://www.youtube.com/html5 and check for "Media Source
-Extensions" support.

package/VERSION

@@ -1 +1 @@
-3.33.0-dev.2023120600
+3.33.0

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

@@ -39,4 +39,6 @@ declare let isWebOs2022: boolean;
 declare let isPanasonic: boolean;
 /** `true` for the PlayStation 5 game console. */
 declare let isPlayStation5: boolean;
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+/** `true` for the Xbox game consoles. */
+declare let isXbox: boolean;
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isXbox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

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

@@ -40,8 +40,10 @@ var isWebOs2022 = false;
 var isPanasonic = false;
 /** `true` for the PlayStation 5 game console. */
 var isPlayStation5 = false;
+/** `true` for the Xbox game consoles. */
+var isXbox = false;
 ((function findCurrentBrowser() {
-    var _a, _b;
+    var _a, _b, _c;
     if (isNode) {
         return;
     }
@@ -66,9 +68,24 @@ var isPlayStation5 = false;
         /iPad|iPhone|iPod/.test(navigator.platform)) {
         isSafariMobile = true;
     }
-    else if (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
+    else if (
+    // the following statement check if the window.safari contains the method
+    // "pushNotification", this condition is not met when using web app from the dock
+    // on macOS, this is why we also check userAgent.
+    Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
         ((_b = (_a = window.safari) === null || _a === void 0 ? void 0 : _a.pushNotification) === null || _b === void 0 ? void 0 : _b.toString()) ===
-            "[object SafariRemoteNotification]") {
+            "[object SafariRemoteNotification]" ||
+        // browsers are lying: Chrome reports both as Chrome and Safari in user
+        // agent string, So to detect Safari we have to check for the Safari string
+        // and the absence of the Chrome string
+        // eslint-disable-next-line max-len
+        // @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#which_part_of_the_user_agent_contains_the_information_you_are_looking_for
+        ((/Safari\/(\d+)/).test(navigator.userAgent) &&
+            // Safari should contain Version/ in userAgent
+            (/Version\/(\d+)/).test(navigator.userAgent) &&
+            (((_c = navigator.vendor) === null || _c === void 0 ? void 0 : _c.indexOf("Apple")) !== -1) &&
+            !(/Chrome\/(\d+)/).test(navigator.userAgent) &&
+            !(/Chromium\/(\d+)/).test(navigator.userAgent))) {
         isSafariDesktop = true;
     }
     // 2 - Find out specific device/platform information
@@ -99,5 +116,8 @@ var isPlayStation5 = false;
     else if (/[Pp]anasonic/.test(navigator.userAgent)) {
         isPanasonic = true;
     }
+    else if (navigator.userAgent.indexOf("Xbox") !== -1) {
+        isXbox = true;
+    }
 })());
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isXbox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

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

@@ -0,0 +1,14 @@
+/**
+ * We noticed that on Xbox game consoles and Universal windows platforms
+ * (presumably an Edge version is in cause here), the browser didn't send
+ * a "seeking" event if we were seeking at a 0 position initially.
+ *
+ * We could theoretically never seek at 0 initially as the initial position of
+ * an HTMLMediaElement should be at 0 anyway, but we still do it as a safe
+ * solution, as many devices have a buggy integration of HTML5 media API.
+ *
+ * This function returns `true` when we should avoid doing so, for now only for
+ * the non-standard behavior of those Edge platforms.
+ * @returns {number}
+ */
+export default function shouldPreventSeekingAt0Initially(): boolean;

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

@@ -0,0 +1,17 @@
+import { isIEOrEdge, isXbox } from "./browser_detection";
+/**
+ * We noticed that on Xbox game consoles and Universal windows platforms
+ * (presumably an Edge version is in cause here), the browser didn't send
+ * a "seeking" event if we were seeking at a 0 position initially.
+ *
+ * We could theoretically never seek at 0 initially as the initial position of
+ * an HTMLMediaElement should be at 0 anyway, but we still do it as a safe
+ * solution, as many devices have a buggy integration of HTML5 media API.
+ *
+ * This function returns `true` when we should avoid doing so, for now only for
+ * the non-standard behavior of those Edge platforms.
+ * @returns {number}
+ */
+export default function shouldPreventSeekingAt0Initially() {
+    return isXbox || isIEOrEdge;
+}

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

@@ -39,6 +39,7 @@ declare class ConfigHandler {
         DEFAULT_MAX_BUFFER_BEHIND: number;
         DEFAULT_MAX_VIDEO_BUFFER_SIZE: number;
         MAXIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
+        MINIMUM_MAX_BUFFER_AHEAD: Partial<Record<"audio" | "video" | "image" | "text", number>>;
         MAXIMUM_MAX_BUFFER_BEHIND: Partial<Record<"audio" | "video" | "image" | "text", number>>;
         DEFAULT_INITIAL_BITRATES: {
             audio: number;

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

@@ -88,7 +88,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.33.0-dev.2023120600";
+        _this.version = /* PLAYER_VERSION */ "3.33.0";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -1942,7 +1942,7 @@ var Player = /** @class */ (function (_super) {
         var segmentBufferStatus = this._priv_contentInfos
             .segmentBuffersStore.getStatus(bufferType);
         if (segmentBufferStatus.type === "initialized") {
-            segmentBufferStatus.value.synchronizeInventory();
+            segmentBufferStatus.value.synchronizeInventory(true);
             return segmentBufferStatus.value.getInventory();
         }
         return null;
@@ -2472,5 +2472,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.33.0-dev.2023120600";
+Player.version = /* PLAYER_VERSION */ "3.33.0";
 export default Player;

package/dist/_esm5.processed/core/decrypt/attach_media_keys.d.ts

@@ -21,8 +21,9 @@ import LoadedSessionsStore from "./utils/loaded_sessions_store";
  * Dispose of the MediaKeys instance attached to the given media element, if
  * one.
  * @param {Object} mediaElement
+ * @returns {Promise}
  */
-export declare function disableMediaKeys(mediaElement: HTMLMediaElement): void;
+export declare function disableMediaKeys(mediaElement: HTMLMediaElement): Promise<unknown>;
 /**
  * Attach MediaKeys and its associated state to an HTMLMediaElement.
  *

package/dist/_esm5.processed/core/decrypt/attach_media_keys.js

@@ -56,10 +56,11 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  * Dispose of the MediaKeys instance attached to the given media element, if
  * one.
  * @param {Object} mediaElement
+ * @returns {Promise}
  */
 export function disableMediaKeys(mediaElement) {
     MediaKeysInfosStore.setState(mediaElement, null);
-    eme.setMediaKeys(mediaElement, null)
+    return eme.setMediaKeys(mediaElement, null)
         .then(function () {
         log.info("DRM: MediaKeys disabled with success");
     })

package/dist/_esm5.processed/core/decrypt/init_media_keys.js

@@ -49,7 +49,9 @@ 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 { isWebOs } from "../../compat/browser_detection";
 import log from "../../log";
+import noop from "../../utils/noop";
 import { disableMediaKeys } from "./attach_media_keys";
 import getMediaKeysInfos from "./get_media_keys";
 /**
@@ -71,11 +73,17 @@ export default function initMediaKeys(mediaElement, keySystemsConfigs, cancelSig
                     shouldDisableOldMediaKeys = mediaElement.mediaKeys !== null &&
                         mediaElement.mediaKeys !== undefined &&
                         mediaKeys !== mediaElement.mediaKeys;
-                    if (shouldDisableOldMediaKeys) {
-                        log.debug("DRM: Disabling old MediaKeys");
-                        disableMediaKeys(mediaElement);
-                    }
-                    return [2 /*return*/, mediaKeysInfo];
+                    if (!shouldDisableOldMediaKeys) return [3 /*break*/, 4];
+                    log.debug("DRM: Disabling old MediaKeys");
+                    if (!isWebOs) return [3 /*break*/, 3];
+                    return [4 /*yield*/, disableMediaKeys(mediaElement)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    disableMediaKeys(mediaElement).catch(noop);
+                    _a.label = 4;
+                case 4: return [2 /*return*/, mediaKeysInfo];
             }
         });
     });

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

@@ -178,7 +178,7 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
             log.debug("Init: Initial time calculated:", initTime);
             return initTime;
         };
-        performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal).autoPlayResult
+        performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, true, cancelSignal).autoPlayResult
             .then(function () {
             return getLoadedReference(playbackObserver, mediaElement, true, cancelSignal)
                 .onUpdate(function (isLoaded, stopListening) {

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

@@ -331,7 +331,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         cancelSignal.register(function () {
             segmentBuffersStore.disposeAll();
         });
-        var _b = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
+        var _b = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, true, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
         if (cancelSignal.isCancelled()) {
             return;
         }

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

@@ -44,11 +44,13 @@ export default function getLoadedReference(playbackObserver, mediaElement, isDir
         }
         var minReadyState = shouldWaitForHaveEnoughData() ? 4 :
             3;
-        if (observation.readyState >= minReadyState && observation.currentRange !== null) {
-            if (!shouldValidateMetadata() || mediaElement.duration > 0) {
-                isLoaded.setValue(true);
-                listenCanceller.cancel();
-                return;
+        if (observation.readyState >= minReadyState) {
+            if (observation.currentRange !== null || observation.ended) {
+                if (!shouldValidateMetadata() || mediaElement.duration > 0) {
+                    isLoaded.setValue(true);
+                    listenCanceller.cancel();
+                    return;
+                }
             }
         }
     }, { includeLastObservation: true, clearSignal: listenCanceller.signal });

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

@@ -57,7 +57,8 @@ export interface IInitialSeekAndPlayObject {
  * @param {number|Function} startTime
  * @param {boolean} mustAutoPlay
  * @param {Function} onWarning
+ * @param {boolean} isDirectfile
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function performInitialSeekAndPlay(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver, startTime: number | (() => number), mustAutoPlay: boolean, onWarning: (err: IPlayerError) => void, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;
+export default function performInitialSeekAndPlay(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver, startTime: number | (() => number), mustAutoPlay: boolean, onWarning: (err: IPlayerError) => void, isDirectfile: boolean, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;

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

@@ -15,6 +15,9 @@
  */
 import { shouldValidateMetadata } from "../../../compat";
 import { READY_STATES } from "../../../compat/browser_compatibility_types";
+import { isSafariMobile } from "../../../compat/browser_detection";
+/* eslint-disable-next-line max-len */
+import shouldPreventSeekingAt0Initially from "../../../compat/should_prevent_seeking_at_0_initially";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
 import SharedReference from "../../../utils/reference";
@@ -26,10 +29,11 @@ import SharedReference from "../../../utils/reference";
  * @param {number|Function} startTime
  * @param {boolean} mustAutoPlay
  * @param {Function} onWarning
+ * @param {boolean} isDirectfile
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function performInitialSeekAndPlay(mediaElement, playbackObserver, startTime, mustAutoPlay, onWarning, cancelSignal) {
+export default function performInitialSeekAndPlay(mediaElement, playbackObserver, startTime, mustAutoPlay, onWarning, isDirectfile, cancelSignal) {
     var resolveAutoPlay;
     var rejectAutoPlay;
     var autoPlayResult = new Promise(function (res, rej) {
@@ -49,12 +53,39 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
     return { autoPlayResult: autoPlayResult, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed };
     function onLoadedMetadata() {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+        /** `true` if we asked the `PlaybackObserver` to perform an initial seek. */
+        var hasAskedForInitialSeek = false;
+        var performInitialSeek = function (initialSeekTime) {
+            log.info("Init: Set initial time", initialSeekTime);
+            playbackObserver.setCurrentTime(initialSeekTime);
+            hasAskedForInitialSeek = true;
+            initialSeekPerformed.setValue(true);
+            initialSeekPerformed.finish();
+        };
+        // `startTime` defined as a function might depend on metadata to make its
+        // choice, such as the content duration, minimum and/or maximum position.
+        //
+        // The RxPlayer might already know those through the Manifest file for
+        // non-Directfile contents, yet only through the `HTMLMediaElement` once a
+        // a sufficient `readyState` has been reached for directfile contents.
+        // So let's divide the two possibilities here.
         var initialTime = typeof startTime === "function" ? startTime() :
             startTime;
-        log.info("Init: Set initial time", initialTime);
-        playbackObserver.setCurrentTime(initialTime);
-        initialSeekPerformed.setValue(true);
-        initialSeekPerformed.finish();
+        if (shouldPreventSeekingAt0Initially() && initialTime === 0) {
+            initialSeekPerformed.setValue(true);
+            initialSeekPerformed.finish();
+        }
+        else if (isDirectfile && isSafariMobile) {
+            // On safari mobile (version 17.1.2) seeking too early cause the video
+            // to never buffer media data. Using setTimeout 0 defers the seek
+            // to a moment at which safari should be more able to handle a seek.
+            setTimeout(function () {
+                performInitialSeek(initialTime);
+            }, 0);
+        }
+        else {
+            performInitialSeek(initialTime);
+        }
         if (shouldValidateMetadata() && mediaElement.duration === 0) {
             var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
                 "falsely announced having loaded the content.");
@@ -63,8 +94,19 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
         if (cancelSignal.isCancelled()) {
             return;
         }
+        /**
+         * We only want to continue to `play` when a `seek` has actually been
+         * performed (if it has been asked). This boolean keep track of if the
+         * seek arised.
+         */
+        var isAwaitingSeek = hasAskedForInitialSeek;
         playbackObserver.listen(function (observation, stopListening) {
-            if (!observation.seeking &&
+            if (hasAskedForInitialSeek && observation.seeking) {
+                isAwaitingSeek = false;
+                return;
+            }
+            if (!isAwaitingSeek &&
+                !observation.seeking &&
                 observation.rebuffering === null &&
                 observation.readyState >= 1) {
                 stopListening();
@@ -85,6 +127,17 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             deregisterCancellation();
             return resolveAutoPlay({ type: "skipped" });
         }
+        else if (mediaElement.ended) {
+            // the video has ended state to true, executing VideoElement.play() will
+            // restart the video from the start, which is not wanted in most cases.
+            // returning "skipped" prevents the call to play() and fix the issue
+            log.warn("Init: autoplay is enabled but the video is ended. " +
+                "Skipping autoplay to prevent video to start again");
+            initialPlayPerformed.setValue(true);
+            initialPlayPerformed.finish();
+            deregisterCancellation();
+            return resolveAutoPlay({ type: "skipped" });
+        }
         var playResult;
         try {
             playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -224,7 +224,14 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 err :
                 new Error("An unknown error occured when doing operations " +
                     "on the SourceBuffer");
-            this._pendingTask.reject(error);
+            var task = this._pendingTask;
+            if (task.type === SegmentBufferOperation.Push &&
+                task.data.length === 0 &&
+                task.inventoryData !== null) {
+                this._segmentInventory.insertChunk(task.inventoryData, false);
+            }
+            this._pendingTask = null;
+            task.reject(error);
         }
     };
     /**
@@ -272,7 +279,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 switch (task.type) {
                     case SegmentBufferOperation.Push:
                         if (task.inventoryData !== null) {
-                            this._segmentInventory.insertChunk(task.inventoryData);
+                            this._segmentInventory.insertChunk(task.inventoryData, true);
                         }
                         break;
                     case SegmentBufferOperation.EndOfSegment:

package/dist/_esm5.processed/core/segment_buffers/implementations/image/image_segment_buffer.js

@@ -80,7 +80,7 @@ var ImageSegmentBuffer = /** @class */ (function (_super) {
         try {
             this._buffered.insert(startTime, endTime);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
             }
         }
         catch (err) {

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -231,7 +231,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
             return;
         }
         if (infos.inventoryInfos !== null) {
-            this._segmentInventory.insertChunk(infos.inventoryInfos);
+            this._segmentInventory.insertChunk(infos.inventoryInfos, true);
         }
         this._buffer.insert(cues, start, end);
         this._buffered.insert(start, end);

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -157,7 +157,7 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
             }
             this._buffered.insert(start, end);
             if (infos.inventoryInfos !== null) {
-                this._segmentInventory.insertChunk(infos.inventoryInfos);
+                this._segmentInventory.insertChunk(infos.inventoryInfos, true);
             }
         }
         catch (err) {

package/dist/_esm5.processed/core/segment_buffers/implementations/types.d.ts

@@ -131,8 +131,13 @@ export declare abstract class SegmentBuffer {
      * This methods allow to manually trigger a synchronization. It should be
      * called before retrieving Segment information from it (e.g. with
      * `getInventory`).
+     * @param {boolean} [skipLog] - This method may trigger a voluminous debug
+     * log once synchronization is finished 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.
      */
-    synchronizeInventory(): void;
+    synchronizeInventory(skipLog?: boolean): void;
     /**
      * Returns the currently buffered data for which the content is known with
      * the corresponding content information.

package/dist/_esm5.processed/core/segment_buffers/implementations/types.js

@@ -63,10 +63,15 @@ var SegmentBuffer = /** @class */ (function () {
      * This methods allow to manually trigger a synchronization. It should be
      * called before retrieving Segment information from it (e.g. with
      * `getInventory`).
+     * @param {boolean} [skipLog] - This method may trigger a voluminous debug
+     * log once synchronization is finished 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.
      */
-    SegmentBuffer.prototype.synchronizeInventory = function () {
+    SegmentBuffer.prototype.synchronizeInventory = function (skipLog) {
         // The default implementation just use the SegmentInventory
-        this._segmentInventory.synchronizeBuffered(this.getBufferedRanges());
+        this._segmentInventory.synchronizeBuffered(this.getBufferedRanges(), skipLog);
     };
     /**
      * Returns the currently buffered data for which the content is known with

package/dist/_esm5.processed/core/segment_buffers/index.d.ts

@@ -15,7 +15,7 @@
  */
 import BufferGarbageCollector from "./garbage_collector";
 import { IBufferType, IEndOfSegmentInfos, IEndOfSegmentOperation, IPushChunkInfos, IPushedChunkData, IPushOperation, IRemoveOperation, ISBOperation, SegmentBuffer, SegmentBufferOperation } from "./implementations";
-import { IBufferedChunk, IChunkContext, IInsertedChunkInfos } from "./inventory";
+import { ChunkStatus, IBufferedChunk, IChunkContext, IInsertedChunkInfos } from "./inventory";
 import SegmentBuffersStore, { ISegmentBufferOptions, ITextTrackSegmentBufferOptions } from "./segment_buffers_store";
 export default SegmentBuffersStore;
-export { BufferGarbageCollector, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, };
+export { BufferGarbageCollector, ChunkStatus, ISegmentBufferOptions, ITextTrackSegmentBufferOptions, SegmentBuffer, IBufferType, IBufferedChunk, IChunkContext, IInsertedChunkInfos, IPushChunkInfos, IPushedChunkData, IEndOfSegmentInfos, SegmentBufferOperation, ISBOperation, IEndOfSegmentOperation, IPushOperation, IRemoveOperation, };

package/dist/_esm5.processed/core/segment_buffers/inventory/index.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentInventory, { IBufferedChunk, IInsertedChunkInfos } from "./segment_inventory";
+import SegmentInventory, { ChunkStatus, IBufferedChunk, IInsertedChunkInfos } from "./segment_inventory";
 export default SegmentInventory;
-export { IBufferedChunk, IInsertedChunkInfos, };
+export { ChunkStatus, IBufferedChunk, IInsertedChunkInfos, };
 export { IBufferedHistoryEntry } from "./buffered_history";
 export { IChunkContext } from "./types";

package/dist/_esm5.processed/core/segment_buffers/inventory/segment_inventory.d.ts

@@ -16,6 +16,27 @@
 import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
 import { IBufferedHistoryEntry } from "./buffered_history";
 import { IChunkContext } from "./types";
+/** Categorization of a given chunk in the `SegmentInventory`. */
+export declare const enum ChunkStatus {
+    /**
+     * This chunk is only a part of a partially-pushed segment for now, meaning
+     * that it is only a sub-part of a requested segment that was not yet
+     * fully-loaded and pushed.
+     *
+     * Once and if the corresponding segment is fully-pushed, its `ChunkStatus`
+     * switches to `Complete`.
+     */
+    PartiallyPushed = 0,
+    /** This chunk corresponds to a fully-loaded segment. */
+    Complete = 1,
+    /**
+     * This chunk's push operation failed, in this scenario there is no certitude
+     * about the presence of that chunk in the buffer: it may not be present,
+     * partially-present, or fully-present depending on why that push operation
+     * failed, which is generally only known by the lower-level code.
+     */
+    Failed = 2
+}
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
     /**
@@ -69,14 +90,10 @@ export interface IBufferedChunk {
     /** Information on what that chunk actually contains. */
     infos: IChunkContext;
     /**
-     * If `true`, this chunk is only a partial chunk of a whole segment.
-     *
-     * Inversely, if `false`, this chunk is a whole segment whose inner chunks
-     * have all been fully pushed.
-     * In that condition, the `start` and `end` properties refer to that fully
-     * pushed segment.
+     * Status of this chunk.
+     * @see ChunkStatus
      */
-    partiallyPushed: boolean;
+    status: ChunkStatus;
     /**
      * If `true`, the segment as a whole is divided into multiple parts in the
      * buffer, with other segment(s) between them.
@@ -160,8 +177,13 @@ export default class SegmentInventory {
      * 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.
      */
-    synchronizeBuffered(buffered: TimeRanges): void;
+    synchronizeBuffered(buffered: TimeRanges, skipLog?: boolean): void;
     /**
      * Add a new chunk in the inventory.
      *
@@ -169,7 +191,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 }: IInsertedChunkInfos): void;
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos, succeed: boolean): void;
     /**
      * Indicate that inserted chunks can now be considered as a complete segment.
      * Take in argument the same content than what was given to `insertChunk` for