rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/es2017/core/init/media_source_content_initializer.js

@@ -16,27 +16,32 @@
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import { MediaError } from "../../errors";
+import features from "../../features";
 import log from "../../log";
+import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import assert from "../../utils/assert";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
+import noop from "../../utils/noop";
 import objectAssign from "../../utils/object_assign";
 import SharedReference from "../../utils/reference";
+import SyncOrAsync from "../../utils/sync_or_async";
 import TaskCanceller from "../../utils/task_canceller";
 import AdaptiveRepresentationSelector from "../adaptive";
 import { getKeySystemConfiguration, } from "../decrypt";
 import { ManifestFetcher, SegmentFetcherCreator, } from "../fetchers";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator from "../stream";
-import { ContentInitializer } from "./types";
-import ContentTimeBoundariesObserver from "./utils/content_time_boundaries_observer";
-import openMediaSource from "./utils/create_media_source";
-import createStreamPlaybackObserver from "./utils/create_stream_playback_observer";
-import { maintainEndOfStream } from "./utils/end_of_stream";
+import { ContentInitializer, } from "./types";
+/* eslint-disable-next-line max-len */
+import createContentTimeBoundariesObserver from "./utils/create_content_time_boundaries_observer";
+import createCorePlaybackObserver from "./utils/create_core_playback_observer";
+import createMediaSource from "./utils/create_media_source";
+import DecipherabilityFreezeDetector from "./utils/DecipherabilityFreezeDetector";
 import getInitialTime from "./utils/get_initial_time";
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
+import MainThreadTextInterface from "./utils/main_thread_text_displayer_interface";
 import RebufferingController from "./utils/rebuffering_controller";
 import StreamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -61,7 +66,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         super();
         this._settings = settings;
         this._initCanceller = new TaskCanceller();
-        this._initialManifestProm = null;
+        this._manifest = null;
         const urls = settings.url === undefined ? undefined :
             [settings.url];
         this._manifestFetcher = new ManifestFetcher(urls, settings.transport, settings.manifestRequestSettings);
