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

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

@@ -32,7 +32,6 @@ import EVENTS from "../events_generators";
 import reloadAfterSwitch from "../reload_after_switch";
 import RepresentationStream from "../representation";
 import createRepresentationEstimator from "./create_representation_estimator";
-var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
 /**
  * Create new AdaptationStream Observable, which task will be to download the
  * media data for a given Adaptation (i.e. "track").
@@ -48,7 +47,7 @@ var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
  * @returns {Observable}
  */
 export default function AdaptationStream(_a) {
-    var abrManager = _a.abrManager, playbackObserver = _a.playbackObserver, 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, maxVideoBufferSize = _a.maxVideoBufferSize;
     var directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
     /**
@@ -120,6 +119,7 @@ export default function AdaptationStream(_a) {
         if (directManualBitrateSwitching &&
             fromEstimate.manual &&
             !isFirstEstimate) {
+            var DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
             return reloadAfterSwitch(period, adaptation.type, playbackObserver, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch);
         }
         /**
@@ -187,9 +187,12 @@ export default function AdaptationStream(_a) {
                 1;
             bufferGoalRatioMap[representation.id] = bufferGoalRatio;
             var bufferGoal$ = wantedBufferAhead.asObservable().pipe(map(function (wba) { return wba * bufferGoalRatio; }));
+            // eslint-disable-next-line max-len
+            var maxBufferSize$ = adaptation.type === "video" ? maxVideoBufferSize.asObservable() :
+                observableOf(Infinity);
             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$ } })
+                options: { bufferGoal$: bufferGoal$, maxBufferSize$: maxBufferSize$, drmSystemId: options.drmSystemId, fastSwitchThreshold$: fastSwitchThreshold$ } })
                 .pipe(catchError(function (err) {
                 var formattedError = formatError(err, {
                     defaultCode: "NONE",

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

@@ -15,8 +15,8 @@
  */
 import { Subject } from "rxjs";
 import { ICustomError } from "../../errors";
-import { Adaptation, ISegment, Period, Representation } from "../../manifest";
-import { IContentProtection } from "../eme";
+import Manifest, { Adaptation, ISegment, Period, Representation } from "../../manifest";
+import { IRepresentationProtectionData } from "../../manifest/representation";
 import { IBufferType } from "../segment_buffers";
 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: {
@@ -52,7 +52,12 @@ declare const EVENTS: {
     needsDecipherabilityFlush(position: number, autoPlay: boolean, duration: number): INeedsDecipherabilityFlush;
     periodStreamReady(type: IBufferType, period: Period, adaptation$: Subject<Adaptation | null>): IPeriodStreamReadyEvent;
     periodStreamCleared(type: IBufferType, period: Period): IPeriodStreamClearedEvent;
-    encryptionDataEncountered(initDataInfo: IContentProtection): IEncryptionDataEncounteredEvent;
+    encryptionDataEncountered(reprProtData: IRepresentationProtectionData, content: {
+        manifest: Manifest;
+        period: Period;
+        adaptation: Adaptation;
+        representation: Representation;
+    }): IEncryptionDataEncounteredEvent;
     representationChange(type: IBufferType, period: Period, representation: Representation): IRepresentationChangeEvent;
     streamTerminating(): IStreamTerminatingEvent;
     resumeStream(): IResumeStreamEvent;

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import objectAssign from "../../utils/object_assign";
 var EVENTS = {
     activePeriodChanged: function (period) {
         return { type: "activePeriodChanged",
@@ -84,9 +85,9 @@ var EVENTS = {
         return { type: "periodStreamCleared",
             value: { type: type, period: period } };
     },
-    encryptionDataEncountered: function (initDataInfo) {
+    encryptionDataEncountered: function (reprProtData, content) {
         return { type: "encryption-data-encountered",
-            value: initDataInfo };
+            value: objectAssign({ content: content }, reprProtData) };
     },
     representationChange: function (type, period, representation) {
         return { type: "representationChange",

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import StreamOrchestrator, { IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./orchestrator";
+export { IAudioTrackSwitchingMode } from "./period";
 export * from "./types";
 export default StreamOrchestrator;
 export { IStreamOrchestratorPlaybackObservation, IStreamOrchestratorOptions, };

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

@@ -26,6 +26,7 @@ export declare type IStreamOrchestratorPlaybackObservation = IPeriodStreamPlayba
 /** Options tweaking the behavior of the StreamOrchestrator. */
 export declare type IStreamOrchestratorOptions = IPeriodStreamOptions & {
     wantedBufferAhead: IReadOnlySharedReference<number>;
+    maxVideoBufferSize: IReadOnlySharedReference<number>;
     maxBufferAhead: IReadOnlySharedReference<number>;
     maxBufferBehind: IReadOnlySharedReference<number>;
 };

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

@@ -37,7 +37,6 @@ import PeriodStream from "../period";
 import ActivePeriodEmitter from "./active_period_emitter";
 import areStreamsComplete from "./are_streams_complete";
 import getBlacklistedRanges from "./get_blacklisted_ranges";
-var MAXIMUM_MAX_BUFFER_AHEAD = config.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = config.MAXIMUM_MAX_BUFFER_BEHIND;
 /**
  * Create and manage the various Stream Observables needed for the content to
  * play:
@@ -65,7 +64,8 @@ var MAXIMUM_MAX_BUFFER_AHEAD = config.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFF
  */
 export default function StreamOrchestrator(content, playbackObserver, abrManager, segmentBuffersStore, segmentFetcherCreator, options) {
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
-    var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead;
+    var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
+    var _a = config.getCurrent(), MAXIMUM_MAX_BUFFER_AHEAD = _a.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _a.MAXIMUM_MAX_BUFFER_BEHIND;
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
     var garbageCollectors = new WeakMapMemory(function (segmentBuffer) {
@@ -315,7 +315,7 @@ export default function StreamOrchestrator(content, playbackObserver, abrManager
         );
         // Will emit when the current Stream should be destroyed.
         var killCurrentStream$ = observableMerge(endOfCurrentStream$, destroyAll$);
-        var periodStream$ = PeriodStream({ abrManager: abrManager, bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, wantedBufferAhead: wantedBufferAhead }).pipe(mergeMap(function (evt) {
+        var periodStream$ = PeriodStream({ abrManager: abrManager, bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize }).pipe(mergeMap(function (evt) {
             if (evt.type === "stream-status") {
                 if (evt.value.hasFinishedLoading) {
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);

package/dist/_esm5.processed/core/stream/period/create_empty_adaptation_stream.js

@@ -31,7 +31,8 @@ export default function createEmptyAdaptationStream(playbackObserver, wantedBuff
     var hasFinishedLoading = false;
     var wantedBufferAhead$ = wantedBufferAhead.asObservable();
     var observation$ = playbackObserver.observe(true);
-    return observableCombineLatest([observation$, wantedBufferAhead$]).pipe(mergeMap(function (_a) {
+    return observableCombineLatest([observation$,
+        wantedBufferAhead$]).pipe(mergeMap(function (_a) {
         var observation = _a[0], wba = _a[1];
         var position = observation.position;
         if (period.end !== undefined && position + wba >= period.end) {

package/dist/_esm5.processed/core/stream/period/get_adaptation_switch_strategy.d.ts

@@ -35,20 +35,24 @@ export declare type IAdaptationSwitchStrategy = {
     value: undefined;
 };
 export interface IAdaptationSwitchOptions {
-    /**
-     * Strategy to adopt when manually switching of audio adaptation.
-     * Can be either:
-     *    - "seamless": transitions are smooth but could be not immediate.
-     *    - "direct": strategy will be "smart", if the mimetype and the codec,
-     *    change, we will perform a hard reload of the media source, however, if it
-     *    doesn't change, we will just perform a small flush by removing buffered range
-     *    and performing, a small seek on the media element.
-     *    Transitions are faster, but, we could see appear a reloading or seeking state.
-     */
-    audioTrackSwitchingMode: "seamless" | "direct";
+    /** RxPlayer's behavior when switching the audio track. */
+    audioTrackSwitchingMode: IAudioTrackSwitchingMode;
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch: "continue" | "reload";
 }
+/**
+ * Strategy to adopt when manually switching of audio adaptation.
+ * Can be either:
+ *    - "seamless": transitions are smooth but could be not immediate.
+ *    - "direct": strategy will be "smart", if the mimetype and the codec,
+ *    change, we will perform a hard reload of the media source, however, if it
+ *    doesn't change, we will just perform a small flush by removing buffered range
+ *    and performing, a small seek on the media element.
+ *    Transitions are faster, but, we could see appear a BUFFERING state.
+ *    - "reload": completely reload the content. This allows a direct switch
+ *    compatible with most device but may necessitate a RELOADING phase.
+ */
+export declare type IAudioTrackSwitchingMode = "seamless" | "direct" | "reload";
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.

package/dist/_esm5.processed/core/stream/period/get_adaptation_switch_strategy.js

@@ -16,7 +16,6 @@
 import config from "../../../config";
 import areCodecsCompatible from "../../../utils/are_codecs_compatible";
 import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../utils/ranges";
-var ADAPTATION_SWITCH_BUFFER_PADDINGS = config.ADAPTATION_SWITCH_BUFFER_PADDINGS;
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.
@@ -63,7 +62,10 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         return { type: "continue", value: undefined };
     }
     var currentTime = playbackInfo.currentTime;
-    if (adaptation.type === "video" &&
+    var audioTrackSwitchingMode = options.audioTrackSwitchingMode;
+    var hasReloadSwitchingMode = adaptation.type === "video" ||
+        (adaptation.type === "audio" && audioTrackSwitchingMode === "reload");
+    if (hasReloadSwitchingMode &&
         // We're playing the current Period
         isTimeInRange({ start: start, end: end }, currentTime) &&
         // There is data for the current position or the codecs are differents
@@ -75,7 +77,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     }
     // From here, clean-up data from the previous Adaptation, if one
     var shouldFlush = adaptation.type === "audio" &&
-        options.audioTrackSwitchingMode === "direct";
+        audioTrackSwitchingMode === "direct";
     var rangesToExclude = [];
     // First, we don't want to accidentally remove some segments from the previous
     // Period (which overlap a little with this one)
@@ -92,6 +94,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     }
     // Next, exclude data around current position to avoid decoding issues
     var bufferType = adaptation.type;
+    var ADAPTATION_SWITCH_BUFFER_PADDINGS = config.getCurrent().ADAPTATION_SWITCH_BUFFER_PADDINGS;
     /** Ranges that won't be cleaned from the current buffer. */
     var paddingBefore = ADAPTATION_SWITCH_BUFFER_PADDINGS[bufferType].before;
     if (paddingBefore == null) {

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

@@ -14,5 +14,6 @@
  * limitations under the License.
  */
 import PeriodStream, { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "./period_stream";
+export { IAudioTrackSwitchingMode } from "./get_adaptation_switch_strategy";
 export default PeriodStream;
 export { IPeriodStreamArguments, IPeriodStreamOptions, IPeriodStreamPlaybackObservation, };

package/dist/_esm5.processed/core/stream/period/period_stream.d.ts

@@ -23,6 +23,7 @@ import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
 import { IAdaptationStreamOptions } from "../adaptation";
 import { IPeriodStreamEvent } from "../types";
+import { IAudioTrackSwitchingMode } from "./get_adaptation_switch_strategy";
 /** Playback observation required by the `PeriodStream`. */
 export interface IPeriodStreamPlaybackObservation {
     /** The position we are in the video in seconds at the time of the observation. */
@@ -60,20 +61,12 @@ export interface IPeriodStreamArguments {
     playbackObserver: IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
     options: IPeriodStreamOptions;
     wantedBufferAhead: IReadOnlySharedReference<number>;
+    maxVideoBufferSize: IReadOnlySharedReference<number>;
 }
 /** Options tweaking the behavior of the PeriodStream. */
 export declare type IPeriodStreamOptions = IAdaptationStreamOptions & {
-    /**
-     * Strategy to adopt when manually switching of audio adaptation.
-     * Can be either:
-     *    - "seamless": transitions are smooth but could be not immediate.
-     *    - "direct": strategy will be "smart", if the mimetype and the codec,
-     *    change, we will perform a hard reload of the media source, however, if it
-     *    doesn't change, we will just perform a small flush by removing buffered range
-     *    and performing, a small seek on the media element.
-     *    Transitions are faster, but, we could see appear a reloading or seeking state.
-     */
-    audioTrackSwitchingMode: "seamless" | "direct";
+    /** RxPlayer's behavior when switching the audio track. */
+    audioTrackSwitchingMode: IAudioTrackSwitchingMode;
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch: "continue" | "reload";
     /** Options specific to the text SegmentBuffer. */
@@ -89,4 +82,4 @@ export declare type IPeriodStreamOptions = IAdaptationStreamOptions & {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function PeriodStream({ abrManager, bufferType, content, garbageCollectors, playbackObserver, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, }: IPeriodStreamArguments): Observable<IPeriodStreamEvent>;
+export default function PeriodStream({ abrManager, bufferType, content, garbageCollectors, playbackObserver, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize, }: IPeriodStreamArguments): Observable<IPeriodStreamEvent>;

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -25,7 +25,6 @@ import EVENTS from "../events_generators";
 import reloadAfterSwitch from "../reload_after_switch";
 import createEmptyStream from "./create_empty_adaptation_stream";
 import getAdaptationSwitchStrategy from "./get_adaptation_switch_strategy";
-var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
 /**
  * Create single PeriodStream Observable:
  *   - Lazily create (or reuse) a SegmentBuffer for the given type.
@@ -37,7 +36,7 @@ var DELTA_POSITION_AFTER_RELOAD = config.DELTA_POSITION_AFTER_RELOAD;
  * @returns {Observable}
  */
 export default function PeriodStream(_a) {
-    var abrManager = _a.abrManager, bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead;
+    var abrManager = _a.abrManager, bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
     var period = content.period;
     // Emits the chosen Adaptation for the current type.
     // `null` when no Adaptation is chosen (e.g. no subtitles)
@@ -50,6 +49,7 @@ export default function PeriodStream(_a) {
          * This value contains this relative position, in seconds.
          * @see reloadAfterSwitch
          */
+        var DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
         var relativePosAfterSwitch = switchNb === 0 ? 0 :
             bufferType === "audio" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio :
                 bufferType === "video" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video :
@@ -118,7 +118,7 @@ export default function PeriodStream(_a) {
     function createAdaptationStream(adaptation, segmentBuffer) {
         var manifest = content.manifest;
         var adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
-        return AdaptationStream({ abrManager: abrManager, content: { manifest: manifest, period: period, adaptation: adaptation }, options: options, playbackObserver: adaptationPlaybackObserver, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead }).pipe(catchError(function (error) {
+        return AdaptationStream({ abrManager: abrManager, content: { manifest: manifest, period: period, adaptation: adaptation }, options: options, playbackObserver: adaptationPlaybackObserver, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize }).pipe(catchError(function (error) {
             // Stream linked to a non-native media buffer should not impact the
             // stability of the player. ie: if a text buffer sends an error, we want
             // to continue playing without any subtitles

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

@@ -17,8 +17,6 @@ import { concatAll, defer as observableDefer, from as observableFrom, } from "rx
 import config from "../../../config";
 import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
-var GC_GAP_CALM = config.BUFFER_GC_GAPS.CALM;
-var GC_GAP_BEEFY = config.BUFFER_GC_GAPS.BEEFY;
 /**
  * Run the garbage collector.
  *
@@ -31,6 +29,8 @@ var GC_GAP_BEEFY = config.BUFFER_GC_GAPS.BEEFY;
  */
 export default function forceGarbageCollection(currentPosition, bufferingQueue) {
     return observableDefer(function () {
+        var GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
+        var GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
         log.warn("Stream: Running garbage collector");
         var buffered = bufferingQueue.getBufferedRanges();
         var cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);

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

@@ -42,6 +42,11 @@ export interface IBufferStatus {
      * on which segments should be loaded.
      */
     shouldRefreshManifest: boolean;
+    /**
+     * If 'true', the buffer memory is saturated before being able to download
+     * at least MIN_REQUIRED_BUFFER_AHEAD ( default : 10sec )
+     */
+    isBufferFull: boolean;
 }
 /**
  * Checks on the current buffered data for the given type and Period
@@ -62,4 +67,4 @@ export default function getBufferStatus(content: {
     manifest: Manifest;
     period: Period;
     representation: Representation;
-}, wantedStartPosition: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, segmentBuffer: SegmentBuffer): IBufferStatus;
+}, wantedStartPosition: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;

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

@@ -18,7 +18,6 @@ import { SegmentBufferOperation, } from "../../segment_buffers";
 import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
 import getSegmentPriority from "./get_segment_priority";
-var MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
 /**
  * Checks on the current buffered data for the given type and Period
  * and returns what should be done to fill the buffer according to the buffer
@@ -33,7 +32,7 @@ var MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
-export default function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, segmentBuffer) {
+export default function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
     var _a;
     var period = content.period, representation = content.representation;
     segmentBuffer.synchronizeInventory();
@@ -56,8 +55,11 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var neededSegments = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed })
-        .map(function (segment) { return ({ priority: getSegmentPriority(segment.time, wantedStartPosition), segment: segment }); });
+    var _b = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), neededSegments = _b.neededSegments, isBufferFull = _b.isBufferFull;
+    var prioritizedNeededSegments = neededSegments.map(function (segment) { return ({
+        priority: getSegmentPriority(segment.time, wantedStartPosition),
+        segment: segment,
+    }); });
     /**
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
@@ -66,7 +68,7 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
     var lastPosition = representation.index.getLastPosition();
     if (!representation.index.isInitialized() ||
         period.end === undefined ||
-        neededSegments.length > 0) {
+        prioritizedNeededSegments.length > 0) {
         hasFinishedLoading = false;
     }
     else {
@@ -110,14 +112,14 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
         if (segmentsBeingPushed.length > 0) {
             nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
         }
-        if (neededSegments.length > 0) {
+        if (prioritizedNeededSegments.length > 0) {
             nextSegmentStart = nextSegmentStart !== null ?
-                Math.min(nextSegmentStart, neededSegments[0].segment.time) :
-                neededSegments[0].segment.time;
+                Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
+                prioritizedNeededSegments[0].segment.time;
         }
         imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
     }
-    return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: neededSegments, shouldRefreshManifest: shouldRefreshManifest };
+    return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: prioritizedNeededSegments, isBufferFull: isBufferFull, shouldRefreshManifest: shouldRefreshManifest };
 }
 /**
  * From the given SegmentInventory, filters the "playable" (in a supported codec
@@ -128,6 +130,7 @@ export default function getBufferStatus(content, wantedStartPosition, playbackOb
  * @returns {Array.<Object>}
  */
 function getPlayableBufferedSegments(neededRange, segmentInventory) {
+    var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
     var segmentRoundingError = Math.max(1 / 60, MINIMUM_SEGMENT_SIZE);
     var minEnd = neededRange.start + segmentRoundingError;
     var maxStart = neededRange.end - segmentRoundingError;

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

@@ -14,17 +14,18 @@
  * limitations under the License.
  */
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { IBufferedChunk } from "../../segment_buffers";
+import { IBufferedChunk, IEndOfSegmentInfos } from "../../segment_buffers";
 import { IBufferedHistoryEntry, IChunkContext } from "../../segment_buffers/inventory";
+interface IContentContext {
+    adaptation: Adaptation;
+    manifest: Manifest;
+    period: Period;
+    representation: Representation;
+}
 /** Arguments for `getNeededSegments`. */
 export interface IGetNeededSegmentsArguments {
     /** The content we want to load segments for */
-    content: {
-        adaptation: Adaptation;
-        manifest: Manifest;
-        period: Period;
-        representation: Representation;
-    };
+    content: IContentContext;
     /**
      * The current playing position.
      * Important to avoid asking for segments on the same exact position, which
@@ -46,12 +47,7 @@ export interface IGetNeededSegmentsArguments {
         end: number;
     };
     /** The list of segments that are already in the process of being pushed. */
-    segmentsBeingPushed: Array<{
-        adaptation: Adaptation;
-        period: Period;
-        representation: Representation;
-        segment: ISegment;
-    }>;
+    segmentsBeingPushed: IEndOfSegmentInfos[];
     /**
      * Information on the segments already in the buffer, in chronological order.
      *
@@ -62,8 +58,16 @@ export interface IGetNeededSegmentsArguments {
      * re-requested.
      */
     bufferedSegments: IBufferedChunk[];
+    /**
+     * maxBufferSize is the maximum memory in kilobytes that the buffer should take
+     */
+    maxBufferSize: number;
     getBufferedHistory: (context: IChunkContext) => IBufferedHistoryEntry[];
 }
+interface INeededSegments {
+    neededSegments: ISegment[];
+    isBufferFull: boolean;
+}
 /**
  * Return the list of segments that can currently be downloaded to fill holes
  * in the buffer in the given range, including already-pushed segments currently
@@ -74,4 +78,5 @@ export interface IGetNeededSegmentsArguments {
  * @param {Object} args
  * @returns {Array.<Object>}
  */
-export default function getNeededSegments({ bufferedSegments, content, currentPlaybackTime, fastSwitchThreshold, getBufferedHistory, neededRange, segmentsBeingPushed, }: IGetNeededSegmentsArguments): ISegment[];
+export default function getNeededSegments({ bufferedSegments, content, currentPlaybackTime, fastSwitchThreshold, getBufferedHistory, neededRange, segmentsBeingPushed, maxBufferSize, }: IGetNeededSegmentsArguments): INeededSegments;
+export {};

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

@@ -18,12 +18,6 @@ import config from "../../../config";
 import log from "../../../log";
 import { areSameContent, } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-var CONTENT_REPLACEMENT_PADDING = config.CONTENT_REPLACEMENT_PADDING, BITRATE_REBUFFERING_RATIO = config.BITRATE_REBUFFERING_RATIO, MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config.MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT, MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
-/**
- * Epsilon compensating for rounding errors when comparing the start and end
- * time of multiple segments.
- */
-var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
 /**
  * Return the list of segments that can currently be downloaded to fill holes
  * in the buffer in the given range, including already-pushed segments currently
@@ -35,8 +29,11 @@ var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
  * @returns {Array.<Object>}
  */
 export default function getNeededSegments(_a) {
-    var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed;
+    var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed, maxBufferSize = _a.maxBufferSize;
     var representation = content.representation;
+    var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
+    // Current buffer length in seconds
+    var bufferLength = getBufferLength(bufferedSegments, segmentsBeingPushed);
     var availableSegmentsForRange = representation.index
         .getSegments(neededRange.start, neededRange.end - neededRange.start);
     // Remove from `bufferedSegments` any segments we would prefer to replace:
@@ -57,7 +54,7 @@ export default function getNeededSegments(_a) {
             }
             log.debug("Stream: skipping segment gc-ed at the start", currentSeg);
         }
-        if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.start)) {
+        if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.end)) {
             lazySegmentHistory = lazySegmentHistory !== null && lazySegmentHistory !== void 0 ? lazySegmentHistory : getBufferedHistory(currentSeg.infos);
             if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory, currentSeg.bufferedEnd)) {
                 return false;
@@ -66,7 +63,15 @@ export default function getNeededSegments(_a) {
         }
         return true;
     });
-    var segmentsToDownload = availableSegmentsForRange.filter(function (segment) {
+    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_LENGTH = _b.MIN_BUFFER_LENGTH, MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP = _b.MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP;
+    var isMemorySaturated = false;
+    /**
+     * Epsilon compensating for rounding errors when comparing the start and end
+     * time of multiple segments.
+     */
+    var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
+    var isBufferFull = false;
+    var neededSegments = availableSegmentsForRange.filter(function (segment) {
         var contentObject = objectAssign({ segment: segment }, content);
         // First, check that the segment is not already being pushed
         if (segmentsBeingPushed.length > 0) {
@@ -80,6 +85,19 @@ export default function getNeededSegments(_a) {
         if (segment.isInit) {
             return true; // never skip initialization segments
         }
+        if (isMemorySaturated) {
+            // If we are so saturated in memory
+            // That we cannot download atleast till
+            // NeededRange.Start ( current position ) + a CONST
+            // Then the buffer is full
+            if (time < neededRange.start + MIN_BUFFER_DISTANCE_BEFORE_CLEAN_UP) {
+                isBufferFull = true;
+            }
+        }
+        if (isMemorySaturated &&
+            bufferLength > MIN_BUFFER_LENGTH) {
+            return false;
+        }
         if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
             return false; // too small, don't download
         }
@@ -130,9 +148,57 @@ export default function getNeededSegments(_a) {
                     getLastContiguousSegment(segmentsToKeep, i).end < end - ROUNDING_ERROR;
             }
         }
+        var estimatedSegmentSize = (duration * content.representation.bitrate) / 8000;
+        if (availableBufferSize - estimatedSegmentSize < 0 &&
+            bufferLength > MIN_BUFFER_LENGTH) {
+            isMemorySaturated = true;
+            return false;
+        }
+        availableBufferSize -= estimatedSegmentSize;
+        bufferLength += duration;
         return true;
     });
-    return segmentsToDownload;
+    return { neededSegments: neededSegments, isBufferFull: isBufferFull };
+}
+/**
+ * Compute the estimated available buffer size in memory in kilobytes
+ * @param bufferedSegments
+ * @param segmentsBeingPushed
+ * @param maxVideoBufferSize
+ * @returns availableBufferSize in kilobytes
+ */
+function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoBufferSize) {
+    var availableBufferSize = maxVideoBufferSize;
+    availableBufferSize -= segmentsBeingPushed.reduce(function (size, segment) {
+        var bitrate = segment.representation.bitrate;
+        // Not taking into account the fact that the segment
+        // can still be generated and the duration not fully exact
+        var duration = segment.segment.duration;
+        return size + ((bitrate / 8000) * duration);
+    }, 0);
+    return bufferedSegments.reduce(function (size, chunk) {
+        if (chunk.chunkSize !== undefined) {
+            return size - (chunk.chunkSize / 8000);
+        }
+        else {
+            return size;
+        }
+    }, availableBufferSize);
+}
+/**
+ * Compute the length of the buffer in seconds
+ * @param bufferedSegments
+ * @param segmentsBeingPushed
+ * @returns bufferLength in seconds
+ */
+function getBufferLength(bufferedSegments, segmentsBeingPushed) {
+    var bufferLength = bufferedSegments.reduce(function (length, segment) {
+        return length + (segment.end - segment.start);
+    }, 0);
+    var bufferBeingPushed = segmentsBeingPushed.reduce(function (length, segment) {
+        return length + segment.segment.duration;
+    }, 0);
+    return bufferLength + bufferBeingPushed;
 }
 /**
  * From the given array of buffered chunks (`bufferedSegments`) returns the last
@@ -143,6 +209,12 @@ export default function getNeededSegments(_a) {
  */
 function getLastContiguousSegment(bufferedSegments, startIndex) {
     var j = startIndex + 1;
+    var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
+    /**
+     * Epsilon compensating for rounding errors when comparing the start and end
+     * time of multiple segments.
+     */
+    var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
     // go through all contiguous segments and take the last one
     while (j < bufferedSegments.length - 1 &&
         (bufferedSegments[j - 1].end + ROUNDING_ERROR) >
@@ -162,6 +234,7 @@ function getLastContiguousSegment(bufferedSegments, startIndex) {
  * @returns {boolean}
  */
 function shouldContentBeReplaced(oldContent, currentContent, currentPlaybackTime, fastSwitchThreshold) {
+    var CONTENT_REPLACEMENT_PADDING = config.getCurrent().CONTENT_REPLACEMENT_PADDING;
     if (oldContent.period.id !== currentContent.period.id) {
         return false; // keep segments from another Period by default.
     }
@@ -186,6 +259,7 @@ function shouldContentBeReplaced(oldContent, currentContent, currentPlaybackTime
  */
 function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastSwitchThreshold) {
     var oldContentBitrate = oldSegmentRepresentation.bitrate;
+    var BITRATE_REBUFFERING_RATIO = config.getCurrent().BITRATE_REBUFFERING_RATIO;
     if (fastSwitchThreshold === undefined) {
         // only re-load comparatively-poor bitrates for the same Adaptation.
         var bitrateCeil = oldContentBitrate * BITRATE_REBUFFERING_RATIO;
@@ -207,6 +281,7 @@ function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastS
  * that time, we will return `false`.
  */
 function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
+    var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
     if (currentSeg.bufferedStart === undefined) {
         log.warn("Stream: Start of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg);
@@ -237,6 +312,7 @@ function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
  * that time, we will return `false`.
  */
 function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
+    var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
     if (currentSeg.bufferedEnd === undefined) {
         log.warn("Stream: End of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg);