rx-player 3.29.0-dev.2022090500 → 3.29.0-dev.2022091600

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

@@ -40,7 +40,7 @@ import EVENTS from "../events_generators";
 import PeriodStream from "../period";
 import ActivePeriodEmitter from "./active_period_emitter";
 import areStreamsComplete from "./are_streams_complete";
-import getBlacklistedRanges from "./get_blacklisted_ranges";
+import getTimeRangesForContent from "./get_time_ranges_for_content";
 /**
  * Create and manage the various Stream Observables needed for the content to
  * play:
@@ -204,29 +204,43 @@ export default function StreamOrchestrator(content, playbackObserver, representa
             }
             return launchConsecutiveStreamsForPeriod(newInitialPeriod);
         }));
-        // Free the buffer of undecipherable data
         var handleDecipherabilityUpdate$ = fromEvent(manifest, "decipherabilityUpdate")
-            .pipe(mergeMap(function (updates) {
+            .pipe(mergeMap(onDecipherabilityUpdates));
+        return observableMerge(restartStreamsWhenOutOfBounds$, handleDecipherabilityUpdate$, launchConsecutiveStreamsForPeriod(basePeriod));
+        function onDecipherabilityUpdates(updates) {
             var segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
             var ofCurrentType = updates
                 .filter(function (update) { return update.adaptation.type === bufferType; });
             if (ofCurrentType.length === 0 || segmentBufferStatus.type !== "initialized") {
                 return EMPTY; // no need to stop the current Streams.
             }
-            var undecipherableUpdates = ofCurrentType.filter(function (update) {
+            var segmentBuffer = segmentBufferStatus.value;
+            var resettedContent = ofCurrentType.filter(function (update) {
+                return update.representation.decipherable === undefined;
+            });
+            var undecipherableContent = ofCurrentType.filter(function (update) {
                 return update.representation.decipherable === false;
             });
-            var segmentBuffer = segmentBufferStatus.value;
-            var rangesToClean = getBlacklistedRanges(segmentBuffer, undecipherableUpdates);
-            if (rangesToClean.length === 0) {
-                // Nothing to clean => no buffer to flush.
-                return EMPTY;
-            }
-            // We have to remove the undecipherable media data and then ask the
-            // current media element to be "flushed"
+            /**
+             * Time ranges now containing undecipherable content.
+             * Those should first be removed and, depending on the platform, may
+             * need Supplementary actions as playback issues may remain even after
+             * removal.
+             */
+            var undecipherableRanges = getTimeRangesForContent(segmentBuffer, undecipherableContent);
+            /**
+             * Time ranges now containing content whose decipherability status came
+             * back to being unknown.
+             * To simplify its handling, those are just removed from the buffer.
+             * Less considerations have to be taken than for the `undecipherableRanges`.
+             */
+            var rangesToRemove = getTimeRangesForContent(segmentBuffer, resettedContent);
+            // First close all Stream currently active so they don't continue to
+            // load and push segments.
             enableOutOfBoundsCheck = false;
             destroyStreams$.next();
-            return observableConcat.apply(void 0, __spreadArray(__spreadArray([], rangesToClean.map(function (_a) {
+            /** Remove from the `SegmentBuffer` all the concerned time ranges. */
+            var cleanOperations = __spreadArray(__spreadArray([], undecipherableRanges, true), rangesToRemove, true).map(function (_a) {
                 var start = _a.start, end = _a.end;
                 if (start >= end) {
                     return EMPTY;
@@ -235,15 +249,15 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 return fromCancellablePromise(canceller, function () {
                     return segmentBuffer.removeBuffer(start, end, canceller.signal);
                 }).pipe(ignoreElements());
-            }), false), [
+            });
+            return observableConcat.apply(void 0, __spreadArray(__spreadArray([], cleanOperations, false), [
                 // Schedule micro task before checking the last playback observation
                 // to reduce the risk of race conditions where the next observation
                 // was going to be emitted synchronously.
                 nextTickObs().pipe(ignoreElements()),
                 playbackObserver.getReference().asObservable().pipe(take(1), mergeMap(function (observation) {
                     var _a;
-                    var shouldAutoPlay = !((_a = observation.paused.pending) !== null && _a !== void 0 ? _a : playbackObserver.getIsPaused());
-                    return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position.last, shouldAutoPlay, observation.duration)), observableDefer(function () {
+                    var restartStream$ = observableDefer(function () {
                         var _a;
                         var lastPosition = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
                         var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
@@ -251,10 +265,17 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             throw new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest.");
                         }
                         return launchConsecutiveStreamsForPeriod(newInitialPeriod);
-                    }));
+                    });
+                    if (needsFlushingAfterClean(observation, undecipherableRanges)) {
+                        var shouldAutoPlay = !((_a = observation.paused.pending) !== null && _a !== void 0 ? _a : playbackObserver.getIsPaused());
+                        return observableConcat(observableOf(EVENTS.needsDecipherabilityFlush(observation.position.last, shouldAutoPlay, observation.duration)), restartStream$);
+                    }
+                    else if (needsFlushingAfterClean(observation, rangesToRemove)) {
+                        return observableConcat(observableOf(EVENTS.needsBufferFlush()), restartStream$);
+                    }
+                    return restartStream$;
                 }))], false));