@@ -71,10 +76,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
      * For now, this mainly mean loading the Manifest document.
      */
     prepare() {
-        if (this._initialManifestProm !== null) {
+        if (this._manifest !== null) {
             return;
         }
-        this._initialManifestProm = createCancellablePromise(this._initCanceller.signal, (res, rej) => {
+        this._manifest = SyncOrAsync.createAsync(createCancellablePromise(this._initCanceller.signal, (res, rej) => {
             this._manifestFetcher.addEventListener("warning", (err) => this.trigger("warning", err));
             this._manifestFetcher.addEventListener("error", (err) => {
                 this.trigger("error", err);
@@ -83,7 +88,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             this._manifestFetcher.addEventListener("manifestReady", (manifest) => {
                 res(manifest);
             });
-        });
+        }));
         this._manifestFetcher.start();
         this._initCanceller.signal.register(() => {
             this._manifestFetcher.dispose();
@@ -130,8 +135,32 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         return createCancellablePromise(initCanceller.signal, (resolve) => {
             const { keySystems } = this._settings;
             /** Initialize decryption capabilities. */
-            const drmInitRef = initializeContentDecryption(mediaElement, keySystems, protectionRef, { onWarning: (err) => this.trigger("warning", err),
-                onError: (err) => this._onFatalError(err) }, initCanceller.signal);
+            const drmInitRef = initializeContentDecryption(mediaElement, keySystems, protectionRef, {
+                onWarning: (err) => this.trigger("warning", err),
+                onError: (err) => this._onFatalError(err),
+                onBlackListProtectionData: (val) => {
+                    // Ugly IIFE workaround to allow async event listener
+                    (async () => {
+                        var _a;
+                        if (this._manifest === null) {
+                            return;
+                        }
+                        const manifest = (_a = this._manifest.syncValue) !== null && _a !== void 0 ? _a : await this._manifest.getValueAsAsync();
+                        blackListProtectionDataOnManifest(manifest, val);
+                    })().catch(noop);
+                },
+                onKeyIdsCompatibilityUpdate: (updates) => {
+                    // Ugly IIFE workaround to allow async event listener
+                    (async () => {
+                        var _a;
+                        if (this._manifest === null) {
+                            return;
+                        }
+                        const manifest = (_a = this._manifest.syncValue) !== null && _a !== void 0 ? _a : await this._manifest.getValueAsAsync();
+                        updateKeyIdsDecipherabilityOnManifest(manifest, updates.whitelistedKeyIds, updates.blacklistedKeyIds, updates.delistedKeyIds);
+                    })().catch(noop);
+                },
+            }, initCanceller.signal);
             drmInitRef.onUpdate((drmStatus, stopListeningToDrmUpdates) => {
                 if (drmStatus.initializationState.type === "uninitialized") {
                     return;
@@ -139,7 +168,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 stopListeningToDrmUpdates();
                 const mediaSourceCanceller = new TaskCanceller();
                 mediaSourceCanceller.linkToSignal(initCanceller.signal);
-                openMediaSource(mediaElement, mediaSourceCanceller.signal)
+                createMediaSource(mediaElement, mediaSourceCanceller.signal)
                     .then((mediaSource) => {
                     const lastDrmStatus = drmInitRef.getValue();
                     if (lastDrmStatus.initializationState.type === "awaiting-media-link") {
@@ -171,19 +200,22 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         });
     }
     async _onInitialMediaSourceReady(mediaElement, initialMediaSource, playbackObserver, drmSystemId, protectionRef, initialMediaSourceCanceller) {
+        var _a;
         const { adaptiveOptions, autoPlay, bufferOptions, lowLatencyMode, segmentRequestOptions, speed, startAt, textTrackOptions, transport } = this._settings;
         const initCanceller = this._initCanceller;
-        assert(this._initialManifestProm !== null);
-        const manifestProm = this._initialManifestProm;
+        assert(this._manifest !== null);
         let manifest;
         try {
-            manifest = await manifestProm;
+            manifest = (_a = this._manifest.syncValue) !== null && _a !== void 0 ? _a : await this._manifest.getValueAsAsync();
         }
         catch (_e) {
             return; // The error should already have been processed through an event listener
         }
-        manifest.addEventListener("manifestUpdate", () => {
-            this.trigger("manifestUpdate", null);
+        manifest.addEventListener("manifestUpdate", (updates) => {
+            this.trigger("manifestUpdate", updates);
+        }, initCanceller.signal);
+        manifest.addEventListener("decipherabilityUpdate", (elts) => {
+            this.trigger("decipherabilityUpdate", elts);
         }, initCanceller.signal);
         log.debug("Init: Calculating initial time");
         const initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
@@ -235,7 +267,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 }
                 const newCanceller = new TaskCanceller();
                 newCanceller.linkToSignal(initCanceller.signal);
-                openMediaSource(mediaElement, newCanceller.signal)
+                createMediaSource(mediaElement, newCanceller.signal)
                     .then(newMediaSource => {
                     recursivelyLoadOnMediaSource(newMediaSource, reloadOrder.position, reloadOrder.autoPlay, newCanceller);
                 })
@@ -262,8 +294,25 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             const error = new MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
             return this._onFatalError(error);
         }
+        let textDisplayerInterface = null;
+        let textDisplayer = null;
+        if (this._settings.textTrackOptions.textTrackMode === "html" &&
+            features.htmlTextDisplayer !== null) {
+            textDisplayer = new features.htmlTextDisplayer(mediaElement, this._settings.textTrackOptions.textTrackElement);
+        }
+        else if (features.nativeTextDisplayer !== null) {
+            textDisplayer = new features.nativeTextDisplayer(mediaElement);
+        }
+        if (textDisplayer !== null) {
+            const sender = new MainThreadTextInterface(textDisplayer);
+            textDisplayerInterface = sender;
+            cancelSignal.register(() => {
+                sender.stop();
+                textDisplayer === null || textDisplayer === void 0 ? void 0 : textDisplayer.stop();
+            });
+        }
         /** Interface to create media buffers. */
-        const segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
+        const segmentBuffersStore = new SegmentBuffersStore(mediaSource, mediaElement.nodeName === "VIDEO", textDisplayerInterface);
         cancelSignal.register(() => {
             segmentBuffersStore.disposeAll();
         });
@@ -280,6 +329,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             if (isPerformed) {
                 stopListening();
                 const streamEventsEmitter = new StreamEventsEmitter(manifest, mediaElement, playbackObserver);
+                manifest.addEventListener("manifestUpdate", () => {
+                    streamEventsEmitter.onManifestUpdate(manifest);
+                }, cancelSignal);
                 streamEventsEmitter.addEventListener("event", (payload) => {
                     this.trigger("streamEvent", payload);
                 }, cancelSignal);
@@ -292,29 +344,44 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 });
             }
         }, { clearSignal: cancelSignal, emitCurrentValue: true });
-        const streamObserver = createStreamPlaybackObserver(playbackObserver, { autoPlay,
+        const coreObserver = createCorePlaybackObserver(playbackObserver, { autoPlay,
             manifest,
+            mediaSource,
+            textDisplayer,
             initialPlayPerformed,
             speed }, cancelSignal);
-        const rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
-        rebufferingController.addEventListener("needsReload", () => {
-            let position;
-            const lastObservation = playbackObserver.getReference().getValue();
-            if (lastObservation.position.isAwaitingFuturePosition()) {
-                position = lastObservation.position.getWanted();
-            }
-            else {
-                position = playbackObserver.getCurrentTime();
+        const rebufferingController = this._createRebufferingController(playbackObserver, manifest, speed, cancelSignal);
+        const decipherabilityFreezeDetector = new DecipherabilityFreezeDetector(segmentBuffersStore);
+        playbackObserver.listen((observation) => {
+            if (decipherabilityFreezeDetector.needToReload(observation)) {
+                let position;
+                const lastObservation = playbackObserver.getReference().getValue();
+                if (lastObservation.position.isAwaitingFuturePosition()) {
+                    position = lastObservation.position.getWanted();
+                }
+                else {
+                    position = playbackObserver.getCurrentTime();
+                }
+                const autoplay = initialPlayPerformed.getValue() ?
+                    !playbackObserver.getIsPaused() :
+                    autoPlay;
+                onReloadOrder({ position, autoPlay: autoplay });
             }
-            // NOTE couldn't both be always calculated at event destination?
-            // Maybe there are exceptions?
-            const autoplay = initialPlayPerformed.getValue() ?
-                !playbackObserver.getIsPaused() :
-                autoPlay;
-            onReloadOrder({ position, autoPlay: autoplay });
+        }, { clearSignal: cancelSignal });
+        // Synchronize SegmentBuffers with what has been buffered.
+        coreObserver.listen((observation) => {
+            ["video", "audio", "text"].forEach(tType => {
+                var _a;
+                const segmentBufferStatus = segmentBuffersStore.getStatus(tType);
+                if (segmentBufferStatus.type === "initialized") {
+                    segmentBufferStatus.value.synchronizeInventory((_a = observation.buffered[tType]) !== null && _a !== void 0 ? _a : []);
+                }
+            });
+        }, { clearSignal: cancelSignal });
+        const contentTimeBoundariesObserver = createContentTimeBoundariesObserver(manifest, mediaSource, coreObserver, segmentBuffersStore, {
+            onWarning: (err) => this.trigger("warning", err),
+            onPeriodChanged: (period) => this.trigger("activePeriodChanged", { period }),
         }, cancelSignal);
-        const contentTimeBoundariesObserver = this
-            ._createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal);
         /**
          * Emit a "loaded" events once the initial play has been performed and the
          * media can begin playback.
@@ -338,7 +405,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         });
         /* eslint-disable-next-line @typescript-eslint/no-this-alias */
         const self = this;
-        StreamOrchestrator({ manifest, initialPeriod }, streamObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, bufferOptions, handleStreamOrchestratorCallbacks(), cancelSignal);
+        StreamOrchestrator({ manifest, initialPeriod }, coreObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, bufferOptions, handleStreamOrchestratorCallbacks(), cancelSignal);
         /**
          * Returns Object handling the callbacks from a `StreamOrchestrator`, which
          * are basically how it communicates about events.
@@ -346,9 +413,21 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
          */
         function handleStreamOrchestratorCallbacks() {
             return {
-                needsBufferFlush: () => {
-                    const seekedTime = mediaElement.currentTime + 0.001;
-                    playbackObserver.setCurrentTime(seekedTime);
+                needsBufferFlush: (payload) => {
+                    var _a;
+                    let wantedSeekingTime;
+                    const currentTime = playbackObserver.getCurrentTime();
+                    const relativeResumingPosition = (_a = payload === null || payload === void 0 ? void 0 : payload.relativeResumingPosition) !== null && _a !== void 0 ? _a : 0;
+                    const canBeApproximateSeek = Boolean(payload === null || payload === void 0 ? void 0 : payload.relativePosHasBeenDefaulted);
+                    if (relativeResumingPosition === 0 && canBeApproximateSeek) {
+                        // in case relativeResumingPosition is 0, we still perform
+                        // a tiny seek to be sure that the browser will correclty reload the video.
+                        wantedSeekingTime = currentTime + 0.001;
+                    }
+                    else {
+                        wantedSeekingTime = currentTime + relativeResumingPosition;
+                    }
+                    playbackObserver.setCurrentTime(wantedSeekingTime);
                     // Seek again once data begins to be buffered.
                     // This is sadly necessary on some browsers to avoid decoding
                     // issues after a flush.
@@ -368,7 +447,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                         // Data is buffered around the current position
                         obs.currentRange !== null ||
                             // Or, for whatever reason, we have no buffer but we're already advancing
-                            obs.position.getPolled() > seekedTime + 0.1) {
+                            obs.position.getPolled() > wantedSeekingTime + 0.1) {
                             stopListening();
                             playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
                         }
@@ -442,12 +521,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 },
                 bitrateEstimateChange: (value) => self.trigger("bitrateEstimateChange", value),
                 needsMediaSourceReload: (payload) => {
-                    var _a;
-                    const lastObservation = streamObserver.getReference().getValue();
+                    var _a, _b, _c;
+                    const lastObservation = coreObserver.getReference().getValue();
                     const currentPosition = lastObservation.position.isAwaitingFuturePosition() ?
                         lastObservation.position.getWanted() :
-                        streamObserver.getCurrentTime();
-                    const isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
+                        ((_a = coreObserver.getCurrentTime()) !== null && _a !== void 0 ? _a : lastObservation.position.getPolled());
+                    const isPaused = (_c = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : coreObserver.getIsPaused()) !== null && _c !== void 0 ? _c : lastObservation.paused.last;
                     let position = currentPosition + payload.timeOffset;
                     if (payload.minimumPosition !== undefined) {
                         position = Math.max(payload.minimumPosition, position);
@@ -458,21 +537,21 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                     onReloadOrder({ position, autoPlay: !isPaused });
                 },
                 needsDecipherabilityFlush() {
-                    var _a;
+                    var _a, _b, _c, _d;
                     const keySystem = getKeySystemConfiguration(mediaElement);
                     if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
-                        const lastObservation = streamObserver.getReference().getValue();
+                        const lastObservation = coreObserver.getReference().getValue();
                         const position = lastObservation.position.isAwaitingFuturePosition() ?
                             lastObservation.position.getWanted() :
-                            streamObserver.getCurrentTime();
-                        const isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
+                            ((_a = coreObserver.getCurrentTime()) !== null && _a !== void 0 ? _a : lastObservation.position.getPolled());
+                        const isPaused = (_c = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : coreObserver.getIsPaused()) !== null && _c !== void 0 ? _c : lastObservation.paused.last;
                         onReloadOrder({ position, autoPlay: !isPaused });
                     }
                     else {
-                        const lastObservation = streamObserver.getReference().getValue();
+                        const lastObservation = coreObserver.getReference().getValue();
                         const position = lastObservation.position.isAwaitingFuturePosition() ?
                             lastObservation.position.getWanted() :
-                            streamObserver.getCurrentTime();
+                            ((_d = coreObserver.getCurrentTime()) !== null && _d !== void 0 ? _d : lastObservation.position.getPolled());
                         // simple seek close to the current position
                         // to flush the buffers
                         if (position + 0.001 < lastObservation.duration) {
@@ -495,57 +574,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             };
         }
     }
-    /**
-     * Creates a `ContentTimeBoundariesObserver`, a class indicating various
-     * events related to media time (such as duration updates, period changes,
-     * warnings about being out of the Manifest time boundaries or "endOfStream"
-     * management), handle those events and returns the class.
-     *
-     * Various methods from that class need then to be called at various events
-     * (see `ContentTimeBoundariesObserver`).
-     * @param {Object} manifest
-     * @param {MediaSource} mediaSource
-     * @param {Object} streamObserver
-     * @param {Object} segmentBuffersStore
-     * @param {Object} cancelSignal
-     * @returns {Object}
-     */
-    _createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
-        /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        const mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
-        cancelSignal.register(() => {
-            mediaSourceDurationUpdater.stopUpdating();
-        });
-        /** Allows to cancel a pending `end-of-stream` operation. */
-        let endOfStreamCanceller = null;
-        const contentTimeBoundariesObserver = new ContentTimeBoundariesObserver(manifest, streamObserver, segmentBuffersStore.getBufferTypes());
-        cancelSignal.register(() => {
-            contentTimeBoundariesObserver.dispose();
-        });
-        contentTimeBoundariesObserver.addEventListener("warning", (err) => this.trigger("warning", err));
-        contentTimeBoundariesObserver.addEventListener("periodChange", (period) => {
-            this.trigger("activePeriodChanged", { period });
-        });
-        contentTimeBoundariesObserver.addEventListener("endingPositionChange", (x) => mediaSourceDurationUpdater.updateDuration(x.endingPosition, x.isEnd));
-        contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
-            if (endOfStreamCanceller === null) {
-                endOfStreamCanceller = new TaskCanceller();
-                endOfStreamCanceller.linkToSignal(cancelSignal);
-                log.debug("Init: end-of-stream order received.");
-                maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
-            }
-        });
-        contentTimeBoundariesObserver.addEventListener("resumeStream", () => {
-            if (endOfStreamCanceller !== null) {
-                log.debug("Init: resume-stream order received.");
-                endOfStreamCanceller.cancel();
-                endOfStreamCanceller = null;
-            }
-        });
-        const endInfo = contentTimeBoundariesObserver.getCurrentEndingTime();
-        mediaSourceDurationUpdater.updateDuration(endInfo.endingPosition, endInfo.isEnd);
-        return contentTimeBoundariesObserver;
-    }
     /**
      * Creates a `RebufferingController`, a class trying to avoid various stalling
      * situations (such as rebuffering periods), and returns it.
@@ -564,8 +592,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    _createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal) {
-        const rebufferingController = new RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed);
+    _createRebufferingController(playbackObserver, manifest, speed, cancelSignal) {
+        const rebufferingController = new RebufferingController(playbackObserver, manifest, speed);
         // Bubble-up events
         rebufferingController.addEventListener("stalled", (evt) => this.trigger("stalled", evt));
         rebufferingController.addEventListener("unstalled", () => this.trigger("unstalled", null));
@@ -575,3 +603,83 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         return rebufferingController;
     }
 }
+/**
+ * Change the decipherability of Representations which have their key id in one
+ * of the given Arrays:
+ *
+ *   - Those who have a key id listed in `whitelistedKeyIds` will have their
+ *     decipherability updated to `true`
+ *
+ *   - Those who have a key id listed in `blacklistedKeyIds` will have their
+ *     decipherability updated to `false`
+ *
+ *   - Those who have a key id listed in `delistedKeyIds` will have their
+ *     decipherability updated to `undefined`.
+ *
+ * @param {Object} manifest
+ * @param {Array.<Uint8Array>} whitelistedKeyIds
+ * @param {Array.<Uint8Array>} blacklistedKeyIds
+ * @param {Array.<Uint8Array>} delistedKeyIds
+ */
+function updateKeyIdsDecipherabilityOnManifest(manifest, whitelistedKeyIds, blacklistedKeyIds, delistedKeyIds) {
+    manifest.updateRepresentationsDeciperability((ctx) => {
+        const { representation } = ctx;
+        if (representation.contentProtections === undefined) {
+            return representation.decipherable;
+        }
+        const contentKIDs = representation.contentProtections.keyIds;
+        if (contentKIDs !== undefined) {
+            for (const elt of contentKIDs) {
+                for (const blacklistedKeyId of blacklistedKeyIds) {
+                    if (areArraysOfNumbersEqual(blacklistedKeyId, elt.keyId)) {
+                        return false;
+                    }
+                }
+                for (const whitelistedKeyId of whitelistedKeyIds) {
+                    if (areArraysOfNumbersEqual(whitelistedKeyId, elt.keyId)) {
+                        return true;
+                    }
+                }
+                for (const delistedKeyId of delistedKeyIds) {
+                    if (areArraysOfNumbersEqual(delistedKeyId, elt.keyId)) {
+                        return undefined;
+                    }
+                }
+            }
+        }
+        return representation.decipherable;
+    });
+}
+/**
+ * Update decipherability to `false` to any Representation which is linked to
+ * the given initialization data.
+ * @param {Object} manifest
+ * @param {Object} initData
+ */
+function blackListProtectionDataOnManifest(manifest, initData) {
+    manifest.updateRepresentationsDeciperability((ctx) => {
+        var _a, _b;
+        const rep = ctx.representation;
+        if (rep.decipherable === false) {
+            return false;
+        }
+        const segmentProtections = (_b = (_a = rep.contentProtections) === null || _a === void 0 ? void 0 : _a.initData) !== null && _b !== void 0 ? _b : [];
+        for (const protection of segmentProtections) {
+            if (initData.type === undefined ||
+                protection.type === initData.type) {
+                const containedInitData = initData.values.getFormattedValues()
+                    .every(undecipherableVal => {
+                    return protection.values.some(currVal => {
+                        return (undecipherableVal.systemId === undefined ||
+                            currVal.systemId === undecipherableVal.systemId) &&
+                            areArraysOfNumbersEqual(currVal.data, undecipherableVal.data);
+                    });
+                });
+                if (containedInitData) {
+                    return false;
+                }
+            }
+        }
+        return rep.decipherable;
+    });
+}

package/dist/es2017/core/init/multithread/main_thread/multi_thread_content_initializer.d.ts

@@ -0,0 +1,167 @@
+import { IKeySystemOption } from "../../../../public_types";
+import { ITransportOptions } from "../../../../transports";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
+import { IAdaptiveRepresentationSelectorArguments } from "../../../adaptive";
+import { PlaybackObserver } from "../../../api";
+import { IManifestFetcherSettings } from "../../../fetchers";
+import { ContentInitializer, ITextDisplayerOptions } from "../../types";
+import { IInitialTimeOptions } from "../../utils/get_initial_time";
+/**
+ * @class MultiThreadContentInitializer
+ */
+export default class MultiThreadContentInitializer extends ContentInitializer {
+    /** Constructor settings associated to this `MultiThreadContentInitializer`. */
+    private _settings;
+    /**
+     * Information relative to the current loaded content.
+     *
+     * `null` when no content is prepared yet.
+     */
+    private _currentContentInfo;
+    /**
+     * `TaskCanceller` allowing to abort everything that the
+     * `MultiThreadContentInitializer` is doing.
+     */
+    private _initCanceller;
+    /**
+     * `TaskCanceller` allowing to abort and clean-up every task and resource
+     * linked to the current `MediaSource` instance.
+     *
+     * It may be triggered either at content stop (and thus at the same time than
+     * the `_initCanceller`) or when reloading the content.
+     */
+    private _currentMediaSourceCanceller;
+    /**
+     * Create a new `MultiThreadContentInitializer`, associated to the given
+     * settings.
+     * @param {Object} settings
+     */
+    constructor(settings: IInitializeArguments);
+    /**
+     * Perform non-destructive preparation steps, to prepare a future content.
+     */
+    prepare(): void;
+    /**
+     * Update URL of the Manifest.
+     * @param {Array.<string>|undefined} urls - URLs to reach that Manifest from
+     * the most prioritized URL to the least prioritized URL.
+     * @param {boolean} refreshNow - If `true` the resource in question (e.g.
+     * DASH's MPD) will be refreshed immediately.
+     */
+    updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void;
+    /**
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    start(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver): void;
+    dispose(): void;
+    private _onFatalError;
+    private _initializeContentDecryption;
+    private _hasTextBufferFeature;
+    private _reload;
+    /**
+     * Start-up modules and mechanisms (initial seek, auto-play etc.) needed each
+     * time a content is loaded AND re-loaded on a `HTMLMediaElement`, when the
+     * manifest is known.
+     *
+     * Note that this does not include reacting to incoming worker messages nor
+     * sending them, those actions have to be handled separately.
+     *
+     * @param {Object} parameters
+     * @param {Object} cancelSignal
+     * @returns {Object|null} - Playback Observer created for this content. `null`
+     * only if playback initialization failed (most likely because it has been
+     * cancelled).
+     */
+    private _setUpModulesOnNewMediaSource;
+    /**
+     * Initialize content playback if and only if those conditions are filled:
+     *   - The Manifest is fetched and stored in `this._currentContentInfo`.
+     *   - `drmInitializationStatus` indicates that DRM matters are initialized.
+     *   - `mediaSourceStatus` indicates that the MediaSource is attached to the
+     *     `mediaElement`.
+     *
+     * In other cases, this method will do nothing.
+     *
+     * To call when any of those conditions might become `true`, to start-up
+     * playback.
+     *
+     * @param {Object} parameters
+     * @returns {boolean} - Returns `true` if all conditions where met for
+     * playback start.
+     */
+    private _startPlaybackIfReady;
+    /**
+     * Handles Worker messages asking to create a MediaSource.
+     * @param {Object} msg - The worker's message received.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content plays.
+     * @param {Worker} worker - The WebWorker concerned, messages may be sent back
+     * to it.
+     */
+    private _onCreateMediaSourceMessage;
+}
+/** Arguments to give to the `InitializeOnMediaSource` function. */
+export interface IInitializeArguments {
+    worker: Worker;
+    /** Options concerning the ABR logic. */
+    adaptiveOptions: IAdaptiveRepresentationSelectorArguments;
+    /** `true` if we should play when loaded. */
+    autoPlay: boolean;
+    /** Options concerning the media buffers. */
+    bufferOptions: {
+        /** Buffer "goal" at which we stop downloading new segments. */
+        wantedBufferAhead: IReadOnlySharedReference<number>;
+        /** Buffer maximum size in kiloBytes at which we stop downloading */
+        maxVideoBufferSize: IReadOnlySharedReference<number>;
+        /** Max buffer size after the current position, in seconds (we GC further up). */
+        maxBufferAhead: IReadOnlySharedReference<number>;
+        /** Max buffer size before the current position, in seconds (we GC further down). */
+        maxBufferBehind: IReadOnlySharedReference<number>;
+        /**
+         * Enable/Disable fastSwitching: allow to replace lower-quality segments by
+         * higher-quality ones to have a faster transition.
+         */
+        enableFastSwitching: boolean;
+        /** Behavior when a new video and/or audio codec is encountered. */
+        onCodecSwitch: "continue" | "reload";
+    };
+    /** Every encryption configuration set. */
+    keySystems: IKeySystemOption[];
+    /** `true` to play low-latency contents optimally. */
+    lowLatencyMode: boolean;
+    /** Options relative to the streaming protocol. */
+    transportOptions: Omit<ITransportOptions, "manifestLoader" | "segmentLoader" | "representationFilter"> & {
+        manifestLoader: undefined;
+        segmentLoader: undefined;
+        representationFilter: string | undefined;
+    };
+    /** Settings linked to Manifest requests. */
+    manifestRequestSettings: IManifestFetcherSettings;
+    /** Configuration for the segment requesting logic. */
+    segmentRequestOptions: {
+        lowLatencyMode: boolean;
+        /**
+         * Amount of time after which a request should be aborted.
+         * `undefined` indicates that a default value is wanted.
+         * `-1` indicates no timeout.
+         */
+        requestTimeout: number | undefined;
+        /**
+         * Amount of time, in milliseconds, after which a request that hasn't receive
+         * the headers and status code should be aborted and optionnaly retried,
+         * depending on the maxRetry configuration.
+         */
+        connectionTimeout: number | undefined;
+        /** Maximum number of time a request on error will be retried. */
+        maxRetry: number | undefined;
+    };
+    /** Emit the playback rate (speed) set by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /** The configured starting position. */
+    startAt?: IInitialTimeOptions | undefined;
+    /** Configuration specific to the text track. */
+    textTrackOptions: ITextDisplayerOptions;
+    /** URL of the Manifest. `undefined` if unknown or not pertinent. */
+    url: string | undefined;
+}