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

package/src/core/segment_buffers/inventory/segment_inventory.ts

@@ -29,14 +29,23 @@ import BufferedHistory, {
 } from "./buffered_history";
 import { IChunkContext } from "./types";
 
-const { BUFFERED_HISTORY_RETENTION_TIME,
-        BUFFERED_HISTORY_MAXIMUM_ENTRIES,
-        MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE,
-        MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE,
-        MINIMUM_SEGMENT_SIZE } = config;
 
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
+  /**
+   * Complete size of the pushed chunk, in bytes.
+   * Note that this does not always reflect the memory imprint of the segment in
+   * memory:
+   *
+   *   1. It's the size of the original container file. A browser receiving that
+   *      segment might then transform it under another form that may be more or
+   *      less voluminous.
+   *
+   *   2. It's the size of the full chunk. In some scenarios only a sub-part of
+   *      that chunk is actually considered (examples: when using append
+   *      windows, when another chunk overlap that one etc.).
+   */
+  chunkSize : number | undefined;
   /**
    * Last inferred end in the media buffer this chunk ends at, in seconds.
    *
@@ -114,6 +123,8 @@ export interface IInsertedChunkInfos {
   representation : Representation;
   /** The Segment that chunk is linked to. */
   segment : ISegment;
+  /** Estimated size of the full pushed chunk, in bytes. */
+  chunkSize : number | undefined;
   /**
    * Start time, in seconds, this chunk most probably begins from after being
    * pushed.
@@ -152,6 +163,8 @@ export default class SegmentInventory {
   private _bufferedHistory : BufferedHistory;
 
   constructor() {
+    const { BUFFERED_HISTORY_RETENTION_TIME,
+            BUFFERED_HISTORY_MAXIMUM_ENTRIES } = config.getCurrent();
     this._inventory = [];
     this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME,
                                                 BUFFERED_HISTORY_MAXIMUM_ENTRIES);
@@ -180,7 +193,7 @@ export default class SegmentInventory {
     const inventory = this._inventory;
     let inventoryIndex = 0; // Current index considered.
     let thisSegment = inventory[0]; // Current segmentInfos considered
-
+    const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
     /** Type of buffer considered, used for logs */
     const bufferType : string | undefined = thisSegment?.infos.adaptation.type;
 
