rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -449,8 +449,8 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
   }
 }
 
-/** Data of chunks that should be pushed to the NativeTextSegmentBuffer. */
-export interface INativeTextTracksBufferSegmentData {
+/** Data of chunks that should be pushed to the HTMLTextSegmentBuffer. */
+export interface IHTMLTextTracksBufferSegmentData {
   /** The text track data, in the format indicated in `type`. */
   data : string;
   /** The format of `data` (examples: "ttml", "srt" or "vtt") */
@@ -475,49 +475,49 @@ export interface INativeTextTracksBufferSegmentData {
  */
 function assertChunkIsTextTrackSegmentData(
   chunk : unknown
-) : asserts chunk is INativeTextTracksBufferSegmentData {
-  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+) : asserts chunk is IHTMLTextTracksBufferSegmentData {
+  if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   if (
     typeof chunk !== "object" ||
     chunk === null ||
-    typeof (chunk as INativeTextTracksBufferSegmentData).data !== "string" ||
-    typeof (chunk as INativeTextTracksBufferSegmentData).type !== "string" ||
+    typeof (chunk as IHTMLTextTracksBufferSegmentData).data !== "string" ||
+    typeof (chunk as IHTMLTextTracksBufferSegmentData).type !== "string" ||
     (
-      (chunk as INativeTextTracksBufferSegmentData).language !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).language !== "string"
+      (chunk as IHTMLTextTracksBufferSegmentData).language !== undefined &&
+      typeof (chunk as IHTMLTextTracksBufferSegmentData).language !== "string"
     ) ||
     (
-      (chunk as INativeTextTracksBufferSegmentData).start !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).start !== "number"
+      (chunk as IHTMLTextTracksBufferSegmentData).start !== undefined &&
+      typeof (chunk as IHTMLTextTracksBufferSegmentData).start !== "number"
     ) ||
     (
-      (chunk as INativeTextTracksBufferSegmentData).end !== undefined &&
-      typeof (chunk as INativeTextTracksBufferSegmentData).end !== "number"
+      (chunk as IHTMLTextTracksBufferSegmentData).end !== undefined &&
+      typeof (chunk as IHTMLTextTracksBufferSegmentData).end !== "number"
     )
   ) {
-    throw new Error("Invalid format given to a NativeTextSegmentBuffer");
+    throw new Error("Invalid format given to a HTMLTextSegmentBuffer");
   }
 }
 
 /*
  * The following ugly code is here to provide a compile-time check that an
- * `INativeTextTracksBufferSegmentData` (type of data pushed to a
- * `NativeTextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
+ * `IHTMLTextTracksBufferSegmentData` (type of data pushed to a
+ * `HTMLTextSegmentBuffer`) can be derived from a `ITextTrackSegmentData`
  * (text track data parsed from a segment).
  *
  * It doesn't correspond at all to real code that will be called. This is just
  * a hack to tell TypeScript to perform that check.
  */
-if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   /* eslint-disable @typescript-eslint/ban-ts-comment */
   // @ts-ignore
   function _checkType(
     input : ITextTrackSegmentData
   ) : void {
-    function checkEqual(_arg : INativeTextTracksBufferSegmentData) : void {
+    function checkEqual(_arg : IHTMLTextTracksBufferSegmentData) : void {
       /* nothing */
     }
     checkEqual(input);

package/src/core/segment_buffers/implementations/text/html/text_track_cues_store.ts

@@ -84,7 +84,7 @@ export default class TextTrackCuesStore {
    * @param {Number} to
    */
   remove(from : number, _to : number) : void {
-    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+    if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
       assert(from >= 0);
       assert(_to >= 0);
       assert(_to > from);

package/src/core/segment_buffers/implementations/text/native/native_text_segment_buffer.ts

@@ -284,7 +284,7 @@ export interface INativeTextTracksBufferSegmentData {
 function assertChunkIsTextTrackSegmentData(
   chunk : unknown
 ) : asserts chunk is INativeTextTracksBufferSegmentData {
-  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+  if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   if (
@@ -318,7 +318,7 @@ function assertChunkIsTextTrackSegmentData(
  * It doesn't correspond at all to real code that will be called. This is just
  * a hack to tell TypeScript to perform that check.
  */
-if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   /* eslint-disable @typescript-eslint/ban-ts-comment */
   // @ts-ignore

package/src/core/segment_buffers/implementations/utils/manual_time_ranges.ts

@@ -39,7 +39,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   insert(start : number, end : number) : void {
-    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+    if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");
     }
@@ -48,7 +48,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   remove(start : number, end : number) : void {
-    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+    if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");
     }

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

@@ -15,6 +15,7 @@
  */
 
 import { areSameContent } from "../../../manifest";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import { IChunkContext } from "./types";
 
 /**
@@ -23,7 +24,7 @@ import { IChunkContext } from "./types";
  * low-latency streaming usages) in the buffer becomes known.
  */
 export interface IBufferedHistoryEntry {
-  /** `performance.now()` when the event happened. */
+  /** The RxPlayer's monotonically-raising timestamp when the event happened. */
   date : number;
 
   /**
@@ -86,7 +87,7 @@ export default class BufferedHistory {
     context : IChunkContext,
     buffered : { start: number; end: number } | null
   ) : void {
-    const now = performance.now();
+    const now = getMonotonicTimeStamp();
     this._history.push({ date: now,
                          buffered,
                          context });
@@ -107,7 +108,7 @@ export default class BufferedHistory {
   /**
    * If the current history does not satisfy `_lifetime` or `_maxHistoryLength`,
    * clear older entries until it does.
-   * @param {number} now - Current `performance.now()` result.
+   * @param {number} now - Current monotonically-raising timestamp.
    */
   private _cleanHistory(now : number) {
     const historyEarliestLimit = now - this._lifetime;

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

@@ -921,6 +921,7 @@ function guessBufferedStartFromRangeStart(
   } else if (rangeStart < firstSegmentInRange.start) {
     log.debug("SI: range start too far from expected start",
               bufferType, rangeStart, firstSegmentInRange.start);
+    firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
   } else {
     log.debug("SI: Segment appears immediately garbage collected at the start",
               bufferType, firstSegmentInRange.bufferedStart, rangeStart);

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

@@ -1,3 +1,4 @@
+import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -6,9 +7,8 @@ import assertUnreachable from "../../../utils/assert_unreachable";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
-import {
+import SharedReference, {
   createMappedReference,
-  createSharedReference,
   IReadOnlySharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
@@ -19,7 +19,6 @@ import RepresentationStream, {
   IRepresentationStreamCallbacks,
   ITerminationOrder,
 } from "../representation";
-import createReloadRequest from "../utils/create_reload_request";
 import getRepresentationsSwitchingStrategy from "./get_representations_switch_strategy";
 import {
   IAdaptationStreamArguments,
@@ -56,7 +55,7 @@ import {
  * triggered, to immediately stop all operations the `AdaptationStream` is
  * doing.
  */
-export default function AdaptationStream<T>(
+export default function AdaptationStream(
   { playbackObserver,
     content,
     options,
@@ -65,7 +64,7 @@ export default function AdaptationStream<T>(
     segmentFetcherCreator,
     wantedBufferAhead,
     maxVideoBufferSize } : IAdaptationStreamArguments,
-  callbacks : IAdaptationStreamCallbacks<T>,
+  callbacks : IAdaptationStreamCallbacks,
   parentCancelSignal : CancellationSignal
 ) : void {
   const { manifest, period, adaptation } = content;
@@ -88,7 +87,7 @@ export default function AdaptationStream<T>(
    * Emit the currently chosen `Representation`.
    * `null` if no Representation is chosen for now.
    */
-  const currentRepresentation = createSharedReference<Representation | null>(
+  const currentRepresentation = new SharedReference<Representation | null>(
     null,
     adapStreamCanceller.signal
   );
@@ -97,7 +96,7 @@ export default function AdaptationStream<T>(
   let previouslyEmittedBitrate : number | undefined;
 
   /** Emit the list of Representation for the adaptive logic. */
-  const representationsList = createSharedReference(
+  const representationsList = new SharedReference(
     content.representations.getValue().representations,
     adapStreamCanceller.signal);
 
@@ -121,7 +120,7 @@ export default function AdaptationStream<T>(
 
 
   /** Used to determine when "fast-switching" is possible. */
-  const fastSwitchThreshold = createSharedReference<number | undefined>(0);
+  const fastSwitchThreshold = new SharedReference<number | undefined>(0);
 
   estimateRef.onUpdate(({ bitrate, knownStableBitrate }) => {
     if (options.enableFastSwitching) {
@@ -189,11 +188,23 @@ export default function AdaptationStream<T>(
       case "continue":
         break; // nothing to do
       case "needs-reload": // Just ask to reload
-        const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
-        const bufferType = adaptation.type;
-        return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-          callbacks.waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-        }, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch, period, fnCancelSignal);
+        // We begin by scheduling a micro-task to reduce the possibility of race
+        // conditions where the inner logic would be called synchronously before
+        // the next observation (which may reflect very different playback conditions)
+        // is actually received.
+        return nextTick(() => {
+          playbackObserver.listen(() => {
+            if (fnCancelSignal.isCancelled()) {
+              return;
+            }
+            const { DELTA_POSITION_AFTER_RELOAD } = config.getCurrent();
+            const timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
+            return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type,
+                                                        period,
+                                                        timeOffset,
+                                                        stayInPeriod: true });
+          }, { includeLastObservation: true, clearSignal: fnCancelSignal });
+        });
 
       case "flush-buffer": // Clean + flush
       case "clean-buffer": // Just clean
@@ -245,7 +256,7 @@ export default function AdaptationStream<T>(
      * This allows to easily rely on that value in inner Observables which might also
      * need the last already-considered value.
      */
-    const terminateCurrentStream = createSharedReference<ITerminationOrder | null>(
+    const terminateCurrentStream = new SharedReference<ITerminationOrder | null>(
       null,
       repStreamTerminatingCanceller.signal
     );
@@ -276,7 +287,7 @@ export default function AdaptationStream<T>(
       return ; // previous callback has stopped everything by side-effect
     }
 
-    const representationStreamCallbacks : IRepresentationStreamCallbacks<T> = {
+    const representationStreamCallbacks : IRepresentationStreamCallbacks = {
       streamStatusUpdate: callbacks.streamStatusUpdate,
       encryptionDataEncountered: callbacks.encryptionDataEncountered,
       manifestMightBeOufOfSync: callbacks.manifestMightBeOufOfSync,
@@ -289,10 +300,6 @@ export default function AdaptationStream<T>(
       },
       addedSegment(segmentInfo) {
         abrCallbacks.addedSegment(segmentInfo);
-        if (adapStreamCanceller.isUsed()) {
-          return;
-        }
-        callbacks.addedSegment(segmentInfo);
       },
       terminating() {
         if (repStreamTerminatingCanceller.isUsed()) {
@@ -324,7 +331,7 @@ export default function AdaptationStream<T>(
   function createRepresentationStream(
     representation : Representation,
     terminateCurrentStream : IReadOnlySharedReference<ITerminationOrder | null>,
-    representationStreamCallbacks : IRepresentationStreamCallbacks<T>,
+    representationStreamCallbacks : IRepresentationStreamCallbacks,
     fnCancelSignal : CancellationSignal
   ) : void {
     const bufferGoalCanceller = new TaskCanceller();
@@ -334,7 +341,7 @@ export default function AdaptationStream<T>(
     }, bufferGoalCanceller.signal);
     const maxBufferSize = adaptation.type === "video" ?
       maxVideoBufferSize :
-      createSharedReference(Infinity);
+      new SharedReference(Infinity);
     log.info("Stream: changing representation",
              adaptation.type,
              representation.id,
@@ -391,13 +398,21 @@ export default function AdaptationStream<T>(
     manifest.addEventListener("manifestUpdate", updates => {
       for (const element of updates.updatedPeriods) {
         if (element.period.id === period.id) {
-          for (const adap of element.result.removedAdaptations) {
-            if (adap.id === adaptation.id) {
-              const bufferType = adaptation.type;
-              return createReloadRequest(playbackObserver, ({ position, autoPlay }) => {
-                callbacks
-                  .waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-              }, 0, period, fnCancelSignal);
+          for (const updated of element.result.updatedAdaptations) {
+            if (updated.adaptation.id === adaptation.id) {
+              for (const rep of updated.removedRepresentations) {
+                if (rep.id === representation.id) {
+                  if (fnCancelSignal.isCancelled()) {
+                    return;
+                  }
+                  return callbacks.waitingMediaSourceReload({
+                    bufferType: adaptation.type,
+                    period,
+                    timeOffset: 0,
+                    stayInPeriod: true,
+                  });
+                }
+              }
             }
           }
         } else if (element.period.start > period.start) {

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

@@ -22,8 +22,8 @@ import {
 } from "../representation";
 
 /** Callbacks called by the `AdaptationStream` on various events. */
-export interface IAdaptationStreamCallbacks<T>
-  extends Omit<IRepresentationStreamCallbacks<T>, "terminating">
+export interface IAdaptationStreamCallbacks
+  extends Omit<IRepresentationStreamCallbacks, "terminating" | "addedSegment">
 {
   /** Called as new bitrate estimates are done. */
   bitrateEstimateChange(payload : IBitrateEstimateChangePayload) : void;
@@ -87,16 +87,22 @@ export interface IWaitingMediaSourceReloadPayload {
   /** Buffer type concerned. */
   bufferType : IBufferType;
   /**
-   * The position in seconds and the time at which the MediaSource should be
-   * reset once it has been reloaded.
+   * Relative position, compared to the current position, at which we should
+   * restart playback after reloading. For example `-2` will reload 2 seconds
+   * before the current position.
    */
-  position : number;
+  timeOffset : number;
   /**
-   * If `true`, we want the HTMLMediaElement to play right after the reload is
-   * done.
-   * If `false`, we want to stay in a paused state at that point.
+   * If `true`, we will control that the position we reload at, after applying
+   * `timeOffset`, is still part of the Period `period`.
+   *
+   * If it isn't we will re-calculate that reloaded position to be:
+   *   - either the Period's start if the calculated position is before the
+   *     Period's start.
+   *   - either the Period'end start if the calculated position is after the
+   *     Period's end.
    */
-  autoPlay : boolean;
+  stayInPeriod : boolean;
 }
 
 /** Regular playback information needed by the AdaptationStream. */

package/src/core/stream/index.ts

@@ -15,6 +15,7 @@
  */
 
 import StreamOrchestrator, {
+  INeedsMediaSourceReloadPayload,
   IStreamOrchestratorOptions,
   IStreamOrchestratorPlaybackObservation,
   IStreamOrchestratorCallbacks,
@@ -32,6 +33,7 @@ export {
 
 export default StreamOrchestrator;
 export {
+  INeedsMediaSourceReloadPayload,
   IStreamOrchestratorPlaybackObservation,
   IStreamOrchestratorOptions,
   IStreamOrchestratorCallbacks,

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

@@ -54,12 +54,7 @@ export default function getTimeRangesForContent(
       const { bufferedStart, bufferedEnd } = chunk;
       if (bufferedStart === undefined || bufferedEnd === undefined) {
         log.warn("SO: No buffered start or end found from a segment.");
-        const buffered = segmentBuffer.getBufferedRanges();
-        const len = buffered.length;
-        if (len === 0) {
-          return [];
-        }
-        return [{ start: buffered.start(0), end: buffered.end(len - 1) }];
+        return [{ start: 0, end: Number.MAX_VALUE }];
       }
 
       const previousLastElement = accumulator[accumulator.length - 1];

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

@@ -15,6 +15,7 @@
  */
 
 import StreamOrchestrator, {
+  INeedsMediaSourceReloadPayload,
   IStreamOrchestratorCallbacks,
   IStreamOrchestratorOptions,
   IStreamOrchestratorPlaybackObservation,
@@ -22,6 +23,7 @@ import StreamOrchestrator, {
 
 export default StreamOrchestrator;
 export {
+  INeedsMediaSourceReloadPayload,
   IStreamOrchestratorCallbacks,
   IStreamOrchestratorOptions,
   IStreamOrchestratorPlaybackObservation,

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

@@ -47,7 +47,6 @@ import PeriodStream, {
   IPeriodStreamReadyPayload,
 } from "../period";
 import { IStreamStatusPayload } from "../representation";
-import createReloadRequest from "../utils/create_reload_request";
 import getTimeRangesForContent from "./get_time_ranges_for_content";
 
 /**
@@ -231,8 +230,11 @@ export default function StreamOrchestrator(
             callbacks.lockedStream({ bufferType: payload.bufferType,
                                      period: payload.period });
           } else {
-            const { position, autoPlay } = payload;
-            callbacks.needsMediaSourceReload({ position, autoPlay });
+            callbacks.needsMediaSourceReload({
+              timeOffset: payload.timeOffset,
+              minimumPosition: payload.stayInPeriod ? payload.period.start : undefined,
+              maximumPosition: payload.stayInPeriod ? payload.period.end : undefined,
+            });
           }
         },
         periodStreamReady(payload : IPeriodStreamReadyPayload) : void {
@@ -339,6 +341,9 @@ export default function StreamOrchestrator(
       /** Remove from the `SegmentBuffer` all the concerned time ranges. */
       for (const { start, end } of [...undecipherableRanges, ...rangesToRemove]) {
         if (start < end) {
+          if (orchestratorCancelSignal.isCancelled()) {
+            return;
+          }
           await segmentBuffer.removeBuffer(start, end, orchestratorCancelSignal);
         }
       }
@@ -352,11 +357,9 @@ export default function StreamOrchestrator(
         }
         const observation = playbackObserver.getReference().getValue();
         if (needsFlushingAfterClean(observation, undecipherableRanges)) {
-          const shouldAutoPlay = !(observation.paused.pending ??
-                                   playbackObserver.getIsPaused());
-          callbacks.needsDecipherabilityFlush({ position: observation.position.last,
-                                                autoPlay: shouldAutoPlay,
-                                                duration: observation.duration });
+
+          // Bind to Period start and end
+          callbacks.needsDecipherabilityFlush();
           if (orchestratorCancelSignal.isCancelled()) {
             return ;
           }
@@ -547,10 +550,18 @@ export default function StreamOrchestrator(
             if (manifest.periods.length > 0 &&
                 manifest.periods[0].start <= period.start)
             {
-              createReloadRequest(playbackObserver, ({ position , autoPlay }) => {
-                consecutivePeriodStreamCb
-                  .waitingMediaSourceReload({ bufferType, period, position, autoPlay });
-              }, 0, { start: undefined, end: undefined }, innerCancelSignal);
+              // We begin by scheduling a micro-task to reduce the possibility of race
+              // conditions where the inner logic would be called synchronously before
+              // the next observation (which may reflect very different playback
+              // conditions) is actually received.
+              return nextTick(() => {
+                if (innerCancelSignal.isCancelled()) {
+                  return;
+                }
+                return callbacks.needsMediaSourceReload({ timeOffset: 0,
+                                                          minimumPosition: undefined,
+                                                          maximumPosition: undefined });
+              });
             }
           } else if (period.start > basePeriod.start) {
             break;
@@ -640,7 +651,7 @@ export interface IStreamOrchestratorCallbacks
    * worst cases completely removed and re-created through the "reload" mechanism,
    * depending on the platform.
    */
-  needsDecipherabilityFlush(payload : INeedsDecipherabilityFlushPayload) : void;
+  needsDecipherabilityFlush() : void;
 }
 
 /** Payload for the `periodStreamCleared` callback. */
@@ -666,16 +677,23 @@ export interface IPeriodStreamClearedPayload {
 /** Payload for the `needsMediaSourceReload` callback. */
 export interface INeedsMediaSourceReloadPayload {
   /**
-   * The position in seconds and the time at which the MediaSource should be
-   * reset once it has been reloaded.
+   * Relative position, compared to the current one, at which we should
+   * restart playback after reloading. For example `-2` will reload 2 seconds
+   * before the current position.
    */
-  position : number;
+  timeOffset : number;
   /**
-   * If `true`, we want the HTMLMediaElement to play right after the reload is
-   * done.
-   * If `false`, we want to stay in a paused state at that point.
+   * If defined and if the new position obtained after relying on
+   * `timeOffset` is before `minimumPosition`, then we will reload at
+   * `minimumPosition`  instead.
    */
-  autoPlay : boolean;
+  minimumPosition : number | undefined;
+  /**
+   * If defined and if the new position obtained after relying on
+   * `timeOffset` is after `maximumPosition`, then we will reload at
+   * `maximumPosition`  instead.
+   */
+  maximumPosition : number | undefined;
 }
 
 /** Payload for the `lockedStream` callback. */
@@ -686,28 +704,6 @@ export interface ILockedStreamPayload {
   bufferType : IBufferType;
 }
 
-/** Payload for the `needsDecipherabilityFlush` callback. */
-export interface INeedsDecipherabilityFlushPayload {
-  /**
-   * Indicated in the case where the MediaSource has to be reloaded,
-   * in which case the time of the HTMLMediaElement should be reset to that
-   * position, in seconds, once reloaded.
-   */
-  position : number;
-  /**
-   * If `true`, we want the HTMLMediaElement to play right after the flush is
-   * done.
-   * If `false`, we want to stay in a paused state at that point.
-   */
-  autoPlay : boolean;
-  /**
-   * The duration (maximum seekable position) of the content.
-   * This is indicated in the case where a seek has to be performed, to avoid
-   * seeking too far in the content.
-   */
-  duration : number;
-}
-
 /**
  * Returns `true` if low-level buffers have to be "flushed" after the given
  * `cleanedRanges` time ranges have been removed from an audio or video