-        }));
-        return observableMerge(restartStreamsWhenOutOfBounds$, handleDecipherabilityUpdate$, launchConsecutiveStreamsForPeriod(basePeriod));
+        }
     }
     /**
      * Create lazily consecutive PeriodStreams:
@@ -342,3 +363,24 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         return observableMerge(currentStream$, nextPeriodStream$, destroyAll$.pipe(ignoreElements()));
     }
 }
+/**
+ * Returns `true` if low-level buffers have to be "flushed" after the given
+ * `cleanedRanges` time ranges have been removed from an audio or video
+ * SourceBuffer, to prevent playback issues.
+ * @param {Object} observation
+ * @param {Array.<Object>} cleanedRanges
+ * @returns {boolean}
+ */
+function needsFlushingAfterClean(observation, cleanedRanges) {
+    if (cleanedRanges.length === 0) {
+        return false;
+    }
+    var curPos = observation.position.last;
+    // Based on the playback direction, we just check whether we may encounter
+    // the corresponding ranges, without seeking or re-switching playback
+    // direction which is expected to lead to a low-level flush anyway.
+    // There's a 5 seconds security, just to be sure.
+    return observation.speed >= 0 ?
+        cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5 :
+        cleanedRanges[0].start <= curPos + 5;
+}

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