@@ -325,6 +338,7 @@ export default class SegmentInventory {
       adaptation,
       representation,
       segment,
+      chunkSize,
       start,
       end } : IInsertedChunkInfos
   ) : void {
@@ -341,6 +355,7 @@ export default class SegmentInventory {
 
     const inventory = this._inventory;
     const newSegment = { partiallyPushed: true,
+                         chunkSize,
                          splitted: false,
                          start,
                          end,
@@ -545,9 +560,16 @@ export default class SegmentInventory {
               //  prevSegment  : |---------|
               //  newSegment   :    |====|
               //  ===>         : |--|====|-|
-              log.debug("SI: Segment pushed is contained in a previous one",
-                        bufferType, start, end, segmentI.start, segmentI.end);
+              log.warn("SI: Segment pushed is contained in a previous one",
+                       bufferType, start, end, segmentI.start, segmentI.end);
               const nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                                    /**
+                                     * Note: this sadly means we're doing as if
+                                     * that chunk is present two times.
+                                     * Thankfully, this scenario should be
+                                     * fairly rare.
+                                     */
+                                    chunkSize: segmentI.chunkSize,
                                     splitted: true,
                                     start: newSegment.end,
                                     end: segmentI.end,
@@ -695,10 +717,15 @@ export default class SegmentInventory {
         }
 
         const firstI = i;
+        let segmentSize = inventory[i].chunkSize;
         i += 1;
         while (i < inventory.length &&
                areSameContent(inventory[i].infos, content))
         {
+          const chunkSize = inventory[i].chunkSize;
+          if (segmentSize !== undefined && chunkSize !== undefined) {
+            segmentSize += chunkSize;
+          }
           i++;
         }
 
@@ -711,6 +738,7 @@ export default class SegmentInventory {
           i -= length;
         }
         this._inventory[firstI].partiallyPushed = false;
+        this._inventory[firstI].chunkSize = segmentSize;
         this._inventory[firstI].end = lastEnd;
         this._inventory[firstI].bufferedEnd = lastBufferedEnd;
         this._inventory[firstI].splitted = splitted;
@@ -780,6 +808,8 @@ function bufferedStartLooksCoherent(
   }
   const { start, end } = thisSegment;
   const duration = end - start;
+  const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE,
+          MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config.getCurrent();
   return Math.abs(start - thisSegment.bufferedStart) <=
            MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
          (thisSegment.bufferedEnd === undefined ||
@@ -805,6 +835,8 @@ function bufferedEndLooksCoherent(
   }
   const { start, end } = thisSegment;
   const duration = end - start;
+  const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE,
+          MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config.getCurrent();
   return Math.abs(end - thisSegment.bufferedEnd) <=
            MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
          thisSegment.bufferedStart != null &&
@@ -828,6 +860,7 @@ function guessBufferedStartFromRangeStart(
                             null,
   bufferType : string
 ) : void {
+  const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config.getCurrent();
   if (firstSegmentInRange.bufferedStart !== undefined) {
     if (firstSegmentInRange.bufferedStart < rangeStart) {
       log.debug("SI: Segment partially GCed at the start",
@@ -892,6 +925,7 @@ function guessBufferedEndFromRangeEnd(
   rangeEnd : number,
   bufferType? : string
 ) : void {
+  const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config.getCurrent();
   if (lastSegmentInRange.bufferedEnd !== undefined) {
     if (lastSegmentInRange.bufferedEnd > rangeEnd) {
       log.debug("SI: Segment partially GCed at the end",

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -76,7 +76,6 @@ import {
 } from "../types";
 import createRepresentationEstimator from "./create_representation_estimator";
 
-const { DELTA_POSITION_AFTER_RELOAD } = config;
 
 /** Regular playback information needed by the AdaptationStream. */
 export interface IAdaptationStreamPlaybackObservation extends
@@ -123,6 +122,7 @@ export interface IAdaptationStreamArguments {
    * this AdaptationStream won't try to download new segments.
    */
   wantedBufferAhead : IReadOnlySharedReference<number>;
+  maxVideoBufferSize : IReadOnlySharedReference<number>;
 }
 
 /**
@@ -189,6 +189,7 @@ export default function AdaptationStream({
   segmentBuffer,
   segmentFetcherCreator,
   wantedBufferAhead,
+  maxVideoBufferSize,
 } : IAdaptationStreamArguments) : Observable<IAdaptationStreamEvent> {
   const directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
   const { manifest, period, adaptation } = content;
@@ -280,6 +281,7 @@ export default function AdaptationStream({
         fromEstimate.manual &&
         !isFirstEstimate)
     {
+      const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
       return reloadAfterSwitch(period,
                                adaptation.type,
                                playbackObserver,
@@ -375,6 +377,9 @@ export default function AdaptationStream({
       const bufferGoal$ = wantedBufferAhead.asObservable().pipe(
         map((wba) => wba * bufferGoalRatio)
       );
+      // eslint-disable-next-line max-len
+      const maxBufferSize$ = adaptation.type === "video" ? maxVideoBufferSize.asObservable() :
+                                                           observableOf(Infinity);
 
       log.info("Stream: changing representation",
                adaptation.type,
@@ -389,6 +394,7 @@ export default function AdaptationStream({
                                     segmentFetcher,
                                     terminate$: terminateCurrentStream$,
                                     options: { bufferGoal$,
+                                               maxBufferSize$,
                                                drmSystemId: options.drmSystemId,
                                                fastSwitchThreshold$ } })
         .pipe(catchError((err : unknown) => {

package/src/core/stream/events_generators.ts

@@ -16,13 +16,14 @@
 
 import { Subject } from "rxjs";
 import { ICustomError } from "../../errors";
-import {
+import Manifest, {
   Adaptation,
   ISegment,
   Period,
   Representation,
 } from "../../manifest";
-import { IContentProtection } from "../eme";
+import { IRepresentationProtectionData } from "../../manifest/representation";
+import objectAssign from "../../utils/object_assign";
 import { IBufferType } from "../segment_buffers";
 import {
   IActivePeriodChangedEvent,
@@ -169,10 +170,14 @@ const EVENTS = {
   },
 
   encryptionDataEncountered(
-    initDataInfo : IContentProtection
+    reprProtData : IRepresentationProtectionData,
+    content : { manifest : Manifest;
+                period : Period;
+                adaptation : Adaptation;
+                representation : Representation; }
   ) : IEncryptionDataEncounteredEvent {
     return { type: "encryption-data-encountered",
-             value: initDataInfo };
+             value: objectAssign({ content }, reprProtData) };
   },
 
   representationChange(

package/src/core/stream/index.ts

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

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -78,13 +78,12 @@ import getBlacklistedRanges from "./get_blacklisted_ranges";
 
 export type IStreamOrchestratorPlaybackObservation = IPeriodStreamPlaybackObservation;
 
-const { MAXIMUM_MAX_BUFFER_AHEAD,
-        MAXIMUM_MAX_BUFFER_BEHIND } = config;
 
 /** Options tweaking the behavior of the StreamOrchestrator. */
 export type IStreamOrchestratorOptions =
   IPeriodStreamOptions &
   { wantedBufferAhead : IReadOnlySharedReference<number>;
+    maxVideoBufferSize : IReadOnlySharedReference<number>;
     maxBufferAhead : IReadOnlySharedReference<number>;
     maxBufferBehind : IReadOnlySharedReference<number>; };
 
@@ -123,8 +122,13 @@ export default function StreamOrchestrator(
   options: IStreamOrchestratorOptions
 ) : Observable<IStreamOrchestratorEvent> {
   const { manifest, initialPeriod } = content;
-  const { maxBufferAhead, maxBufferBehind, wantedBufferAhead } = options;
+  const { maxBufferAhead,
+          maxBufferBehind,
+          wantedBufferAhead,
+          maxVideoBufferSize } = options;
 
+  const { MAXIMUM_MAX_BUFFER_AHEAD,
+          MAXIMUM_MAX_BUFFER_BEHIND } = config.getCurrent();
   // Keep track of a unique BufferGarbageCollector created per
   // SegmentBuffer.
   const garbageCollectors =
@@ -452,7 +456,8 @@ export default function StreamOrchestrator(
                                          segmentBuffersStore,
                                          options,
                                          playbackObserver,
-                                         wantedBufferAhead }
+                                         wantedBufferAhead,
+                                         maxVideoBufferSize }
     ).pipe(
       mergeMap((evt : IPeriodStreamEvent) : Observable<IMultiplePeriodStreamsEvent> => {
         if (evt.type === "stream-status") {

package/src/core/stream/period/create_empty_adaptation_stream.ts

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

package/src/core/stream/period/get_adaptation_switch_strategy.ts

@@ -33,7 +33,6 @@ import {
   SegmentBuffer,
 } from "../../segment_buffers";
 
-const { ADAPTATION_SWITCH_BUFFER_PADDINGS } = config;
 
 export type IAdaptationSwitchStrategy =
   { type: "continue"; value: undefined } |
@@ -42,22 +41,28 @@ export type IAdaptationSwitchStrategy =
   { type: "needs-reload"; 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 type IAudioTrackSwitchingMode = "seamless" |
+                                       "direct" |
+                                       "reload";
+
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.
@@ -120,7 +125,11 @@ export default function getAdaptationSwitchStrategy(
   }
 
   const { currentTime } = playbackInfo;
-  if (adaptation.type === "video" &&
+  const { audioTrackSwitchingMode } = options;
+
+  const hasReloadSwitchingMode = adaptation.type === "video" ||
+    (adaptation.type === "audio" && audioTrackSwitchingMode === "reload");
+  if (hasReloadSwitchingMode &&
       // We're playing the current Period
       isTimeInRange({ start, end }, currentTime) &&
       // There is data for the current position or the codecs are differents
@@ -136,7 +145,7 @@ export default function getAdaptationSwitchStrategy(
   // From here, clean-up data from the previous Adaptation, if one
 
   const shouldFlush = adaptation.type === "audio" &&
-                      options.audioTrackSwitchingMode === "direct";
+                      audioTrackSwitchingMode === "direct";
 
   const rangesToExclude = [];
 
@@ -157,6 +166,7 @@ export default function getAdaptationSwitchStrategy(
 
   // Next, exclude data around current position to avoid decoding issues
   const bufferType = adaptation.type;
+  const { ADAPTATION_SWITCH_BUFFER_PADDINGS } = config.getCurrent();
 
   /** Ranges that won't be cleaned from the current buffer. */
   let paddingBefore = ADAPTATION_SWITCH_BUFFER_PADDINGS[bufferType].before;

package/src/core/stream/period/index.ts

@@ -19,6 +19,7 @@ import PeriodStream, {
   IPeriodStreamOptions,
   IPeriodStreamPlaybackObservation,
 } from "./period_stream";
+export { IAudioTrackSwitchingMode } from "./get_adaptation_switch_strategy";
 
 export default PeriodStream;
 

package/src/core/stream/period/period_stream.ts

@@ -59,9 +59,10 @@ import {
   IStreamWarningEvent,
 } from "../types";
 import createEmptyStream from "./create_empty_adaptation_stream";
-import getAdaptationSwitchStrategy from "./get_adaptation_switch_strategy";
+import getAdaptationSwitchStrategy, {
+  IAudioTrackSwitchingMode,
+} from "./get_adaptation_switch_strategy";
 
-const { DELTA_POSITION_AFTER_RELOAD } = config;
 
 /** Playback observation required by the `PeriodStream`. */
 export interface IPeriodStreamPlaybackObservation {
@@ -99,27 +100,17 @@ export interface IPeriodStreamArguments {
   playbackObserver : IReadOnlyPlaybackObserver<IPeriodStreamPlaybackObservation>;
   options: IPeriodStreamOptions;
   wantedBufferAhead : IReadOnlySharedReference<number>;
+  maxVideoBufferSize : IReadOnlySharedReference<number>;
 }
 
 /** Options tweaking the behavior of the PeriodStream. */
 export 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. */
     textTrackOptions? : ITextTrackSegmentBufferOptions;
   };
@@ -143,6 +134,7 @@ export default function PeriodStream({
   segmentBuffersStore,
   options,
   wantedBufferAhead,
+  maxVideoBufferSize,
 } : IPeriodStreamArguments) : Observable<IPeriodStreamEvent> {
   const { period } = content;
 
@@ -161,6 +153,7 @@ export default function PeriodStream({
        * This value contains this relative position, in seconds.
        * @see reloadAfterSwitch
        */
+      const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
       const relativePosAfterSwitch =
         switchNb === 0 ? 0 :
         bufferType === "audio" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio :
@@ -279,7 +272,8 @@ export default function PeriodStream({
                               playbackObserver: adaptationPlaybackObserver,
                               segmentBuffer,
                               segmentFetcherCreator,
-                              wantedBufferAhead }).pipe(
+                              wantedBufferAhead,
+                              maxVideoBufferSize }).pipe(
       catchError((error : unknown) => {
         // 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

package/src/core/stream/representation/force_garbage_collection.ts

@@ -25,8 +25,6 @@ import log from "../../../log";
 import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
 import { SegmentBuffer } from "../../segment_buffers";
 
-const GC_GAP_CALM = config.BUFFER_GC_GAPS.CALM;
-const GC_GAP_BEEFY = config.BUFFER_GC_GAPS.BEEFY;
 
 /**
  * Run the garbage collector.
@@ -43,6 +41,8 @@ export default function forceGarbageCollection(
   bufferingQueue : SegmentBuffer
 ) : Observable<unknown> {
   return observableDefer(() => {
+    const GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
+    const GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
     log.warn("Stream: Running garbage collector");
     const buffered = bufferingQueue.getBufferedRanges();
     let cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);

package/src/core/stream/representation/get_buffer_status.ts

@@ -35,7 +35,6 @@ import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
 import getSegmentPriority from "./get_segment_priority";
 
-const { MINIMUM_SEGMENT_SIZE } = config;
 
 /** Analysis of the current buffer's status. */
 export interface IBufferStatus {
@@ -62,6 +61,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;
 }
 
 /**
@@ -87,11 +91,11 @@ export default function getBufferStatus(
   playbackObserver : IReadOnlyPlaybackObserver<unknown>,
   fastSwitchThreshold : number | undefined,
   bufferGoal : number,
+  maxBufferSize : number,
   segmentBuffer : SegmentBuffer
 ) : IBufferStatus {
   const { period, representation } = content;
   segmentBuffer.synchronizeInventory();
-
   const wantedEndPosition = wantedStartPosition + bufferGoal;
   const neededRange = { start: Math.max(wantedStartPosition, period.start),
                         end: Math.min(wantedEndPosition, period.end ?? Infinity) };
@@ -119,15 +123,21 @@ export default function getBufferStatus(
   const getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
 
   /** List of segments we will need to download. */
-  const neededSegments = getNeededSegments({ content,
-                                             bufferedSegments,
-                                             currentPlaybackTime,
-                                             fastSwitchThreshold,
-                                             getBufferedHistory,
-                                             neededRange,
-                                             segmentsBeingPushed })
-    .map((segment) => ({ priority: getSegmentPriority(segment.time, wantedStartPosition),
-                         segment }));
+  const { neededSegments, isBufferFull } = getNeededSegments({ content,
+                                                               bufferedSegments,
+                                                               currentPlaybackTime,
+                                                               fastSwitchThreshold,
+                                                               getBufferedHistory,
+                                                               neededRange,
+                                                               segmentsBeingPushed,
+                                                               maxBufferSize });
+
+  const prioritizedNeededSegments: IQueuedSegment[] =  neededSegments.map((segment) => (
+    {
+      priority: getSegmentPriority(segment.time, wantedStartPosition),
+      segment,
+    }
+  ));
 
   /**
    * `true` if the current `RepresentationStream` has loaded all the
@@ -138,7 +148,7 @@ export default function getBufferStatus(
   const lastPosition = representation.index.getLastPosition();
   if (!representation.index.isInitialized() ||
       period.end === undefined ||
-      neededSegments.length > 0)
+      prioritizedNeededSegments.length > 0)
   {
     hasFinishedLoading = false;
   } else {
@@ -182,10 +192,10 @@ export default function getBufferStatus(
     if (segmentsBeingPushed.length > 0) {
       nextSegmentStart = Math.min(...segmentsBeingPushed.map(info => 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,
@@ -195,7 +205,8 @@ export default function getBufferStatus(
   }
   return { imminentDiscontinuity,
            hasFinishedLoading,
-           neededSegments,
+           neededSegments: prioritizedNeededSegments,
+           isBufferFull,
            shouldRefreshManifest };
 }
 
@@ -211,6 +222,7 @@ function getPlayableBufferedSegments(
   neededRange : { start : number; end : number },
   segmentInventory : IBufferedChunk[]
 ) : IBufferedChunk[] {
+  const { MINIMUM_SEGMENT_SIZE } = config.getCurrent();
   const segmentRoundingError = Math.max(1 / 60, MINIMUM_SEGMENT_SIZE);
   const minEnd = neededRange.start + segmentRoundingError;
   const maxStart = neededRange.end - segmentRoundingError;