rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/{abr/cached_segment_detector.d.ts → segment_buffers/inventory/types.d.ts}

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation, ISegment, Representation } from "../../manifest";
-/**
- * Returns a function used to determine if a segment was loaded
- * from cache or not.
- * @returns {function}
- */
-export default function generateCachedSegmentDetector(): (content: {
-    representation: Representation;
+import { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+/** Content information for a single buffered chunk */
+export interface IChunkContext {
+    /** Adaptation this chunk is related to. */
     adaptation: Adaptation;
+    /** Period this chunk is related to. */
+    period: Period;
+    /** Representation this chunk is related to. */
+    representation: Representation;
+    /** Segment this chunk is related to. */
     segment: ISegment;
-}, duration: number) => boolean;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export {};

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

@@ -118,7 +118,7 @@ export default class SegmentBuffersStore {
      */
     getStatus(bufferType: IBufferType): {
         type: "initialized";
-        value: SegmentBuffer<any>;
+        value: SegmentBuffer;
     } | {
         type: "uninitialized";
     } | {
@@ -161,7 +161,7 @@ export default class SegmentBuffersStore {
      * @param {Object|undefined} options
      * @returns {Object}
      */
-    createSegmentBuffer(bufferType: IBufferType, codec: string, options?: ISegmentBufferOptions): SegmentBuffer<any>;
+    createSegmentBuffer(bufferType: IBufferType, codec: string, options?: ISegmentBufferOptions): SegmentBuffer;
     /**
      * Dispose of the active SegmentBuffer for the given type.
      * @param {string} bufferType

package/dist/_esm5.processed/core/segment_buffers/segment_buffers_store.js

@@ -160,7 +160,7 @@ var SegmentBuffersStore = /** @class */ (function () {
     SegmentBuffersStore.prototype.disableSegmentBuffer = function (bufferType) {
         var currentValue = this._initializedSegmentBuffers[bufferType];
         if (currentValue === null) {
-            log.warn("SBS: The " + bufferType + " SegmentBuffer was already disabled.");
+            log.warn("SBS: The ".concat(bufferType, " SegmentBuffer was already disabled."));
             return;
         }
         if (currentValue !== undefined) {

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

@@ -22,15 +22,17 @@
  * ABRManager, and orchestrates a RepresentationStream, which will download and
  * push segments corresponding to a chosen Representation.
  */
-import { BehaviorSubject, Observable } from "rxjs";
+import { Observable } from "rxjs";
 import Manifest, { Adaptation, Period } from "../../../manifest";
+import { IReadOnlySharedReference } from "../../../utils/reference";
 import ABRManager from "../../abr";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
-import { IRepresentationStreamClockTick } from "../representation";
+import { IRepresentationStreamPlaybackObservation } from "../representation";
 import { IAdaptationStreamEvent } from "../types";
-/** `Clock tick` information needed by the AdaptationStream. */
-export interface IAdaptationStreamClockTick extends IRepresentationStreamClockTick {
+/** Regular playback information needed by the AdaptationStream. */
+export interface IAdaptationStreamPlaybackObservation extends IRepresentationStreamPlaybackObservation {
     /**
      * For the current SegmentBuffer, difference in seconds between the next position
      * where no segment data is available and the current position.
@@ -38,25 +40,25 @@ export interface IAdaptationStreamClockTick extends IRepresentationStreamClockTi
     bufferGap: number;
     /** `duration` property of the HTMLMediaElement on which the content plays. */
     duration: number;
-    /** Allows to fetch the current position at any time. */
-    getCurrentTime: () => number;
     /** If true, the player has been put on pause. */
     isPaused: boolean;
     /** Last "playback rate" asked by the user. */
     speed: number;
+    /**
+     * Only set for live contents.
+     * Difference between the live edge and the current position, in seconds.
+     */
+    liveGap: number | undefined;
 }
 /** Arguments given when creating a new `AdaptationStream`. */
-export interface IAdaptationStreamArguments<T> {
+export interface IAdaptationStreamArguments {
     /**
      * Module allowing to find the best Representation depending on the current
      * conditions like the current network bandwidth.
      */
     abrManager: ABRManager;
-    /**
-     * Regularly emit playback conditions.
-     * The main AdaptationStream logic will be triggered on each `tick`.
-     */
-    clock$: Observable<IAdaptationStreamClockTick>;
+    /** Regularly emit playback conditions. */
+    playbackObserver: IReadOnlyPlaybackObserver<IAdaptationStreamPlaybackObservation>;
     /** Content you want to create this Stream for. */
     content: {
         manifest: Manifest;
@@ -65,15 +67,15 @@ export interface IAdaptationStreamArguments<T> {
     };
     options: IAdaptationStreamOptions;
     /** SourceBuffer wrapper - needed to push media segments. */
-    segmentBuffer: SegmentBuffer<T>;
+    segmentBuffer: SegmentBuffer;
     /** Module used to fetch the wanted media segments. */
-    segmentFetcherCreator: SegmentFetcherCreator<any>;
+    segmentFetcherCreator: SegmentFetcherCreator;
     /**
      * "Buffer goal" wanted, or the ideal amount of time ahead of the current
      * position in the current SegmentBuffer. When this amount has been reached
      * this AdaptationStream won't try to download new segments.
      */
-    wantedBufferAhead$: BehaviorSubject<number>;
+    wantedBufferAhead: IReadOnlySharedReference<number>;
 }
 /**
  * Various specific stream "options" which tweak the behavior of the
@@ -130,4 +132,4 @@ export interface IAdaptationStreamOptions {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function AdaptationStream<T>({ abrManager, clock$, content, options, segmentBuffer, segmentFetcherCreator, wantedBufferAhead$, }: IAdaptationStreamArguments<T>): Observable<IAdaptationStreamEvent<T>>;
+export default function AdaptationStream({ abrManager, playbackObserver, content, options, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, }: IAdaptationStreamArguments): Observable<IAdaptationStreamEvent>;

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -22,15 +22,15 @@
  * ABRManager, and orchestrates a RepresentationStream, which will download and
  * push segments corresponding to a chosen Representation.
  */
-import { BehaviorSubject, concat as observableConcat, defer as observableDefer, EMPTY, merge as observableMerge, of as observableOf, } from "rxjs";
-import { catchError, distinctUntilChanged, exhaustMap, filter, map, mergeMap, share, take, tap, } from "rxjs/operators";
+import { catchError, concat as observableConcat, defer as observableDefer, distinctUntilChanged, EMPTY, exhaustMap, filter, map, merge as observableMerge, mergeMap, of as observableOf, share, take, tap, } from "rxjs";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import deferSubscriptions from "../../../utils/defer_subscriptions";
+import { createSharedReference, } from "../../../utils/reference";
 import EVENTS from "../events_generators";
+import reloadAfterSwitch from "../reload_after_switch";
 import RepresentationStream from "../representation";
-import reloadAfterSwitch from "../utils";
 import createRepresentationEstimator from "./create_representation_estimator";
 var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
 /**
@@ -48,7 +48,7 @@ var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
  * @returns {Observable}
  */
 export default function AdaptationStream(_a) {
-    var abrManager = _a.abrManager, clock$ = _a.clock$, content = _a.content, options = _a.options, segmentBuffer = _a.segmentBuffer, segmentFetcherCreator = _a.segmentFetcherCreator, wantedBufferAhead$ = _a.wantedBufferAhead$;
+    var abrManager = _a.abrManager, playbackObserver = _a.playbackObserver, content = _a.content, options = _a.options, segmentBuffer = _a.segmentBuffer, segmentFetcherCreator = _a.segmentFetcherCreator, wantedBufferAhead = _a.wantedBufferAhead;
     var directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
     /**
@@ -60,25 +60,39 @@ export default function AdaptationStream(_a) {
      * https://developers.google.com/web/updates/2017/10/quotaexceedederror
      */
     var bufferGoalRatioMap = {};
-    var _b = createRepresentationEstimator(content, abrManager, clock$), estimator$ = _b.estimator$, requestFeedback$ = _b.requestFeedback$, streamFeedback$ = _b.streamFeedback$;
+    var _b = createRepresentationEstimator(content, abrManager, playbackObserver.observe(true)), estimator$ = _b.estimator$, abrFeedbacks$ = _b.abrFeedbacks$;
     /** Allows the `RepresentationStream` to easily fetch media segments. */
-    var segmentFetcher = segmentFetcherCreator.createSegmentFetcher(adaptation.type, requestFeedback$);
+    var segmentFetcher = segmentFetcherCreator
+        .createSegmentFetcher(adaptation.type, {
+        onRequestBegin: function (value) {
+            abrFeedbacks$.next({ type: "requestBegin", value: value });
+        },
+        onRequestEnd: function (value) {
+            abrFeedbacks$.next({ type: "requestEnd", value: value });
+        },
+        onProgress: function (value) {
+            abrFeedbacks$.next({ type: "progress", value: value });
+        },
+        onMetrics: function (value) {
+            abrFeedbacks$.next({ type: "metrics", value: value });
+        },
+    });
     /**
-     * Emits each time an estimate is made through the `abrEstimate$` Observable,
-     * starting with the last one.
+     * Stores the last estimate emitted through the `abrEstimate$` Observable,
+     * starting with `null`.
      * This allows to easily rely on that value in inner Observables which might also
      * need the last already-considered value.
      */
-    var lastEstimate$ = new BehaviorSubject(null);
+    var lastEstimate = createSharedReference(null);
     /** Emits abr estimates on Subscription. */
-    var abrEstimate$ = estimator$.pipe(tap(function (estimate) { lastEstimate$.next(estimate); }), deferSubscriptions(), share());
+    var abrEstimate$ = estimator$.pipe(tap(function (estimate) { lastEstimate.setValue(estimate); }), deferSubscriptions(), share());
     /** Emit at each bitrate estimate done by the ABRManager. */
     var bitrateEstimate$ = abrEstimate$.pipe(filter(function (_a) {
         var bitrate = _a.bitrate;
         return bitrate != null;
     }), distinctUntilChanged(function (old, current) { return old.bitrate === current.bitrate; }), map(function (_a) {
         var bitrate = _a.bitrate;
-        log.debug("Stream: new " + adaptation.type + " bitrate estimate", bitrate);
+        log.debug("Stream: new ".concat(adaptation.type, " bitrate estimate"), bitrate);
         return EVENTS.bitrateEstimationChange(adaptation.type, bitrate);
     }));
     /** Recursively create `RepresentationStream`s according to the last estimate. */
@@ -106,13 +120,13 @@ export default function AdaptationStream(_a) {
         if (directManualBitrateSwitching &&
             fromEstimate.manual &&
             !isFirstEstimate) {
-            return reloadAfterSwitch(period, clock$, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
+            return reloadAfterSwitch(period, adaptation.type, playbackObserver, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
         }
         /**
          * Emit when the current RepresentationStream should be terminated to make
          * place for a new one (e.g. when switching quality).
          */
-        var terminateCurrentStream$ = lastEstimate$.pipe(filter(function (newEstimate) { return newEstimate === null ||
+        var terminateCurrentStream$ = lastEstimate.asObservable().pipe(filter(function (newEstimate) { return newEstimate === null ||
             newEstimate.representation.id !== representation.id ||
             (newEstimate.manual && !fromEstimate.manual); }), take(1), map(function (newEstimate) {
             if (newEstimate === null) {
@@ -141,21 +155,21 @@ export default function AdaptationStream(_a) {
          */
         var fastSwitchThreshold$ = !options.enableFastSwitching ?
             observableOf(0) : // Do not fast-switch anything
-            lastEstimate$.pipe(map(function (estimate) { return estimate === null ? undefined :
+            lastEstimate.asObservable().pipe(map(function (estimate) { return estimate === null ? undefined :
                 estimate.knownStableBitrate; }), distinctUntilChanged());
         var representationChange$ = observableOf(EVENTS.representationChange(adaptation.type, period, representation));
         return observableConcat(representationChange$, createRepresentationStream(representation, terminateCurrentStream$, fastSwitchThreshold$)).pipe(tap(function (evt) {
             if (evt.type === "representationChange" ||
                 evt.type === "added-segment") {
-                return streamFeedback$.next(evt);
+                return abrFeedbacks$.next(evt);
             }
         }), mergeMap(function (evt) {
             if (evt.type === "stream-terminating") {
-                var lastEstimate = lastEstimate$.getValue();
-                if (lastEstimate === null) {
+                var estimate = lastEstimate.getValue();
+                if (estimate === null) {
                     return EMPTY;
                 }
-                return recursivelyCreateRepresentationStreams(lastEstimate, false);
+                return recursivelyCreateRepresentationStreams(estimate, false);
             }
             return observableOf(evt);
         }));
@@ -172,29 +186,19 @@ export default function AdaptationStream(_a) {
             var bufferGoalRatio = oldBufferGoalRatio != null ? oldBufferGoalRatio :
                 1;
             bufferGoalRatioMap[representation.id] = bufferGoalRatio;
-            var bufferGoal$ = wantedBufferAhead$.pipe(map(function (wba) { return wba * bufferGoalRatio; }));
-            log.info("Stream: changing representation", adaptation.type, representation);
-            return RepresentationStream({ clock$: clock$,
-                content: { representation: representation,
-                    adaptation: adaptation,
-                    period: period,
-                    manifest: manifest },
-                segmentBuffer: segmentBuffer,
-                segmentFetcher: segmentFetcher,
-                terminate$: terminateCurrentStream$,
-                options: { bufferGoal$: bufferGoal$,
-                    drmSystemId: options.drmSystemId,
-                    fastSwitchThreshold$: fastSwitchThreshold$ } })
+            var bufferGoal$ = wantedBufferAhead.asObservable().pipe(map(function (wba) { return wba * bufferGoalRatio; }));
+            log.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
+            return RepresentationStream({ playbackObserver: playbackObserver, content: { representation: representation, adaptation: adaptation, period: period, manifest: manifest }, segmentBuffer: segmentBuffer, segmentFetcher: segmentFetcher, terminate$: terminateCurrentStream$,
+                options: { bufferGoal$: bufferGoal$, drmSystemId: options.drmSystemId, fastSwitchThreshold$: fastSwitchThreshold$ } })
                 .pipe(catchError(function (err) {
                 var formattedError = formatError(err, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `RepresentationStream` error",
                 });
                 if (formattedError.code === "BUFFER_FULL_ERROR") {
-                    var wantedBufferAhead = wantedBufferAhead$.getValue();
+                    var wba = wantedBufferAhead.getValue();
                     var lastBufferGoalRatio = bufferGoalRatio;
-                    if (lastBufferGoalRatio <= 0.25 ||
-                        wantedBufferAhead * lastBufferGoalRatio <= 2) {
+                    if (lastBufferGoalRatio <= 0.25 || wba * lastBufferGoalRatio <= 2) {
                         throw formattedError;
                     }
                     bufferGoalRatioMap[representation.id] = lastBufferGoalRatio - 0.25;

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

@@ -15,36 +15,28 @@
  */
 import { Observable, Subject } from "rxjs";
 import Manifest, { Adaptation } from "../../../manifest";
-import ABRManager, { IABREstimate, IABRManagerClockTick, IABRMetricsEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent } from "../../abr";
-import { IRepresentationChangeEvent, IStreamEventAddedSegment } from "../types";
+import ABRManager, { IABREstimate, IABRManagerPlaybackObservation, IABRStreamEvents } from "../../abr";
 /**
  * Create an "estimator$" Observable which will emit which Representation (from
  * the given `Adaptation`) is the best fit (see `IABREstimate` type definition)
  * corresponding to the current network and playback conditions.
  *
- * This function also returns two subjects that should be used to add feedback
- * helping the estimator to make its choices:
+ * This function also returns a subject that should be used to add feedback
+ * helping the estimator to make its choices.
  *
- *   - `requestFeedback$`: Subject through which information about new requests
- *     and network metrics should be emitted.
- *
- *   - `streamFeedback$`: Subject through which stream-related events should be
- *      emitted.
- *
- * You can look at the types defined for both of those Subjects to have more
- * information on what data is expected. The idea is to provide as much data as
- * possible so the estimation is as adapted as possible.
+ * You can look at the types defined for this Subject to have more information
+ * on what data is expected. The idea is to provide as much data as possible so
+ * the estimation is as adapted as possible.
  *
  * @param {Object} content
  * @param {Object} abrManager
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Object}
  */
 export default function createRepresentationEstimator({ manifest, adaptation }: {
     manifest: Manifest;
     adaptation: Adaptation;
-}, abrManager: ABRManager, clock$: Observable<IABRManagerClockTick>): {
+}, abrManager: ABRManager, observation$: Observable<IABRManagerPlaybackObservation>): {
     estimator$: Observable<IABREstimate>;
-    streamFeedback$: Subject<IStreamEventAddedSegment<unknown> | IRepresentationChangeEvent>;
-    requestFeedback$: Subject<IABRMetricsEvent | IABRRequestBeginEvent | IABRRequestProgressEvent | IABRRequestEndEvent>;
+    abrFeedbacks$: Subject<IABRStreamEvents>;
 };

package/dist/_esm5.processed/core/stream/adaptation/create_representation_estimator.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { distinctUntilChanged, map, switchMap, } from "rxjs/operators";
+import { Subject, distinctUntilChanged, map, merge as observableMerge, of as observableOf, switchMap, } from "rxjs";
 import { MediaError } from "../../../errors";
 import { fromEvent } from "../../../utils/event_emitter";
 /**
@@ -22,29 +21,21 @@ import { fromEvent } from "../../../utils/event_emitter";
  * the given `Adaptation`) is the best fit (see `IABREstimate` type definition)
  * corresponding to the current network and playback conditions.
  *
- * This function also returns two subjects that should be used to add feedback
- * helping the estimator to make its choices:
+ * This function also returns a subject that should be used to add feedback
+ * helping the estimator to make its choices.
  *
- *   - `requestFeedback$`: Subject through which information about new requests
- *     and network metrics should be emitted.
- *
- *   - `streamFeedback$`: Subject through which stream-related events should be
- *      emitted.
- *
- * You can look at the types defined for both of those Subjects to have more
- * information on what data is expected. The idea is to provide as much data as
- * possible so the estimation is as adapted as possible.
+ * You can look at the types defined for this Subject to have more information
+ * on what data is expected. The idea is to provide as much data as possible so
+ * the estimation is as adapted as possible.
  *
  * @param {Object} content
  * @param {Object} abrManager
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Object}
  */
-export default function createRepresentationEstimator(_a, abrManager, clock$) {
+export default function createRepresentationEstimator(_a, abrManager, observation$) {
     var manifest = _a.manifest, adaptation = _a.adaptation;
-    var streamFeedback$ = new Subject();
-    var requestFeedback$ = new Subject();
-    var abrEvents$ = observableMerge(streamFeedback$, requestFeedback$);
+    var abrFeedbacks$ = new Subject();
     var estimator$ = observableMerge(
     // subscribe "first" (hack as it is a merge here) to event
     fromEvent(manifest, "decipherabilityUpdate"), 
@@ -69,9 +60,7 @@ export default function createRepresentationEstimator(_a, abrManager, clock$) {
         }
         return true;
     }), switchMap(function (playableRepresentations) {
-        return abrManager.get$(adaptation.type, playableRepresentations, clock$, abrEvents$);
+        return abrManager.get$(adaptation.type, playableRepresentations, observation$, abrFeedbacks$);
     }));
-    return { estimator$: estimator$,
-        streamFeedback$: streamFeedback$,
-        requestFeedback$: requestFeedback$ };
+    return { estimator$: estimator$, abrFeedbacks$: abrFeedbacks$ };
 }

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

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AdaptationStream, { IAdaptationStreamArguments, IAdaptationStreamClockTick, IAdaptationStreamOptions } from "./adaptation_stream";
+import AdaptationStream, { IAdaptationStreamArguments, IAdaptationStreamPlaybackObservation, IAdaptationStreamOptions } from "./adaptation_stream";
 export default AdaptationStream;
-export { IAdaptationStreamArguments, IAdaptationStreamClockTick, IAdaptationStreamOptions, };
+export { IAdaptationStreamArguments, IAdaptationStreamPlaybackObservation, IAdaptationStreamOptions, };

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

@@ -17,9 +17,8 @@ import { Subject } from "rxjs";
 import { ICustomError } from "../../errors";
 import { Adaptation, ISegment, Period, Representation } from "../../manifest";
 import { IContentProtection } from "../eme";
-import { INeedsBufferFlush } from "../init";
 import { IBufferType } from "../segment_buffers";
-import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IEndOfStreamEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IResumeStreamEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh, IStreamTerminatingEvent, IStreamWarningEvent } from "./types";
+import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IEndOfStreamEvent, ILockedStreamEvent, INeedsBufferFlushEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IResumeStreamEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh, IStreamTerminatingEvent, IStreamWarningEvent, IWaitingMediaSourceReloadInternalEvent } from "./types";
 declare const EVENTS: {
     activePeriodChanged(period: Period): IActivePeriodChangedEvent;
     adaptationChange(bufferType: IBufferType, adaptation: Adaptation | null, period: Period): IAdaptationChangeEvent;
@@ -34,15 +33,22 @@ declare const EVENTS: {
     needsManifestRefresh(): IStreamNeedsManifestRefresh;
     manifestMightBeOufOfSync(): IStreamManifestMightBeOutOfSync;
     /**
-     * @param {Object} period - The Period to which the stream logic asking for a
-     * media source reload is linked.
      * @param {number} reloadAt - Position at which we should reload
      * @param {boolean} reloadOnPause - If `false`, stay on pause after reloading.
      * if `true`, automatically play once reloaded.
      * @returns {Object}
      */
-    needsMediaSourceReload(period: Period, reloadAt: number, reloadOnPause: boolean): INeedsMediaSourceReload;
-    needsBufferFlush(): INeedsBufferFlush;
+    needsMediaSourceReload(reloadAt: number, reloadOnPause: boolean): INeedsMediaSourceReload;
+    /**
+     * @param {string} bufferType - The buffer type for which the stream cannot
+     * currently load segments.
+     * @param {Object} period - The Period for which the stream cannot
+     * currently load segments.
+     * media source reload is linked.
+     * @returns {Object}
+     */
+    lockedStream(bufferType: IBufferType, period: Period): ILockedStreamEvent;
+    needsBufferFlush(): INeedsBufferFlushEvent;
     needsDecipherabilityFlush(position: number, autoPlay: boolean, duration: number): INeedsDecipherabilityFlush;
     periodStreamReady(type: IBufferType, period: Period, adaptation$: Subject<Adaptation | null>): IPeriodStreamReadyEvent;
     periodStreamCleared(type: IBufferType, period: Period): IPeriodStreamClearedEvent;
@@ -51,5 +57,6 @@ declare const EVENTS: {
     streamTerminating(): IStreamTerminatingEvent;
     resumeStream(): IResumeStreamEvent;
     warning(value: ICustomError): IStreamWarningEvent;
+    waitingMediaSourceReload(bufferType: IBufferType, period: Period, position: number, autoPlay: boolean): IWaitingMediaSourceReloadInternalEvent;
 };
 export default EVENTS;

package/dist/_esm5.processed/core/stream/events_generators.js

@@ -20,16 +20,11 @@ var EVENTS = {
     },
     adaptationChange: function (bufferType, adaptation, period) {
         return { type: "adaptationChange",
-            value: { type: bufferType,
-                adaptation: adaptation,
-                period: period } };
+            value: { type: bufferType, adaptation: adaptation, period: period } };
     },
     addedSegment: function (content, segment, buffered, segmentData) {
         return { type: "added-segment",
-            value: { content: content,
-                segment: segment,
-                segmentData: segmentData,
-                buffered: buffered } };
+            value: { content: content, segment: segment, segmentData: segmentData, buffered: buffered } };
     },
     bitrateEstimationChange: function (type, bitrate) {
         return { type: "bitrateEstimationChange",
@@ -52,18 +47,27 @@ var EVENTS = {
             value: undefined };
     },
     /**
-     * @param {Object} period - The Period to which the stream logic asking for a
-     * media source reload is linked.
      * @param {number} reloadAt - Position at which we should reload
      * @param {boolean} reloadOnPause - If `false`, stay on pause after reloading.
      * if `true`, automatically play once reloaded.
      * @returns {Object}
      */
-    needsMediaSourceReload: function (period, reloadAt, reloadOnPause) {
+    needsMediaSourceReload: function (reloadAt, reloadOnPause) {
         return { type: "needs-media-source-reload",
             value: { position: reloadAt,
-                autoPlay: reloadOnPause,
-                period: period } };
+                autoPlay: reloadOnPause } };
+    },
+    /**
+     * @param {string} bufferType - The buffer type for which the stream cannot
+     * currently load segments.
+     * @param {Object} period - The Period for which the stream cannot
+     * currently load segments.
+     * media source reload is linked.
+     * @returns {Object}
+     */
+    lockedStream: function (bufferType, period) {
+        return { type: "locked-stream",
+            value: { bufferType: bufferType, period: period } };
     },
     needsBufferFlush: function () {
         return { type: "needs-buffer-flush", value: undefined };
@@ -99,5 +103,9 @@ var EVENTS = {
     warning: function (value) {
         return { type: "warning", value: value };
     },
+    waitingMediaSourceReload: function (bufferType, period, position, autoPlay) {
+        return { type: "waiting-media-source-reload",
+            value: { bufferType: bufferType, period: period, position: position, autoPlay: autoPlay } };
+    },
 };
 export default EVENTS;

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import StreamOrchestrator, { IStreamOrchestratorClockTick, IStreamOrchestratorOptions } from "./orchestrator";
+import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./orchestrator";
 export * from "./types";
 export default StreamOrchestrator;
-export { IStreamOrchestratorClockTick, IStreamOrchestratorOptions, };
+export { IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, };

package/dist/_esm5.processed/core/stream/orchestrator/active_period_emitter.d.ts

@@ -15,7 +15,7 @@
  */
 import { Observable } from "rxjs";
 import { Period } from "../../../manifest";
-import { IMultiplePeriodStreamsEvent } from "../types";
+import { IStreamOrchestratorEvent } from "../types";
 /**
  * Emit the active Period each times it changes.
  *
@@ -54,4 +54,4 @@ import { IMultiplePeriodStreamsEvent } from "../types";
  * one is removed.
  * @returns {Observable}
  */
-export default function ActivePeriodEmitter(buffers$: Array<Observable<IMultiplePeriodStreamsEvent>>): Observable<Period | null>;
+export default function ActivePeriodEmitter(buffers$: Array<Observable<IStreamOrchestratorEvent>>): Observable<Period | null>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, } from "rxjs";
-import { distinctUntilChanged, filter, map, scan, } from "rxjs/operators";
+import { distinctUntilChanged, filter, map, merge as observableMerge, scan, } from "rxjs";
 /**
  * Emit the active Period each times it changes.
  *
@@ -94,14 +93,14 @@ export default function ActivePeriodEmitter(buffers$) {
                 {
                     var _b = evt.value, period = _b.period, type = _b.type;
                     var currentInfos = acc[period.id];
-                    if (currentInfos !== undefined && !currentInfos.buffers.has(type)) {
-                        currentInfos.buffers.add(type);
-                    }
-                    else {
+                    if (currentInfos === undefined) {
                         var bufferSet = new Set();
                         bufferSet.add(type);
                         acc[period.id] = { period: period, buffers: bufferSet };
                     }
+                    else if (!currentInfos.buffers.has(type)) {
+                        currentInfos.buffers.add(type);
+                    }
                 }
                 break;
         }

package/dist/_esm5.processed/core/stream/orchestrator/are_streams_complete.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IMultiplePeriodStreamsEvent } from "../types";
+import { IStreamOrchestratorEvent } from "../types";
 /**
  * Returns an Observable which emits ``true`` when all PeriodStreams given are
  * _complete_.
@@ -32,4 +32,4 @@ import { IMultiplePeriodStreamsEvent } from "../types";
  * @param {...Observable} streams
  * @returns {Observable}
  */
-export default function areStreamsComplete(...streams: Array<Observable<IMultiplePeriodStreamsEvent>>): Observable<boolean>;
+export default function areStreamsComplete(...streams: Array<Observable<IStreamOrchestratorEvent>>): Observable<boolean>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, } from "rxjs";
-import { distinctUntilChanged, filter, map, startWith, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, distinctUntilChanged, filter, map, startWith, } from "rxjs";
 /**
  * Returns an Observable which emits ``true`` when all PeriodStreams given are
  * _complete_.

package/dist/_esm5.processed/core/stream/orchestrator/get_blacklisted_ranges.d.ts

@@ -23,7 +23,7 @@ import { SegmentBuffer } from "../../segment_buffers";
  * @param {Array.<Object>} contents
  * @returns {Array.<Object>}
  */
-export default function getBlacklistedRanges(segmentBuffer: SegmentBuffer<unknown>, contents: Array<{
+export default function getBlacklistedRanges(segmentBuffer: SegmentBuffer, contents: Array<{
     adaptation: Adaptation;
     period: Period;
     representation: Representation;

package/dist/_esm5.processed/core/stream/orchestrator/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import StreamOrchestrator, { IStreamOrchestratorClockTick, IStreamOrchestratorOptions } from "./stream_orchestrator";
+import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./stream_orchestrator";
 export default StreamOrchestrator;
-export { IStreamOrchestratorClockTick, IStreamOrchestratorOptions, };
+export { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, };