rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, EMPTY, exhaustMap, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, mergeScan, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, tap, } from "rxjs";
+import { combineLatest as observableCombineLatest, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, } from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
@@ -22,15 +22,14 @@ import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import objectAssign from "../../utils/object_assign";
 import ABRManager from "../abr";
-import { getCurrentKeySystem, } from "../eme";
-import createEMEManager from "./create_eme_manager";
+import { getCurrentKeySystem, } from "../decrypt";
 import openMediaSource from "./create_media_source";
 import EVENTS from "./events_generators";
 import getInitialTime from "./get_initial_time";
+import linkDrmAndContent from "./link_drm_and_content";
 import createMediaSourceLoader from "./load_on_media_source";
 import manifestUpdateScheduler from "./manifest_update_scheduler";
 import throwOnMediaError from "./throw_on_media_error";
-var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
 /**
  * Begin content playback.
  *
@@ -43,7 +42,7 @@ var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DEL
  *
  *   - download the content's Manifest and handle its refresh logic
  *
- *   - Perform EME management if needed
+ *   - Perform decryption if needed
  *
  *   - ask for the choice of the wanted Adaptation through events (e.g. to
  *     choose a language)
@@ -74,20 +73,21 @@ export default function InitializeOnMediaSource(_a) {
      * The MediaSource will be closed when subscriptions are down to 0.
      */
     var openMediaSource$ = openMediaSource(mediaElement).pipe(shareReplay({ refCount: true }));
-    /** Send content protection data to the `EMEManager`. */
+    /** Send content protection initialization data. */
     var protectedSegments$ = new Subject();
