rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -22,12 +22,13 @@
  * position and what is currently buffered.
  */
 import nextTick from "next-tick";
-import { combineLatest as observableCombineLatest, concat as observableConcat, defer as observableDefer, EMPTY, merge as observableMerge, of as observableOf, ReplaySubject, Subject, } from "rxjs";
-import { finalize, ignoreElements, map, mergeMap, share, startWith, switchMap, take, takeWhile, withLatestFrom, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, concat as observableConcat, defer as observableDefer, EMPTY, ignoreElements, merge as observableMerge, mergeMap, of as observableOf, share, startWith, Subject, take, takeWhile, withLatestFrom, } from "rxjs";
 import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
+import { createSharedReference } from "../../../utils/reference";
 import EVENTS from "../events_generators";
+import DownloadingQueue from "./downloading_queue";
 import getBufferStatus from "./get_buffer_status";
 import getSegmentPriority from "./get_segment_priority";
 import pushInitSegment from "./push_init_segment";
@@ -45,208 +46,131 @@ import pushMediaSegment from "./push_media_segment";
  * @returns {Observable}
  */
 export default function RepresentationStream(_a) {
-    var clock$ = _a.clock$, content = _a.content, segmentBuffer = _a.segmentBuffer, segmentFetcher = _a.segmentFetcher, terminate$ = _a.terminate$, options = _a.options;
-    var manifest = content.manifest, period = content.period, adaptation = content.adaptation, representation = content.representation;
+    var content = _a.content, options = _a.options, playbackObserver = _a.playbackObserver, segmentBuffer = _a.segmentBuffer, segmentFetcher = _a.segmentFetcher, terminate$ = _a.terminate$;
+    var period = content.period, adaptation = content.adaptation, representation = content.representation;
     var bufferGoal$ = options.bufferGoal$, drmSystemId = options.drmSystemId, fastSwitchThreshold$ = options.fastSwitchThreshold$;
     var bufferType = adaptation.type;
-    var initSegment = representation.index.getInitSegment();
-    /**
-     * Saved initialization segment state for this representation.
-     * `null` if the initialization segment hasn't been loaded yet.
-     */
-    var initSegmentObject = initSegment === null ? { initializationData: null,
-        protectionDataUpdate: false,
-        initTimescale: undefined } :
-        null;
-    /** Segments queued for download in this RepresentationStream. */
-    var downloadQueue = [];
-    /** Emit to start/restart a downloading Queue. */
-    var startDownloadingQueue$ = new ReplaySubject(1);
-    /** Emit when the RepresentationStream asks to re-check which segments are needed. */
+    /** Saved initialization segment state for this representation. */
+    var initSegmentState = {
+        segment: representation.index.getInitSegment(),
+        segmentData: null,
+        isLoaded: false,
+    };
+    /** Allows to manually re-check which segments are needed. */
     var reCheckNeededSegments$ = new Subject();
+    /** Emit the last scheduled downloading queue for segments. */
+    var lastSegmentQueue = createSharedReference({
+        initSegment: null,
+        segmentQueue: [],
+    });
+    var hasInitSegment = initSegmentState.segment !== null;
+    /** Will load every segments in `lastSegmentQueue` */
+    var downloadingQueue = new DownloadingQueue(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
+    if (!hasInitSegment) {
+        initSegmentState.segmentData = null;
+        initSegmentState.isLoaded = true;
+    }
     /**
-     * Keep track of the information about the pending segment request.
-     * `null` if no segment request is pending in that RepresentationStream.
+     * `true` if the event notifying about encryption data has already been
+     * constructed.
+     * Allows to avoid sending multiple times protection events.
      */
-    var currentSegmentRequest = null;
+    var hasSentEncryptionData = false;
+    var encryptionEvent$ = EMPTY;
+    if (drmSystemId !== undefined) {
+        var encryptionData = representation.getEncryptionData(drmSystemId);
+        if (encryptionData.length > 0) {
+            encryptionEvent$ = observableOf.apply(void 0, encryptionData.map(function (d) {
+                return EVENTS.encryptionDataEncountered(d);
+            }));
+            hasSentEncryptionData = true;
+        }
+    }
+    /** Observable loading and pushing segments scheduled through `lastSegmentQueue`. */
+    var queue$ = downloadingQueue.start()
+        .pipe(mergeMap(onQueueEvent));
+    /** Observable emitting the stream "status" and filling `lastSegmentQueue`. */
     var status$ = observableCombineLatest([
-        clock$,
+        playbackObserver.observe(true),
         bufferGoal$,
         terminate$.pipe(take(1), startWith(null)),
-        reCheckNeededSegments$.pipe(startWith(undefined))
+        reCheckNeededSegments$.pipe(startWith(undefined)),
     ]).pipe(withLatestFrom(fastSwitchThreshold$), mergeMap(function (_a) {
-        var _b = _a[0], tick = _b[0], bufferGoal = _b[1], terminate = _b[2], fastSwitchThreshold = _a[1];
-        var status = getBufferStatus(content, tick, fastSwitchThreshold, bufferGoal, segmentBuffer);
+        var _b = _a[0], observation = _b[0], bufferGoal = _b[1], terminate = _b[2], fastSwitchThreshold = _a[1];
+        var wantedStartPosition = observation.position + observation.wantedTimeOffset;
+        var status = getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, segmentBuffer);
         var neededSegments = status.neededSegments;
+        var neededInitSegment = null;
         // Add initialization segment if required
         if (!representation.index.isInitialized()) {
-            if (initSegment === null) {
+            if (initSegmentState.segment === null) {
                 log.warn("Stream: Uninitialized index without an initialization segment");
             }
-            else if (initSegmentObject !== null) {
+            else if (initSegmentState.isLoaded) {
                 log.warn("Stream: Uninitialized index with an already loaded " +
                     "initialization segment");
             }
             else {
-                neededSegments.unshift({ segment: initSegment,
-                    priority: getSegmentPriority(period.start, tick) });
+                var wantedStart = observation.position + observation.wantedTimeOffset;
+                neededInitSegment = { segment: initSegmentState.segment,
+                    priority: getSegmentPriority(period.start, wantedStart) };
             }
         }
         else if (neededSegments.length > 0 &&
-            initSegment !== null &&
-            initSegmentObject === null) {
-            // prepend initialization segment
+            !initSegmentState.isLoaded &&
+            initSegmentState.segment !== null) {
             var initSegmentPriority = neededSegments[0].priority;
-            neededSegments.unshift({ segment: initSegment,
-                priority: initSegmentPriority });
+            neededInitSegment = { segment: initSegmentState.segment,
+                priority: initSegmentPriority };
         }
-        var mostNeededSegment = neededSegments[0];
-        if (terminate !== null) {
-            downloadQueue = [];
-            if (terminate.urgent) {
-                log.debug("Stream: urgent termination request, terminate.", bufferType);
-                startDownloadingQueue$.next(); // interrupt current requests
-                startDownloadingQueue$.complete(); // complete the downloading queue
-                return observableOf(EVENTS.streamTerminating());
-            }
-            else if (currentSegmentRequest === null ||
-                mostNeededSegment === undefined ||
-                currentSegmentRequest.segment.id !== mostNeededSegment.segment.id) {
-                log.debug("Stream: cancel request and terminate.", currentSegmentRequest === null, bufferType);
-                startDownloadingQueue$.next(); // interrupt the current request
-                startDownloadingQueue$.complete(); // complete the downloading queue
-                return observableOf(EVENTS.streamTerminating());
-            }
-            else if (currentSegmentRequest.priority !== mostNeededSegment.priority) {
-                var request$ = currentSegmentRequest.request$;
-                currentSegmentRequest.priority = mostNeededSegment.priority;
-                segmentFetcher.updatePriority(request$, mostNeededSegment.priority);
-            }
-            log.debug("Stream: terminate after request.", bufferType);
-        }
-        else if (mostNeededSegment === undefined) {
-            if (currentSegmentRequest !== null) {
-                log.debug("Stream: interrupt segment request.", bufferType);
-            }
-            downloadQueue = [];
-            startDownloadingQueue$.next(); // (re-)start with an empty queue
+        if (terminate === null) {
+            lastSegmentQueue.setValue({ initSegment: neededInitSegment,
+                segmentQueue: neededSegments });
         }
-        else if (currentSegmentRequest === null) {
-            log.debug("Stream: start downloading queue.", bufferType);
-            downloadQueue = neededSegments;
-            startDownloadingQueue$.next(); // restart the queue
-        }
-        else if (currentSegmentRequest.segment.id !== mostNeededSegment.segment.id) {
-            log.debug("Stream: restart download queue.", bufferType);
-            downloadQueue = neededSegments;
-            startDownloadingQueue$.next(); // restart the queue
-        }
-        else if (currentSegmentRequest.priority !== mostNeededSegment.priority) {
-            log.debug("Stream: update request priority.", bufferType);
-            var request$ = currentSegmentRequest.request$;
-            currentSegmentRequest.priority = mostNeededSegment.priority;
-            segmentFetcher.updatePriority(request$, mostNeededSegment.priority);
+        else if (terminate.urgent) {
+            log.debug("Stream: Urgent switch, terminate now.", bufferType);
+            lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
+            lastSegmentQueue.finish();
+            return observableOf(EVENTS.streamTerminating());
         }
         else {
-            log.debug("Stream: update downloading queue", bufferType);
-            // Update the previous queue to be all needed segments but the first one,
-            // for which a request is already pending
-            downloadQueue = neededSegments.slice().splice(1, neededSegments.length);
+            // Non-urgent termination wanted:
+            // End the download of the current media segment if pending and
+            // terminate once either that request is finished or another segment
+            // is wanted instead, whichever comes first.
+            var mostNeededSegment = neededSegments[0];
+            var initSegmentRequest = downloadingQueue.getRequestedInitSegment();
+            var currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
+            var nextQueue = currentSegmentRequest === null ||
+                mostNeededSegment === undefined ||
+                currentSegmentRequest.id !== mostNeededSegment.segment.id ?
+                [] :
+                [mostNeededSegment];
+            var nextInit = initSegmentRequest === null ? null :
+                neededInitSegment;
+            lastSegmentQueue.setValue({ initSegment: nextInit,
+                segmentQueue: nextQueue });
+            if (nextQueue.length === 0 && nextInit === null) {
+                log.debug("Stream: No request left, terminate", bufferType);
+                lastSegmentQueue.finish();
+                return observableOf(EVENTS.streamTerminating());
+            }
         }
         var bufferStatusEvt = observableOf({ type: "stream-status",
-            value: { period: period,
-                position: tick.position,
-                bufferType: bufferType,
-                imminentDiscontinuity: status.imminentDiscontinuity,
+            value: { period: period, position: observation.position, bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
                 hasFinishedLoading: status.hasFinishedLoading,
                 neededSegments: status.neededSegments } });
         return status.shouldRefreshManifest ?
             observableConcat(observableOf(EVENTS.needsManifestRefresh()), bufferStatusEvt) :
             bufferStatusEvt;
     }), takeWhile(function (e) { return e.type !== "stream-terminating"; }, true));
+    return observableMerge(status$, queue$, encryptionEvent$).pipe(share());
     /**
-     * `true` if the event notifying about encryption data has already been
-     * constructed.
-     * Allows to avoid sending multiple times protection events.
-     */
-    var hasSentEncryptionData = false;
-    var encryptionEvent$ = EMPTY;
-    if (drmSystemId !== undefined) {
-        var encryptionData = representation.getEncryptionData(drmSystemId);
-        if (encryptionData.length > 0) {
-            encryptionEvent$ = observableOf.apply(void 0, encryptionData.map(function (d) {
-                return EVENTS.encryptionDataEncountered(d);
-            }));
-            hasSentEncryptionData = true;
-        }
-    }
-    /**
-     * Stream Queue:
-     *   - download every segments queued sequentially
-     *   - when a segment is loaded, append it to the SegmentBuffer
-     */
-    var streamQueue$ = startDownloadingQueue$.pipe(switchMap(function () { return downloadQueue.length > 0 ? loadSegmentsFromQueue() : EMPTY; }), mergeMap(onLoaderEvent));
-    return observableConcat(encryptionEvent$, observableMerge(status$, streamQueue$).pipe(share()));
-    /**
-     * Request every Segment in the ``downloadQueue`` on subscription.
-     * Emit the data of a segment when a request succeeded.
-     *
-     * Important side-effects:
-     *   - Mutates `currentSegmentRequest` when doing and finishing a request.
-     *   - Will emit from reCheckNeededSegments$ Subject when it's done.
-     *
-     * Might emit warnings when a request is retried.
-     *
-     * Throws when the request will not be retried (configuration or un-retryable
-     * error).
-     * @returns {Observable}
-     */
-    function loadSegmentsFromQueue() {
-        var requestNextSegment$ = observableDefer(function () {
-            var currentNeededSegment = downloadQueue.shift();
-            if (currentNeededSegment === undefined) {
-                nextTick(function () { reCheckNeededSegments$.next(); });
-                return EMPTY;
-            }
-            var segment = currentNeededSegment.segment, priority = currentNeededSegment.priority;
-            var context = { manifest: manifest, period: period, adaptation: adaptation, representation: representation, segment: segment };
-            var request$ = segmentFetcher.createRequest(context, priority);
-            currentSegmentRequest = { segment: segment, priority: priority, request$: request$ };
-            return request$
-                .pipe(mergeMap(function (evt) {
-                switch (evt.type) {
-                    case "warning":
-                        return observableOf({ type: "retry",
-                            value: { segment: segment, error: evt.value } });
-                    case "chunk-complete":
-                        currentSegmentRequest = null;
-                        return observableOf({ type: "end-of-segment",
-                            value: { segment: segment } });
-                    case "interrupted":
-                        log.info("Stream: segment request interrupted temporarly.", segment);
-                        return EMPTY;
-                    case "chunk":
-                        var initTimescale = initSegmentObject === null || initSegmentObject === void 0 ? void 0 : initSegmentObject.initTimescale;
-                        return evt.parse(initTimescale).pipe(map(function (parserResponse) {
-                            return objectAssign({ segment: segment }, parserResponse);
-                        }));
-                    case "ended":
-                        return requestNextSegment$;
-                    default:
-                        assertUnreachable(evt);
-                }
-            }));
-        });
-        return requestNextSegment$
-            .pipe(finalize(function () { currentSegmentRequest = null; }));
-    }
-    /**
-     * React to event from `loadSegmentsFromQueue`.
+     * React to event from the `DownloadingQueue`.
      * @param {Object} evt
      * @returns {Observable}
      */
-    function onLoaderEvent(evt) {
-        var _a;
+    function onQueueEvent(evt) {
         switch (evt.type) {
             case "retry":
                 return observableConcat(observableOf({ type: "warning", value: evt.value.error }), observableDefer(function () {
@@ -260,56 +184,73 @@ export default function RepresentationStream(_a) {
                     }
                     return EMPTY; // else, ignore.
                 }));
-            case "parsed-init-segment": {
-                initSegmentObject = evt.value;
-                // Now that the initialization segment has been parsed - which may have
-                // included encryption information - take care of the encryption event
-                // if not already done.
-                var allEncryptionData = representation.getAllEncryptionData();
-                var initEncEvt$ = !hasSentEncryptionData &&
-                    allEncryptionData.length > 0 ? observableOf.apply(void 0, allEncryptionData.map(function (p) {
-                    return EVENTS.encryptionDataEncountered(p);
-                })) :
-                    EMPTY;
-                var pushEvent$ = pushInitSegment({ clock$: clock$,
-                    content: content,
-                    segment: evt.segment,
-                    segmentData: evt.value.initializationData,
-                    segmentBuffer: segmentBuffer });
-                return observableMerge(initEncEvt$, pushEvent$);
-            }
-            case "parsed-segment": {
-                var initSegmentData = (_a = initSegmentObject === null || initSegmentObject === void 0 ? void 0 : initSegmentObject.initializationData) !== null && _a !== void 0 ? _a : null;
-                var _b = evt.value, inbandEvents = _b.inbandEvents, needsManifestRefresh = _b.needsManifestRefresh;
-                // TODO better handle use cases like key rotation by not always grouping
-                // every protection data together? To check.
-                var segmentEncryptionEvent = evt.value.protectionDataUpdate &&
-                    !hasSentEncryptionData ? observableOf.apply(void 0, representation.getAllEncryptionData().map(function (p) {
-                    return EVENTS.encryptionDataEncountered(p);
-                })) :
-                    EMPTY;
-                var manifestRefresh$ = needsManifestRefresh === true ?
-                    observableOf(EVENTS.needsManifestRefresh()) :
-                    EMPTY;
-                var inbandEvents$ = inbandEvents !== undefined &&
-                    inbandEvents.length > 0 ?
-                    observableOf({ type: "inband-events",
-                        value: inbandEvents }) :
-                    EMPTY;
-                return observableConcat(segmentEncryptionEvent, manifestRefresh$, inbandEvents$, pushMediaSegment({ clock$: clock$,
-                    content: content,
-                    initSegmentData: initSegmentData,
-                    parsedSegment: evt.value,
-                    segment: evt.segment,
-                    segmentBuffer: segmentBuffer }));
-            }
+            case "parsed-init":
+            case "parsed-media":
+                return onParsedChunk(evt);
             case "end-of-segment": {
                 var segment = evt.value.segment;
                 return segmentBuffer.endOfSegment(objectAssign({ segment: segment }, content))
+                    // 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 */
                     .pipe(ignoreElements());
             }
+            case "end-of-queue":
+                reCheckNeededSegments$.next();
+                return EMPTY;
             default:
                 assertUnreachable(evt);
         }
     }
+    /**
+     * Process a chunk that has just been parsed by pushing it to the
+     * SegmentBuffer and emitting the right events.
+     * @param {Object} evt
+     * @returns {Observable}
+     */
+    function onParsedChunk(evt) {
+        if (evt.segmentType === "init") {
+            nextTick(function () {
+                reCheckNeededSegments$.next();
+            });
+            initSegmentState.segmentData = evt.initializationData;
+            initSegmentState.isLoaded = true;
+            // Now that the initialization segment has been parsed - which may have
+            // included encryption information - take care of the encryption event
+            // if not already done.
+            var allEncryptionData = representation.getAllEncryptionData();
+            var initEncEvt$ = !hasSentEncryptionData &&
+                allEncryptionData.length > 0 ? observableOf.apply(void 0, allEncryptionData.map(function (p) {
+                return EVENTS.encryptionDataEncountered(p);
+            })) :
+                EMPTY;
+            var pushEvent$ = pushInitSegment({ playbackObserver: playbackObserver, content: content, segment: evt.segment,
+                segmentData: evt.initializationData, segmentBuffer: segmentBuffer });
+            return observableMerge(initEncEvt$, pushEvent$);
+        }
+        else {
+            var inbandEvents = evt.inbandEvents, needsManifestRefresh = evt.needsManifestRefresh, protectionDataUpdate = evt.protectionDataUpdate;
+            // TODO better handle use cases like key rotation by not always grouping
+            // every protection data together? To check.
+            var segmentEncryptionEvent$ = protectionDataUpdate &&
+                !hasSentEncryptionData ? observableOf.apply(void 0, representation.getAllEncryptionData().map(function (p) {
+                return EVENTS.encryptionDataEncountered(p);
+            })) :
+                EMPTY;
+            var manifestRefresh$ = needsManifestRefresh === true ?
+                observableOf(EVENTS.needsManifestRefresh()) :
+                EMPTY;
+            var inbandEvents$ = inbandEvents !== undefined &&
+                inbandEvents.length > 0 ?
+                observableOf({ type: "inband-events",
+                    value: inbandEvents }) :
+                EMPTY;
+            var initSegmentData = initSegmentState.segmentData;
+            var pushMediaSegment$ = pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentData: initSegmentData, parsedSegment: evt,
+                segment: evt.segment, segmentBuffer: segmentBuffer });
+            return observableConcat(segmentEncryptionEvent$, manifestRefresh$, inbandEvents$, pushMediaSegment$);
+        }
+    }
 }

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

@@ -18,7 +18,6 @@ import { ICustomError } from "../../errors";
 import { Adaptation, ISegment, Period, Representation } from "../../manifest";
 import { IEMSG } from "../../parsers/containers/isobmff";
 import { IContentProtection } from "../eme";
-import { INeedsBufferFlush } from "../init";
 import { IBufferType } from "../segment_buffers";
 /** Information about a Segment waiting to be loaded by the Stream. */
 export interface IQueuedSegment {
@@ -328,20 +327,61 @@ export interface INeedsMediaSourceReload {
          * If `false`, we want to stay in a paused state at that point.
          */
         autoPlay: boolean;
+    };
+}
+/**
+ * A stream cannot go forward loading segments because it needs the
+ * `MediaSource` to be reloaded first.
+ *
+ * This is a Stream internal event before being translated into either an
+ * `INeedsMediaSourceReload` event or an `ILockedStreamEvent` depending on if
+ * the reloading action has to be taken now or when the corresponding Period
+ * becomes active.
+ */
+export interface IWaitingMediaSourceReloadInternalEvent {
+    type: "waiting-media-source-reload";
+    value: {
+        /** Period concerned. */
+        period: Period;
+        /** Buffer type concerned. */
+        bufferType: IBufferType;
         /**
-         * A `INeedsMediaSourceReload` is an event sent by a Stream (e.g. a
-         * `PeriodStream`, `AdaptationStream` or `RepresentationStream`) which is
-         * linked to a given `Period` in the `Manifest`.
-         *
-         * This property indicates the linked Period in question.
-         *
-         * This property is used internally by the Stream to filter out
-         * `INeedsMediaSourceReload` until the corresponding Period is the active
-         * one. Without it, we might reload the MediaSource too soon.
-         *
-         * Outside of the Stream's code, you probably don't need this information.
+         * The position in seconds and the time at which the MediaSource should be
+         * reset once it has been reloaded.
+         */
+        position: number;
+        /**
+         * If `true`, we want the HTMLMediaElement to play right after the reload is
+         * done.
+         * If `false`, we want to stay in a paused state at that point.
          */
+        autoPlay: boolean;
+    };
+}
+/**
+ * The stream is unable to load segments for a particular Period and buffer
+ * type until that Period becomes the currently-played Period.
+ *
+ * This might be the case for example when a track change happened for an
+ * upcoming Period, which necessitates the reloading of the media source -
+ * through a `INeedsMediaSourceReload` event once the Period is the current one.
+ * Here, the stream might stay in a locked mode for segments linked to that
+ * Period and buffer type, meaning it will not load any such segment until that
+ * next Period becomes the current one (in which case it will probably ask to
+ * reload).
+ *
+ * This event can be useful when investigating rebuffering situation: one might
+ * be due to the next Period not loading segment of a certain type because of a
+ * locked stream. In that case, playing until or seeking at the start of the
+ * corresponding Period should be enough to "unlock" the stream.
+ */
+export interface ILockedStreamEvent {
+    type: "locked-stream";
+    value: {
+        /** Period concerned. */
         period: Period;
+        /** Buffer type concerned. */
+        bufferType: IBufferType;
     };
 }
 /**
@@ -375,13 +415,21 @@ export interface INeedsDecipherabilityFlush {
         duration: number;
     };
 }
+/**
+ * Some situations might require the browser's buffers to be refreshed.
+ * This event is emitted when such situation arised.
+ */
+export interface INeedsBufferFlushEvent {
+    type: "needs-buffer-flush";
+    value: undefined;
+}
 /** Event sent by a `RepresentationStream`. */
-export declare type IRepresentationStreamEvent<T> = IStreamStatusEvent | IStreamEventAddedSegment<T> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamTerminatingEvent | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
+export declare type IRepresentationStreamEvent = IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamTerminatingEvent | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
 /** Event sent by an `AdaptationStream`. */
-export declare type IAdaptationStreamEvent<T> = IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<T> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
+export declare type IAdaptationStreamEvent = IBitrateEstimationChangeEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | INeedsBufferFlushEvent | IWaitingMediaSourceReloadInternalEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
 /** Event sent by a `PeriodStream`. */
-export declare type IPeriodStreamEvent = IPeriodStreamReadyEvent | INeedsMediaSourceReload | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsBufferFlush | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
+export declare type IPeriodStreamEvent = IPeriodStreamReadyEvent | IAdaptationChangeEvent | IWaitingMediaSourceReloadInternalEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsBufferFlushEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
 /** Event coming from function(s) managing multiple PeriodStreams. */
-export declare type IMultiplePeriodStreamsEvent = IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsMediaSourceReload | INeedsBufferFlush | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
+export declare type IMultiplePeriodStreamsEvent = IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsBufferFlushEvent | IAdaptationChangeEvent | IWaitingMediaSourceReloadInternalEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
 /** Every event sent by the `StreamOrchestrator`. */
-export declare type IStreamOrchestratorEvent = IActivePeriodChangedEvent | IEndOfStreamEvent | IResumeStreamEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsBufferFlush | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;
+export declare type IStreamOrchestratorEvent = IActivePeriodChangedEvent | IEndOfStreamEvent | IResumeStreamEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | ILockedStreamEvent | IBitrateEstimationChangeEvent | INeedsMediaSourceReload | INeedsBufferFlushEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamStatusEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IStreamWarningEvent | IInbandEventsEvent;

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

@@ -21,5 +21,5 @@
  * @returns {string}
  */
 export default function errorMessage(name, code, reason) {
-    return name + " (" + code + ") " + reason;
+    return "".concat(name, " (").concat(code, ") ").concat(reason);
 }

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

@@ -50,7 +50,9 @@ var RequestError = /** @class */ (function (_super) {
         Object.setPrototypeOf(_this, RequestError.prototype);
         _this.name = "RequestError";
         _this.url = url;
-        _this.xhr = xhr;
+        if (xhr !== undefined) {
+            _this.xhr = xhr;
+        }
         _this.status = status;
         _this.type = type;
         _this.message = type;

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

@@ -1,11 +1,13 @@
-import { Observable } from "rxjs";
-import { ISegmentLoaderContent, ISegmentLoaderEvent } from "../../../core/fetchers/segment/create_segment_loader";
+import { ISegmentFetcher } from "../../../core/fetchers/segment/segment_fetcher";
 import { ISegment } from "../../../manifest";
+import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../../../transports";
 import { IContentInfos } from "./types";
 export interface ICancellableRequest {
-    data?: Uint8Array;
+    data?: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> | ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>;
+    isComplete: boolean;
     error?: Error;
-    onData?: (data: Uint8Array) => void;
+    onData?: (data: ISegmentParserParsedInitChunk<Uint8Array | ArrayBuffer> | ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>) => void;
+    onComplete?: () => void;
     onError?: (err: Error) => void;
     cancel: () => void;
 }
@@ -17,7 +19,7 @@ export interface ICancellableRequest {
  * @param {Object} segment
  * @returns {Object}
  */
-export declare function createRequest(segmentLoader: (x: ISegmentLoaderContent) => Observable<ISegmentLoaderEvent<Uint8Array | ArrayBuffer | null>>, contentInfos: IContentInfos, segment: ISegment): ICancellableRequest;
+export declare function createRequest(segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>, contentInfos: IContentInfos, segment: ISegment): ICancellableRequest;
 /**
  * Free requests :
  * - Cancel the subscription to the observable