@@ -52,8 +52,12 @@ export default class DownloadingQueue<T> {
     private _mediaSegmentRequest;
     /** Interface used to load segments. */
     private _segmentFetcher;
-    /** Emit the timescale anounced in the initialization segment once parsed. */
-    private _initSegmentMetadata$;
+    /**
+     * Emit the timescale anounced in the initialization segment once parsed.
+     * `undefined` when this is not yet known.
+     * `null` when no initialization segment or timescale exists.
+     */
+    private _initSegmentInfoRef;
     /**
      * Some media segments might have been loaded and are only awaiting for the
      * initialization segment to be parsed before being parsed themselves.
@@ -86,13 +90,13 @@ export default class DownloadingQueue<T> {
     /**
      * Returns the initialization segment currently being requested.
      * Returns `null` if no initialization segment request is pending.
-     * @returns {Object}
+     * @returns {Object | null}
      */
     getRequestedInitSegment(): ISegment | null;
     /**
      * Returns the media segment currently being requested.
      * Returns `null` if no media segment request is pending.
-     * @returns {Object}
+     * @returns {Object | null}
      */
     getRequestedMediaSegment(): ISegment | null;
     /**

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

@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, defer as observableDefer, EMPTY, filter, finalize, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, share, switchMap, take, } from "rxjs";
+import { defer as observableDefer, EMPTY, filter, finalize, merge as observableMerge, Observable, of as observableOf, share, switchMap, } from "rxjs";
 import log from "../../../log";
 import assert from "../../../utils/assert";
-import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
+import createSharedReference from "../../../utils/reference";
+import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Class scheduling segment downloads for a single Representation.
  * @class DownloadingQueue
@@ -51,16 +52,16 @@ var DownloadingQueue = /** @class */ (function () {
         this._initSegmentRequest = null;
         this._mediaSegmentRequest = null;
         this._segmentFetcher = segmentFetcher;
-        this._initSegmentMetadata$ = new ReplaySubject(1);
+        this._initSegmentInfoRef = createSharedReference(undefined);
         this._mediaSegmentsAwaitingInitMetadata = new Set();
         if (!hasInitSegment) {
-            this._initSegmentMetadata$.next(undefined);
+            this._initSegmentInfoRef.setValue(null);
         }
     }
     /**
      * Returns the initialization segment currently being requested.
      * Returns `null` if no initialization segment request is pending.
-     * @returns {Object}
+     * @returns {Object | null}
      */
     DownloadingQueue.prototype.getRequestedInitSegment = function () {
         return this._initSegmentRequest === null ? null :
@@ -69,7 +70,7 @@ var DownloadingQueue = /** @class */ (function () {
     /**
      * Returns the media segment currently being requested.
      * Returns `null` if no media segment request is pending.
-     * @returns {Object}
+     * @returns {Object | null}
      */
     DownloadingQueue.prototype.getRequestedMediaSegment = function () {
         return this._mediaSegmentRequest === null ? null :
@@ -112,7 +113,7 @@ var DownloadingQueue = /** @class */ (function () {
                     return true;
                 }
                 if (currentSegmentRequest.priority !== nextItem.priority) {
-                    _this._segmentFetcher.updatePriority(currentSegmentRequest.request$, nextItem.priority);
+                    _this._segmentFetcher.updatePriority(currentSegmentRequest.request, nextItem.priority);
                 }
                 return false;
             }), switchMap(function (_a) {
@@ -124,7 +125,7 @@ var DownloadingQueue = /** @class */ (function () {
                 var initSegmentRequest = _this._initSegmentRequest;
                 if (next.initSegment !== null && initSegmentRequest !== null) {
                     if (next.initSegment.priority !== initSegmentRequest.priority) {
-                        _this._segmentFetcher.updatePriority(initSegmentRequest.request$, next.initSegment.priority);
+                        _this._segmentFetcher.updatePriority(initSegmentRequest.request, next.initSegment.priority);
                     }
                     return false;
                 }
@@ -150,57 +151,153 @@ var DownloadingQueue = /** @class */ (function () {
         var _this = this;
         var segmentQueue = this._downloadQueue.getValue().segmentQueue;
         var currentNeededSegment = segmentQueue[0];
-        var recursivelyRequestSegments = function (startingSegment) {
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias */
+        var self = this;
+        return observableDefer(function () {
+            return recursivelyRequestSegments(currentNeededSegment);
+        }).pipe(finalize(function () { _this._mediaSegmentRequest = null; }));
+        function recursivelyRequestSegments(startingSegment) {
             if (startingSegment === undefined) {
                 return observableOf({ type: "end-of-queue",
                     value: null });
             }
             var segment = startingSegment.segment, priority = startingSegment.priority;
-            var context = objectAssign({ segment: segment }, _this._content);
-            var request$ = _this._segmentFetcher.createRequest(context, priority);
-            _this._mediaSegmentRequest = { segment: segment, priority: priority, request$: request$ };
-            return request$
-                .pipe(mergeMap(function (evt) {
-                switch (evt.type) {
-                    case "retry":
-                        return observableOf({ type: "retry",
-                            value: { segment: segment, error: evt.value } });
-                    case "interrupted":
+            var context = objectAssign({ segment: segment }, self._content);
+            return new Observable(function (obs) {
+                /** TaskCanceller linked to this Observable's lifecycle. */
+                var canceller = new TaskCanceller();
+                /**
+                 * If `true` , the Observable has either errored, completed, or was
+                 * unsubscribed from.
+                 * This only conserves the Observable for the current segment's request,
+                 * not the other recursively-created future ones.
+                 */
+                var isComplete = false;
+                /**
+                 * Subscription to request the following segment (as this function is
+                 * recursive).
+                 * `undefined` if no following segment has been requested.
+                 */
+                var nextSegmentSubscription;
+                /**
+                 * If true, we're currently waiting for the initialization segment to be
+                 * parsed before parsing a received chunk.
+                 *
+                 * In that case, the `DownloadingQueue` has to remain careful to only
+                 * send further events and complete the Observable only once the
+                 * initialization segment has been parsed AND the chunk parsing has been
+                 * done (this can be done very simply by listening to the same
+                 * `ISharedReference`, as its callbacks are called in the same order
+                 * than the one in which they are added.
+                 */
+                var isWaitingOnInitSegment = false;
+                /** Scheduled actual segment request. */
+                var request = self._segmentFetcher.createRequest(context, priority, {
+                    /**
+                     * Callback called when the request has to be retried.
+                     * @param {Error} error
+                     */
+                    onRetry: function (error) {
+                        obs.next({ type: "retry", value: { segment: segment, error: error } });
+                    },
+                    /**
+                     * Callback called when the request has to be interrupted and
+                     * restarted later.
+                     */
+                    beforeInterrupted: function () {
                         log.info("Stream: segment request interrupted temporarly.", segment.id, segment.time);
-                        return EMPTY;
-                    case "ended":
-                        _this._mediaSegmentRequest = null;
-                        var lastQueue = _this._downloadQueue.getValue().segmentQueue;
-                        if (lastQueue.length === 0) {
-                            return observableOf({ type: "end-of-queue",
-                                value: null });
+                    },
+                    /**
+                     * Callback called when a decodable chunk of the segment is available.
+                     * @param {Function} parse - Function allowing to parse the segment.
+                     */
+                    onChunk: function (parse) {
+                        var initTimescale = self._initSegmentInfoRef.getValue();
+                        if (initTimescale !== undefined) {
+                            emitChunk(parse(initTimescale !== null && initTimescale !== void 0 ? initTimescale : undefined));
+                        }
+                        else {
+                            isWaitingOnInitSegment = true;
+                            // We could also technically call `waitUntilDefined` in both cases,
+                            // but I found it globally clearer to segregate the two cases,
+                            // especially to always have a meaningful `isWaitingOnInitSegment`
+                            // boolean which is a very important variable.
+                            self._initSegmentInfoRef.waitUntilDefined(function (actualTimescale) {
+                                emitChunk(parse(actualTimescale !== null && actualTimescale !== void 0 ? actualTimescale : undefined));
+                            }, { clearSignal: canceller.signal });
+                        }
+                    },
+                    /** Callback called after all chunks have been sent. */
+                    onAllChunksReceived: function () {
+                        if (!isWaitingOnInitSegment) {
+                            obs.next({ type: "end-of-segment",
+                                value: { segment: segment } });
+                        }
+                        else {
+                            self._mediaSegmentsAwaitingInitMetadata.add(segment.id);
+                            self._initSegmentInfoRef.waitUntilDefined(function () {
+                                obs.next({ type: "end-of-segment",
+                                    value: { segment: segment } });
+                                self._mediaSegmentsAwaitingInitMetadata.delete(segment.id);
+                                isWaitingOnInitSegment = false;
+                            }, { clearSignal: canceller.signal });
                         }
-                        else if (lastQueue[0].segment.id === segment.id) {
-                            lastQueue.shift();
+                    },
+                    /**
+                     * Callback called right after the request ended but before the next
+                     * requests are scheduled. It is used to schedule the next segment.
+                     */
+                    beforeEnded: function () {
+                        self._mediaSegmentRequest = null;
+                        if (isWaitingOnInitSegment) {
+                            self._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, { clearSignal: canceller.signal });
                         }
-                        return recursivelyRequestSegments(lastQueue[0]);
-                    case "chunk":
-                    case "chunk-complete":
-                        _this._mediaSegmentsAwaitingInitMetadata.add(segment.id);
-                        return _this._initSegmentMetadata$.pipe(take(1), map(function (initTimescale) {
-                            if (evt.type === "chunk-complete") {
-                                return { type: "end-of-segment",
-                                    value: { segment: segment } };
-                            }
-                            var parsed = evt.parse(initTimescale);
-                            assert(parsed.segmentType === "media", "Should have loaded a media segment.");
-                            return objectAssign({}, parsed, { type: "parsed-media", segment: segment });
-                        }), finalize(function () {
-                            _this._mediaSegmentsAwaitingInitMetadata.delete(segment.id);
-                        }));
-                    default:
-                        assertUnreachable(evt);
+                        else {
+                            continueToNextSegment();
+                        }
+                    },
+                }, canceller.signal);
+                request.catch(function (error) {
+                    if (!isComplete) {
+                        isComplete = true;
+                        obs.error(error);
+                    }
+                });
+                self._mediaSegmentRequest = { segment: segment, priority: priority, request: request };
+                return function () {
+                    self._mediaSegmentsAwaitingInitMetadata.delete(segment.id);
+                    if (nextSegmentSubscription !== undefined) {
+                        nextSegmentSubscription.unsubscribe();
+                    }
+                    if (isComplete) {
+                        return;
+                    }
+                    isComplete = true;
+                    isWaitingOnInitSegment = false;
+                    canceller.cancel();
+                };
+                function emitChunk(parsed) {
+                    assert(parsed.segmentType === "media", "Should have loaded a media segment.");
+                    obs.next(objectAssign({}, parsed, { type: "parsed-media", segment: segment }));
                 }
-            }));
-        };
-        return observableDefer(function () {
-            return recursivelyRequestSegments(currentNeededSegment);
-        }).pipe(finalize(function () { _this._mediaSegmentRequest = null; }));
+                function continueToNextSegment() {
+                    var lastQueue = self._downloadQueue.getValue().segmentQueue;
+                    if (lastQueue.length === 0) {
+                        obs.next({ type: "end-of-queue",
+                            value: null });
+                        isComplete = true;
+                        obs.complete();
+                        return;
+                    }
+                    else if (lastQueue[0].segment.id === segment.id) {
+                        lastQueue.shift();
+                    }
+                    isComplete = true;
+                    nextSegmentSubscription = recursivelyRequestSegments(lastQueue[0])
+                        .subscribe(obs);
+                }
+            });
+        }
     };
     /**
      * Internal logic performing initialization segment requests.
@@ -213,41 +310,61 @@ var DownloadingQueue = /** @class */ (function () {
             this._initSegmentRequest = null;
             return EMPTY;
         }
-        var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
-        var context = objectAssign({ segment: segment }, this._content);
-        var request$ = this._segmentFetcher.createRequest(context, priority);
-        this._initSegmentRequest = { segment: segment, priority: priority, request$: request$ };
-        return request$
-            .pipe(mergeMap(function (evt) {
-            switch (evt.type) {
-                case "retry":
-                    return observableOf({ type: "retry",
-                        value: { segment: segment, error: evt.value } });
-                case "interrupted":
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias */
+        var self = this;
+        return new Observable(function (obs) {
+            /** TaskCanceller linked to this Observable's lifecycle. */
+            var canceller = new TaskCanceller();
+            var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
+            var context = objectAssign({ segment: segment }, _this._content);
+            /**
+             * If `true` , the Observable has either errored, completed, or was
+             * unsubscribed from.
+             */
+            var isComplete = false;
+            var request = _this._segmentFetcher.createRequest(context, priority, {
+                onRetry: function (err) {
+                    obs.next({ type: "retry",
+                        value: { segment: segment, error: err } });
+                },
+                beforeInterrupted: function () {
                     log.info("Stream: init segment request interrupted temporarly.", segment.id);
-                    return EMPTY;
-                case "chunk":
-                    var parsed_1 = evt.parse(undefined);
-                    assert(parsed_1.segmentType === "init", "Should have loaded an init segment.");
-                    return observableConcat(observableOf(objectAssign({}, parsed_1, { type: "parsed-init", segment: segment })), 
-                    // We want to emit parsing information strictly AFTER the
-                    // initialization segment is emitted. Hence why we perform this
-                    // side-effect a posteriori in a concat operator
-                    observableDefer(function () {
-                        if (parsed_1.segmentType === "init") {
-                            _this._initSegmentMetadata$.next(parsed_1.initTimescale);
-                        }
-                        return EMPTY;
-                    }));
-                case "chunk-complete":
-                    return observableOf({ type: "end-of-segment",
+                },
+                beforeEnded: function () {
+                    self._initSegmentRequest = null;
+                    isComplete = true;
+                    obs.complete();
+                },
+                onChunk: function (parse) {
+                    var _a;
+                    var parsed = parse(undefined);
+                    assert(parsed.segmentType === "init", "Should have loaded an init segment.");
+                    obs.next(objectAssign({}, parsed, { type: "parsed-init", segment: segment }));
+                    if (parsed.segmentType === "init") {
+                        self._initSegmentInfoRef.setValue((_a = parsed.initTimescale) !== null && _a !== void 0 ? _a : null);
+                    }
+                },
+                onAllChunksReceived: function () {
+                    obs.next({ type: "end-of-segment",
                         value: { segment: segment } });
-                case "ended":
-                    return EMPTY; // Do nothing, just here to check every case
-                default:
-                    assertUnreachable(evt);
-            }
-        })).pipe(finalize(function () { _this._initSegmentRequest = null; }));
+                },
+            }, canceller.signal);
+            request.catch(function (error) {
+                if (!isComplete) {
+                    isComplete = true;
+                    obs.error(error);
+                }
+            });
+            _this._initSegmentRequest = { segment: segment, priority: priority, request: request };
+            return function () {
+                _this._initSegmentRequest = null;
+                if (isComplete) {
+                    return;
+                }
+                isComplete = true;
+                canceller.cancel();
+            };
+        });
     };
     return DownloadingQueue;
 }());

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

@@ -390,7 +390,9 @@ export interface ILockedStreamEvent {
  * decipherability status of some `Representation`(s).
  *
  * When that event is emitted, the current HTMLMediaElement's buffer might need
- * to be "flushed" to continue (e.g. through a little seek operation).
+ * to be "flushed" to continue (e.g. through a little seek operation) or in
+ * worst cases completely removed and re-created through the "reload" mechanism,
+ * depending on the platform.
  */
 export interface INeedsDecipherabilityFlush {
     type: "needs-decipherability-flush";

package/dist/_esm5.processed/errors/encrypted_media_error.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IEncryptedMediaErrorKeyStatusObject } from "../public_types";
 import { IEncryptedMediaErrorCode } from "./error_codes";
 /**
  * Error linked to the encryption of the media.
@@ -24,11 +25,15 @@ export default class EncryptedMediaError extends Error {
     readonly name: "EncryptedMediaError";
     readonly type: "ENCRYPTED_MEDIA_ERROR";
     readonly code: IEncryptedMediaErrorCode;
+    readonly keyStatuses?: IEncryptedMediaErrorKeyStatusObject[];
     message: string;
     fatal: boolean;
     /**
      * @param {string} code
      * @param {string} reason
      */
-    constructor(code: IEncryptedMediaErrorCode, reason: string);
+    constructor(code: "KEY_STATUS_CHANGE_ERROR", reason: string, supplementaryInfos: {
+        keyStatuses: IEncryptedMediaErrorKeyStatusObject[];
+    });
+    constructor(code: Omit<IEncryptedMediaErrorCode, "KEY_STATUS_CHANGE_ERROR">, reason: string);
 }

package/dist/_esm5.processed/errors/encrypted_media_error.js

@@ -38,11 +38,7 @@ import errorMessage from "./error_message";
  */
 var EncryptedMediaError = /** @class */ (function (_super) {
     __extends(EncryptedMediaError, _super);
-    /**
-     * @param {string} code
-     * @param {string} reason
-     */
-    function EncryptedMediaError(code, reason) {
+    function EncryptedMediaError(code, reason, supplementaryInfos) {
         var _this = _super.call(this) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(_this, EncryptedMediaError.prototype);
@@ -51,6 +47,9 @@ var EncryptedMediaError = /** @class */ (function (_super) {
         _this.code = code;
         _this.message = errorMessage(_this.name, _this.code, reason);
         _this.fatal = false;
+        if (typeof (supplementaryInfos === null || supplementaryInfos === void 0 ? void 0 : supplementaryInfos.keyStatuses) === "string") {
+            _this.keyStatuses = supplementaryInfos.keyStatuses;
+        }
         return _this;
     }
     return EncryptedMediaError;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import VideoThumbnailLoader, { DASH_LOADER, MPL_LOADER } from "./thumbnail_loader";
+import VideoThumbnailLoader, { DASH_LOADER, MPL_LOADER } from "./video_thumbnail_loader";
 export { DASH_LOADER, MPL_LOADER, };
 export default VideoThumbnailLoader;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/index.js

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import VideoThumbnailLoader, { DASH_LOADER, MPL_LOADER, } from "./thumbnail_loader";
+import VideoThumbnailLoader, { DASH_LOADER, MPL_LOADER, } from "./video_thumbnail_loader";
 export { DASH_LOADER, MPL_LOADER, };
 export default VideoThumbnailLoader;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/load_and_push_segment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { ISegmentFetcher, ISegmentLoaderContent } from "../../../core/fetchers/segment/segment_fetcher";
+import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
+import { CancellationSignal } from "../../../utils/task_canceller";
+/**
+ * @param {Object} segmentInfo
+ * @param {Object} segmentBuffer
+ * @param {Object} segmentFetcher
+ * @param {Object} cancelSignal
+ * @returns {Promise}
+ */
+export default function loadAndPushSegment(segmentInfo: ISegmentLoaderContent, segmentBuffer: AudioVideoSegmentBuffer, segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>, cancelSignal: CancellationSignal): Promise<unknown>;