-    /** Create `EMEManager`, an observable which will handle content DRM. */
-    var emeManager$ = createEMEManager(mediaElement, keySystems, protectedSegments$).pipe(
+    /** Initialize decryption capabilities and MediaSource. */
+    var drmEvents$ = linkDrmAndContent(mediaElement, keySystems, protectedSegments$, openMediaSource$)
+        .pipe(
     // Because multiple Observables here depend on this Observable as a source,
     // we prefer deferring Subscription until those Observables are themselves
     // all subscribed to.
-    // This is needed because `emeManager$` might send events synchronously
+    // This is needed because `drmEvents$` might send events synchronously
     // on subscription. In that case, it might communicate those events directly
     // after the first Subscription is done, making the next subscription miss
     // out on those events, even if that second subscription is done
     // synchronously after the first one.
     // By calling `deferSubscriptions`, we ensure that subscription to
-    // `emeManager$` effectively starts after a very short delay, thus
+    // `drmEvents$` effectively starts after a very short delay, thus
     // ensuring that no such race condition can occur.
     deferSubscriptions(), share());
     /**
@@ -95,53 +95,16 @@ export default function InitializeOnMediaSource(_a) {
      * through a throwing Observable.
      */
     var mediaError$ = throwOnMediaError(mediaElement);
-    /**
-     * Wait for the MediaKeys to have been created before opening the MediaSource,
-     * after that second step is done, ask the EMEManager to attach the MediaKeys.
-     * Steps are done in that specific order to avoid compatibility issues.
-     *
-     * This Observable will emit when ready both the MediaSource and useful
-     * DRM-specific information.
-     */
-    var prepareMediaSource$ = emeManager$.pipe(mergeScan(function (acc, evt) {
-        switch (evt.type) {
-            case "eme-disabled":
-            case "attached-media-keys":
-                return observableOf({ isEmeReady: true,
-                    drmSystemId: acc.drmSystemId });
-            case "created-media-keys":
-                var drmSystemId_1 = evt.value.initializationDataSystemId;
-                return openMediaSource$.pipe(mergeMap(function () {
-                    // Now that the MediaSource has been opened and linked to the media
-                    // element we can attach the MediaKeys instance to the latter.
-                    evt.value.canAttachMediaKeys.setValue(true);
-                    // If the `disableMediaKeysAttachmentLock` option has been set to
-                    // `true`, we should not wait until the MediaKeys instance has been
-                    // attached to start loading the content.
-                    // TODO we may want to keep keySystems option knowledge in the EME
-                    // code
-                    var shouldDisableLock = evt.value.options
-                        .disableMediaKeysAttachmentLock === true;
-                    return shouldDisableLock ? observableOf({ isEmeReady: true, drmSystemId: drmSystemId_1 }) :
-                        EMPTY;
-                }), startWith({ isEmeReady: false, drmSystemId: drmSystemId_1 }));
-            default:
-                return EMPTY;
-        }
-    }, { isEmeReady: false, drmSystemId: undefined }), filter(function (emitted) { return emitted.isEmeReady; }), take(1), exhaustMap(function (_a) {
-        var drmSystemId = _a.drmSystemId;
-        return openMediaSource$
-            .pipe(map(function (mediaSource) { return ({ mediaSource: mediaSource, drmSystemId: drmSystemId }); }));
-    }));
+    var mediaSourceReady$ = drmEvents$.pipe(filter(function (evt) {
+        return evt.type === "decryption-ready" || evt.type === "decryption-disabled";
+    }), map(function (e) { return e.value; }), take(1));
     /** Load and play the content asked. */
-    var loadContent$ = observableCombineLatest([manifest$,
-        prepareMediaSource$]).pipe(mergeMap(function (_a) {
-        var manifestEvt = _a[0], mediaSourceInfo = _a[1];
+    var loadContent$ = observableCombineLatest([manifest$, mediaSourceReady$]).pipe(mergeMap(function (_a) {
+        var manifestEvt = _a[0], _b = _a[1], drmSystemId = _b.drmSystemId, initialMediaSource = _b.mediaSource;
         if (manifestEvt.type === "warning") {
             return observableOf(manifestEvt);
         }
         var manifest = manifestEvt.manifest;
-        var initialMediaSource = mediaSourceInfo.mediaSource, drmSystemId = mediaSourceInfo.drmSystemId;
         log.debug("Init: Calculating initial time");
         var initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
         log.debug("Init: Initial time calculated:", initialTime);
@@ -162,22 +125,7 @@ export default function InitializeOnMediaSource(_a) {
         var manifestEvents$ = observableMerge(fromEvent(manifest, "manifestUpdate")
             .pipe(map(function () { return EVENTS.manifestUpdate(); })), fromEvent(manifest, "decipherabilityUpdate")
             .pipe(map(EVENTS.decipherabilityUpdate)));
-        var setUndecipherableRepresentations$ = emeManager$.pipe(tap(function (evt) {
-            if (evt.type === "keys-update") {
-                manifest.updateDeciperabilitiesBasedOnKeyIds(evt.value);
-            }
-            else if (evt.type === "blacklist-protection-data") {
-                log.info("Init: blacklisting Representations based on protection data.");
-                manifest.addUndecipherableProtectionData(evt.value);
-            }
-        }), 
-        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-        // first type parameter as `any` instead of the perfectly fine `unknown`,
-        // leading to linter issues, as it forbids the usage of `any`.
-        // This is why we're disabling the eslint rule.
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-        ignoreElements());
-        return observableMerge(manifestEvents$, manifestUpdate$, setUndecipherableRepresentations$, recursiveLoad$)
+        return observableMerge(manifestEvents$, manifestUpdate$, recursiveLoad$)
             .pipe(startWith(EVENTS.manifestReady(manifest)), finalize(function () { scheduleRefresh$.complete(); }));
         /**
          * Load the content defined by the Manifest in the mediaSource given at the
@@ -199,6 +147,7 @@ export default function InitializeOnMediaSource(_a) {
                             canUseUnsafeMode: true });
                         return null;
                     case "manifest-might-be-out-of-sync":
+                        var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.getCurrent().OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
                         scheduleRefresh$.next({
                             completeRefresh: true,
                             canUseUnsafeMode: false,
@@ -240,5 +189,5 @@ export default function InitializeOnMediaSource(_a) {
             return observableMerge(handleReloads$, currentLoad$);
         }
     }));
-    return observableMerge(loadContent$, mediaError$, emeManager$);
+    return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()));
 }

package/dist/_esm5.processed/core/init/link_drm_and_content.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+import { Observable } from "rxjs";
+import { IContentProtection, IKeySystemOption } from "../decrypt";
+import { IWarningEvent } from "./types";
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystems
+ * @param {Observable<Object>} contentProtections$
+ * @param {Promise} linkingMedia$
+ * @returns {Observable}
+ */
+export default function linkDrmAndContent<T>(mediaElement: HTMLMediaElement, keySystems: IKeySystemOption[], contentProtections$: Observable<IContentProtection>, linkingMedia$: Observable<T>): Observable<IContentDecryptorInitEvent<T>>;
+export declare type IContentDecryptorInitEvent<T> = IDecryptionDisabledEvent<T> | IDecryptionReadyEvent<T> | IWarningEvent;
+/**
+ * Event emitted after deciding that no decryption logic will be launched for
+ * the current content.
+ */
+export interface IDecryptionDisabledEvent<T> {
+    type: "decryption-disabled";
+    value: {
+        /**
+         * Identify the current DRM's system ID.
+         * Here `undefined` as no decryption capability has been added.
+         */
+        drmSystemId: undefined;
+        /** The value outputed by the `linkingMedia$` Observable. */
+        mediaSource: T;
+    };
+}
+/**
+ * Event emitted when decryption capabilities have started and content can
+ * begin to be pushed on the HTMLMediaElement.
+ */
+export interface IDecryptionReadyEvent<T> {
+    type: "decryption-ready";
+    value: {
+        /**
+         * Identify the current DRM's systemId as an hexadecimal string, so the
+         * RxPlayer may be able to (optionally) only send the corresponding
+         * encryption initialization data.
+         * `undefined` if unknown.
+         */
+        drmSystemId: string | undefined;
+        /** The value outputed by the `linkingMedia$` Observable. */
+        mediaSource: T;
+    };
+}

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

@@ -0,0 +1,94 @@
+/**
+ * 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.
+ */
+import { map, merge as observableMerge, Observable, } from "rxjs";
+import { events, hasEMEAPIs, } from "../../compat/";
+import { EncryptedMediaError } from "../../errors";
+import features from "../../features";
+import log from "../../log";
+import { ContentDecryptorState, } from "../decrypt";
+var onEncrypted$ = events.onEncrypted$;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystems
+ * @param {Observable<Object>} contentProtections$
+ * @param {Promise} linkingMedia$
+ * @returns {Observable}
+ */
+export default function linkDrmAndContent(mediaElement, keySystems, contentProtections$, linkingMedia$) {
+    var encryptedEvents$ = observableMerge(onEncrypted$(mediaElement), contentProtections$);
+    if (features.ContentDecryptor == null) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Encrypted event but EME feature not activated");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "EME feature not activated.");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    if (keySystems.length === 0) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Ciphered media and no keySystem passed");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "Media is encrypted and no `keySystems` given");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    if (!hasEMEAPIs()) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Encrypted event but no EME API available");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "Encryption APIs not found.");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    log.debug("Init: Creating ContentDecryptor");
+    var ContentDecryptor = features.ContentDecryptor;
+    return new Observable(function (obs) {
+        var contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+        var mediaSub;
+        contentDecryptor.addEventListener("stateChange", function (state) {
+            if (state === ContentDecryptorState.WaitingForAttachment) {
+                contentDecryptor.removeEventListener("stateChange");
+                mediaSub = linkingMedia$.subscribe(function (mediaSource) {
+                    contentDecryptor.addEventListener("stateChange", function (newState) {
+                        if (newState === ContentDecryptorState.ReadyForContent) {
+                            obs.next({ type: "decryption-ready",
+                                value: { drmSystemId: contentDecryptor.systemId, mediaSource: mediaSource } });
+                            contentDecryptor.removeEventListener("stateChange");
+                        }
+                    });
+                    contentDecryptor.attach();
+                });
+            }
+        });
+        contentDecryptor.addEventListener("error", function (e) {
+            obs.error(e);
+        });
+        contentDecryptor.addEventListener("warning", function (w) {
+            obs.next({ type: "warning", value: w });
+        });
+        var protectionDataSub = contentProtections$.subscribe(function (data) {
+            contentDecryptor.onInitializationData(data);
+        });
+        return function () {
+            protectionDataSub.unsubscribe();
+            mediaSub === null || mediaSub === void 0 ? void 0 : mediaSub.unsubscribe();
+            contentDecryptor.dispose();
+        };
+    });
+}

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

@@ -17,7 +17,6 @@ import { defer as observableDefer, EMPTY, from as observableFrom, map, merge as
 import config from "../../config";
 import log from "../../log";
 import throttle from "../../utils/rx-throttle";
-var FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY = config.FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE = config.MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE = config.MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE;
 /**
  * Refresh the Manifest at the right time.
  * @param {Object} manifestUpdateSchedulerArguments
@@ -56,6 +55,7 @@ export default function manifestUpdateScheduler(_a) {
         var totalUpdateTime = parsingTime !== undefined ?
             parsingTime + (updatingTime !== null && updatingTime !== void 0 ? updatingTime : 0) :
             undefined;
+        var _b = config.getCurrent(), MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE = _b.MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE = _b.MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE;
         /**
          * "unsafeMode" is a mode where we unlock advanced Manifest parsing
          * optimizations with the added risk to lose some information.
@@ -194,6 +194,7 @@ export default function manifestUpdateScheduler(_a) {
                     var message = e instanceof Error ? e.message :
                         "unknown error";
                     log.warn("MUS: Attempt to update Manifest failed: ".concat(message), "Re-downloading the Manifest fully");
+                    var FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY = config.getCurrent().FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY;
                     return startManualRefreshTimer(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, minimumManifestUpdateInterval, newSendingTime)
                         .pipe(mergeMap(function () {
                         return refreshManifest({ completeRefresh: true, unsafeMode: false });

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

@@ -20,7 +20,6 @@ import { MediaError } from "../../errors";
 import log from "../../log";
 import { getNextRangeGap } from "../../utils/ranges";
 import EVENTS from "../stream/events_generators";
-var BUFFER_DISCONTINUITY_THRESHOLD = config.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = config.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = config.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = config.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = config.UNFREEZING_DELTA_POSITION;
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
@@ -106,6 +105,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
     var stall$ = playbackObserver.observe(true).pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
         var observation = _a[0], discontinuitiesStore = _a[1];
         var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        var _b = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
         if (freezing !== null) {
             var now = performance.now();
             var referenceTimestamp = prevFreezingState === null ?

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

@@ -17,7 +17,6 @@ import { combineLatest as observableCombineLatest, concat as observableConcat, d
 import config from "../../../config";
 import { fromEvent } from "../../../utils/event_emitter";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
-var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.STREAM_EVENT_EMITTER_POLL_INTERVAL;
 /**
  * Tells if a stream event has a duration
  * @param {Object} evt
@@ -109,6 +108,7 @@ function streamEventsEmitter(manifest, mediaElement, observation$) {
         if (!hasEvents) {
             return EMPTY;
         }
+        var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.getCurrent().STREAM_EVENT_EMITTER_POLL_INTERVAL;
         return observableCombineLatest([
             interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
             observation$,

package/dist/_esm5.processed/core/init/types.d.ts

@@ -15,10 +15,8 @@
  */
 import { ICustomError } from "../../errors";
 import Manifest, { Adaptation, Period, Representation } from "../../manifest";
-import { IAttachedMediaKeysEvent, IBlacklistProtectionDataEvent, ICreatedMediaKeysEvent, IEncryptedEvent, IInitDataIgnoredEvent, IKeysUpdateEvent, INoUpdateEvent, ISessionMessageEvent, ISessionUpdatedEvent } from "../eme";
 import SegmentBuffersStore from "../segment_buffers";
 import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IInbandEventsEvent, INeedsBufferFlushEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh } from "../stream";
-import { IEMEDisabledEvent } from "./create_eme_manager";
 import { IStreamEventEvent, IStreamEventSkipEvent } from "./stream_events_emitter";
 /** Event sent after the Manifest has been loaded and parsed for the first time. */
 export interface IManifestReadyEvent {
@@ -91,6 +89,6 @@ export { IRepresentationChangeEvent };
 /** Events emitted by a `MediaSourceLoader`. */
 export declare type IMediaSourceLoaderEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsMediaSourceReload | INeedsBufferFlushEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IInbandEventsEvent;
 /** Every events emitted by the `Init` module. */
-export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | IDecipherabilityUpdateEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
+export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | IDecipherabilityUpdateEvent | IWarningEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
 /** Events emitted by the `Init` module for directfile contents. */
-export declare type IDirectfileEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent;
+export declare type IDirectfileEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent;

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

@@ -39,7 +39,6 @@ import { toUint8Array } from "../../../../utils/byte_parsing";
 import hashBuffer from "../../../../utils/hash_buffer";
 import objectAssign from "../../../../utils/object_assign";
 import { SegmentBuffer, SegmentBufferOperation, } from "../types";
-var SOURCE_BUFFER_FLUSHING_INTERVAL = config.SOURCE_BUFFER_FLUSHING_INTERVAL;
 /**
  * Allows to push and remove new segments to a SourceBuffer in a FIFO queue (not
  * doing so can lead to browser Errors) while keeping an inventory of what has
@@ -69,6 +68,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         _this._pendingTask = null;
         _this._lastInitSegment = null;
         _this.codec = codec;
+        var SOURCE_BUFFER_FLUSHING_INTERVAL = config.getCurrent().SOURCE_BUFFER_FLUSHING_INTERVAL;
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
         // `update` or `updateend` events.
         // In that case, we're completely unable to continue the queue here and

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

@@ -38,7 +38,6 @@ import parseTextTrackToElements from "./parsers";
 import TextTrackCuesStore from "./text_track_cues_store";
 import updateProportionalElements from "./update_proportional_elements";
 var onEnded$ = events.onEnded$, onSeeked$ = events.onSeeked$, onSeeking$ = events.onSeeking$;
-var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL, TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.TEXT_TRACK_SIZE_CHECKS_INTERVAL;
 /**
  * Generate the interval at which TextTrack HTML Cues should be refreshed.
  * @param {HTMLMediaElement} videoElement
@@ -48,6 +47,7 @@ function generateRefreshInterval(videoElement) {
     var seeking$ = onSeeking$(videoElement);
     var seeked$ = onSeeked$(videoElement);
     var ended$ = onEnded$(videoElement);
+    var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
     var manualRefresh$ = observableMerge(seeked$, ended$);
     var autoRefresh$ = observableInterval(MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL)
         .pipe(startWith(null));
@@ -113,6 +113,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
                 _this._disableCurrentCues();
                 return;
             }
+            var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
             // to spread the time error, we divide the regular chosen interval.
             var time = Math.max(_this._videoElement.currentTime +
                 (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2, 0);
@@ -315,6 +316,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var proportionalCues = this._currentCues
             .filter(function (cue) { return cue.resolution !== null; });
         if (proportionalCues.length > 0) {
+            var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
             // update propertionally-sized elements periodically
             onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL)
                 .pipe(takeUntil(this._clearSizeUpdates$), takeUntil(this._destroy$))

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

@@ -18,6 +18,20 @@ import { IBufferedHistoryEntry } from "./buffered_history";
 import { IChunkContext } from "./types";
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
+    /**
+     * Complete size of the pushed chunk, in bytes.
+     * Note that this does not always reflect the memory imprint of the segment in
+     * memory:
+     *
+     *   1. It's the size of the original container file. A browser receiving that
+     *      segment might then transform it under another form that may be more or
+     *      less voluminous.
+     *
+     *   2. It's the size of the full chunk. In some scenarios only a sub-part of
+     *      that chunk is actually considered (examples: when using append
+     *      windows, when another chunk overlap that one etc.).
+     */
+    chunkSize: number | undefined;
     /**
      * Last inferred end in the media buffer this chunk ends at, in seconds.
      *
@@ -94,6 +108,8 @@ export interface IInsertedChunkInfos {
     representation: Representation;
     /** The Segment that chunk is linked to. */
     segment: ISegment;
+    /** Estimated size of the full pushed chunk, in bytes. */
+    chunkSize: number | undefined;
     /**
      * Start time, in seconds, this chunk most probably begins from after being
      * pushed.
@@ -153,7 +169,7 @@ export default class SegmentInventory {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    insertChunk({ period, adaptation, representation, segment, start, end }: IInsertedChunkInfos): void;
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }: IInsertedChunkInfos): 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

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

@@ -18,7 +18,6 @@ import log from "../../../log";
 import { areSameContent, } from "../../../manifest";
 import takeFirstSet from "../../../utils/take_first_set";
 import BufferedHistory from "./buffered_history";
-var BUFFERED_HISTORY_RETENTION_TIME = config.BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES = config.BUFFERED_HISTORY_MAXIMUM_ENTRIES, MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = config.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE, MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
 /**
  * Keep track of every chunk downloaded and currently in the linked media
  * buffer.
@@ -30,6 +29,7 @@ var BUFFERED_HISTORY_RETENTION_TIME = config.BUFFERED_HISTORY_RETENTION_TIME, BU
  */
 var SegmentInventory = /** @class */ (function () {
     function SegmentInventory() {
+        var _a = config.getCurrent(), BUFFERED_HISTORY_RETENTION_TIME = _a.BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES = _a.BUFFERED_HISTORY_MAXIMUM_ENTRIES;
         this._inventory = [];
         this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
     }
@@ -55,6 +55,7 @@ var SegmentInventory = /** @class */ (function () {
         var inventory = this._inventory;
         var inventoryIndex = 0; // Current index considered.
         var thisSegment = inventory[0]; // Current segmentInfos considered
+        var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
         /** Type of buffer considered, used for logs */
         var bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
         var rangesLength = buffered.length;
@@ -162,7 +163,7 @@ var SegmentInventory = /** @class */ (function () {
      * @param {Object} chunkInformation
      */
     SegmentInventory.prototype.insertChunk = function (_a) {
-        var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, start = _a.start, end = _a.end;
+        var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, chunkSize = _a.chunkSize, start = _a.start, end = _a.end;
         if (segment.isInit) {
             return;
         }
@@ -172,8 +173,7 @@ var SegmentInventory = /** @class */ (function () {
             return;
         }
         var inventory = this._inventory;
-        var newSegment = { partiallyPushed: true,
-            splitted: false, start: start, end: end, precizeStart: false,
+        var newSegment = { partiallyPushed: true, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
@@ -365,8 +365,15 @@ var SegmentInventory = /** @class */ (function () {
                             //  prevSegment  : |---------|
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
-                            log.debug("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
+                            log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
                             var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                                /**
+                                 * Note: this sadly means we're doing as if
+                                 * that chunk is present two times.
+                                 * Thankfully, this scenario should be
+                                 * fairly rare.
+                                 */
+                                chunkSize: segmentI.chunkSize,
                                 splitted: true,
                                 start: newSegment.end,
                                 end: segmentI.end,
@@ -499,9 +506,14 @@ var SegmentInventory = /** @class */ (function () {
                     }
                 }
                 var firstI = i;
+                var segmentSize = inventory[i].chunkSize;
                 i += 1;
                 while (i < inventory.length &&
                     areSameContent(inventory[i].infos, content)) {
+                    var chunkSize = inventory[i].chunkSize;
+                    if (segmentSize !== undefined && chunkSize !== undefined) {
+                        segmentSize += chunkSize;
+                    }
                     i++;
                 }
                 var lastI = i - 1;
@@ -513,6 +525,7 @@ var SegmentInventory = /** @class */ (function () {
                     i -= length_1;
                 }
                 this._inventory[firstI].partiallyPushed = false;
+                this._inventory[firstI].chunkSize = segmentSize;
                 this._inventory[firstI].end = lastEnd;
                 this._inventory[firstI].bufferedEnd = lastBufferedEnd;
                 this._inventory[firstI].splitted = splitted;
@@ -577,6 +590,7 @@ function bufferedStartLooksCoherent(thisSegment) {
     }
     var start = thisSegment.start, end = thisSegment.end;
     var duration = end - start;
+    var _a = config.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
     return Math.abs(start - thisSegment.bufferedStart) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         (thisSegment.bufferedEnd === undefined ||
@@ -597,6 +611,7 @@ function bufferedEndLooksCoherent(thisSegment) {
     }
     var start = thisSegment.start, end = thisSegment.end;
     var duration = end - start;
+    var _a = config.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
     return Math.abs(end - thisSegment.bufferedEnd) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         thisSegment.bufferedStart != null &&
@@ -612,6 +627,7 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
+    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
     if (firstSegmentInRange.bufferedStart !== undefined) {
         if (firstSegmentInRange.bufferedStart < rangeStart) {
             log.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
@@ -664,6 +680,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {Object} infos
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
+    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
     if (lastSegmentInRange.bufferedEnd !== undefined) {
         if (lastSegmentInRange.bufferedEnd > rangeEnd) {
             log.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.d.ts

@@ -76,6 +76,7 @@ export interface IAdaptationStreamArguments {
      * this AdaptationStream won't try to download new segments.
      */
     wantedBufferAhead: IReadOnlySharedReference<number>;
+    maxVideoBufferSize: IReadOnlySharedReference<number>;
 }
 /**
  * Various specific stream "options" which tweak the behavior of the
@@ -132,4 +133,4 @@ export interface IAdaptationStreamOptions {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function AdaptationStream({ abrManager, playbackObserver, content, options, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, }: IAdaptationStreamArguments): Observable<IAdaptationStreamEvent>;
+export default function AdaptationStream({ abrManager, playbackObserver, content, options, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, maxVideoBufferSize, }: IAdaptationStreamArguments): Observable<IAdaptationStreamEvent>;