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

package/src/core/init/directfile_content_initializer.ts

@@ -26,7 +26,8 @@ import {
   IKeySystemOption,
   IPlayerError,
 } from "../../public_types";
-import createSharedReference, {
+import assert from "../../utils/assert";
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
@@ -39,40 +40,76 @@ import initializeContentDecryption from "./utils/initialize_content_decryption";
 import RebufferingController from "./utils/rebuffering_controller";
 import listenToMediaError from "./utils/throw_on_media_error";
 
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
 export default class DirectFileContentInitializer extends ContentInitializer {
+  /**
+   * Initial options given to the `DirectFileContentInitializer`.
+   */
   private _settings : IDirectFileOptions;
+  /**
+   * Allows to abort and clean everything the `DirectFileContentInitializer` is
+   * doing.
+   */
   private _initCanceller : TaskCanceller;
 
+  /**
+   * Creates a new `DirectFileContentInitializer` linked to the given settings.
+   * @param {Object} settings
+   */
   constructor(settings : IDirectFileOptions) {
     super();
     this._settings = settings;
     this._initCanceller = new TaskCanceller();
   }
 
-  public prepare(): void {
+  /**
+   * "Prepare" content so it can later be played by calling `start`.
+   */
+  public prepare() : void {
     return; // Directfile contents do not have any preparation
   }
 
+  /**
+   * Start playback of the content linked to this `DirectFileContentInitializer`
+   * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+   * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+   * content will be played.
+   * @param {Object} playbackObserver - Object regularly emitting playback
+   * information.
+   */
   public start(
     mediaElement : HTMLMediaElement,
     playbackObserver : PlaybackObserver
-  ): void {
+  ) : void {
     const cancelSignal = this._initCanceller.signal;
     const { keySystems, speed, url } = this._settings;
 
     clearElementSrc(mediaElement);
 
-    if (url == null) {
-      throw new Error("No URL for a DirectFile content");
-    }
-
-    const decryptionRef = createSharedReference(null);
+    /**
+     * Create dummy encryption data emitter, as those are not sent from the
+     * RxPlayer for directfile contents.
+     */
+    const decryptionRef = new SharedReference(null);
     decryptionRef.finish();
+
     const drmInitRef =
-      initializeContentDecryption(mediaElement, keySystems, decryptionRef, {
-        onError: (err) =>  this._onFatalError(err),
-        onWarning: (err : IPlayerError) => this.trigger("warning", err),
-      }, cancelSignal);
+      initializeContentDecryption(
+        mediaElement,
+        keySystems,
+        decryptionRef,
+        { onError: (err) =>  this._onFatalError(err),
+          onWarning: (err : IPlayerError) => this.trigger("warning", err) },
+        cancelSignal);
 
     /** Translate errors coming from the media element into RxPlayer errors. */
     listenToMediaError(mediaElement,
@@ -100,7 +137,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
 
     drmInitRef.onUpdate((evt, stopListeningToDrmUpdates) => {
       if (evt.initializationState.type === "uninitialized") {
-        return;
+        return; // nothing done yet
       }
       stopListeningToDrmUpdates();
 
@@ -108,41 +145,60 @@ export default class DirectFileContentInitializer extends ContentInitializer {
       log.info("Setting URL to HTMLMediaElement", url);
       mediaElement.src = url;
       cancelSignal.register(() => {
+        log.info("Init: Removing directfile src from media element", mediaElement.src);
         clearElementSrc(mediaElement);
       });
+
       if (evt.initializationState.type === "awaiting-media-link") {
         evt.initializationState.value.isMediaLinked.setValue(true);
         drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
           if (newDrmStatus.initializationState.type === "initialized") {
             stopListeningToDrmUpdatesAgain();
             this._seekAndPlay(mediaElement, playbackObserver);
-            return;
           }
         }, { emitCurrentValue: true, clearSignal: cancelSignal });
       } else {
+        assert(evt.initializationState.type === "initialized");
         this._seekAndPlay(mediaElement, playbackObserver);
-        return;
       }
     }, { emitCurrentValue: true, clearSignal: cancelSignal });
   }
 
+  /**
+   * Update URL this `ContentIntializer` depends on.
+   * @param {Array.<string>|undefined} _urls
+   * @param {boolean} _refreshNow
+   */
   public updateContentUrls(_urls : string[] | undefined, _refreshNow : boolean) : void {
     throw new Error("Cannot update content URL of directfile contents");
   }
 
-  public dispose(): void {
+  /**
+   * Stop content and free all resources linked to this `ContentIntializer`.
+   */
+  public dispose() : void {
     this._initCanceller.cancel();
   }
 
-  private _onFatalError(err : unknown) {
+  /**
+   * Logic performed when a fatal error was triggered.
+   * @param {*} err - The fatal error in question.
+   */
+  private _onFatalError(err : unknown) : void {
     this._initCanceller.cancel();
     this.trigger("error", err);
   }
 
+  /**
+   * Perform the initial seek (to begin playback at an initially-calculated
+   * position based on settings) and auto-play if needed when loaded.
+   * @param {HTMLMediaElement} mediaElement
+   * @param {Object} playbackObserver
+   */
   private _seekAndPlay(
     mediaElement : HTMLMediaElement,
     playbackObserver : PlaybackObserver
-  ) {
+  ) : void {
     const cancelSignal = this._initCanceller.signal;
     const { autoPlay, startAt } = this._settings;
     const initialTime = () => {
@@ -178,7 +234,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
 /**
  * calculate initial time as a position in seconds.
  * @param {HTMLMediaElement} mediaElement
- * @param {Object|undefined} startAt
+ * @param {Object|undefined} [startAt]
  * @returns {number}
  */
 function getDirectFileInitialTime(
@@ -220,11 +276,19 @@ function getDirectFileInitialTime(
   return 0;
 }
 
-// Argument used by `initializeDirectfileContent`
+/** Options used by the `DirectFileContentInitializer` */
 export interface IDirectFileOptions {
+  /** If `true` we will play right after the content is considered "loaded". */
   autoPlay : boolean;
+  /**
+   * Encryption-related settings. Can be left as an empty array if the content
+   * isn't encrypted.
+   */
   keySystems : IKeySystemOption[];
+  /** Communicate the playback rate wanted by the user. */
   speed : IReadOnlySharedReference<number>;
+  /** Optional initial position to start at. */
   startAt? : IInitialTimeOptions | undefined;
-  url? : string | undefined;
+  /** URL that should be played. */
+  url : string;
 }

package/src/core/init/index.ts

@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-import MediaSourceContentInitializer, {
-  IInitializeArguments,
-} from "./media_source_content_initializer";
-export * from "./types";
-
-export default MediaSourceContentInitializer;
-export { IInitializeArguments };
+export {
+  ContentInitializer,
+  IContentInitializerEvents,
+  IAdaptationChangeEventPayload,
+  IStallingSituation,
+} from "./types";

package/src/core/init/media_source_content_initializer.ts

@@ -27,9 +27,8 @@ import { ITransportPipelines } from "../../transports";
 import assert from "../../utils/assert";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
 import objectAssign from "../../utils/object_assign";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../utils/reference";
 import TaskCanceller, {
   CancellationSignal,
@@ -69,7 +68,7 @@ import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
 import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
-import streamEventsEmitter from "./utils/stream_events_emitter";
+import StreamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
 
 /**
@@ -159,7 +158,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                        this._initCanceller.signal);
 
     /** Send content protection initialization data to the decryption logic. */
-    const protectionRef = createSharedReference<IContentProtection | null>(
+    const protectionRef = new SharedReference<IContentProtection | null>(
       null,
       this._initCanceller.signal
     );
@@ -212,10 +211,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
       /** Initialize decryption capabilities. */
       const drmInitRef =
-        initializeContentDecryption(mediaElement, keySystems, protectionRef, {
-          onWarning: (err : IPlayerError) => this.trigger("warning", err),
-          onError: (err : Error) => this._onFatalError(err),
-        }, initCanceller.signal);
+        initializeContentDecryption(
+          mediaElement,
+          keySystems,
+          protectionRef,
+          { onWarning: (err : IPlayerError) => this.trigger("warning", err),
+            onError: (err : Error) => this._onFatalError(err) },
+          initCanceller.signal);
 
       drmInitRef.onUpdate((drmStatus, stopListeningToDrmUpdates) => {
         if (drmStatus.initializationState.type === "uninitialized") {
@@ -261,7 +263,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     initialMediaSource : MediaSource,
     playbackObserver : PlaybackObserver,
     drmSystemId : string | undefined,
-    protectionRef : ISharedReference<IContentProtection | null>,
+    protectionRef : SharedReference<IContentProtection | null>,
     initialMediaSourceCanceller : TaskCanceller
   ) : Promise<void> {
     const { adaptiveOptions,
@@ -429,22 +431,30 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     initialPlayPerformed.onUpdate((isPerformed, stopListening) => {
       if (isPerformed) {
         stopListening();
-        streamEventsEmitter(manifest,
-                            mediaElement,
-                            playbackObserver,
-                            (evt) => this.trigger("streamEvent", evt),
-                            (evt) => this.trigger("streamEventSkip", evt),
-                            cancelSignal);
+        const streamEventsEmitter = new StreamEventsEmitter(manifest,
+                                                            mediaElement,
+                                                            playbackObserver);
+        streamEventsEmitter.addEventListener("event", (payload) => {
+          this.trigger("streamEvent", payload);
+        }, cancelSignal);
+        streamEventsEmitter.addEventListener("eventSkip", (payload) => {
+          this.trigger("streamEventSkip", payload);
+        }, cancelSignal);
+        streamEventsEmitter.start();
+        cancelSignal.register(() => {
+          streamEventsEmitter.stop();
+        });
       }
     }, { clearSignal: cancelSignal, emitCurrentValue: true });
 
-    const streamObserver = createStreamPlaybackObserver(manifest,
-                                                        playbackObserver,
+    const streamObserver = createStreamPlaybackObserver(playbackObserver,
                                                         { autoPlay,
+                                                          manifest,
                                                           initialPlayPerformed,
                                                           initialSeekPerformed,
                                                           speed,
-                                                          startTime: initialTime });
+                                                          startTime: initialTime },
+                                                        cancelSignal);
 
     const rebufferingController = this._createRebufferingController(playbackObserver,
                                                                     manifest,
@@ -623,21 +633,41 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         bitrateEstimateChange: (value) =>
           self.trigger("bitrateEstimateChange", value),
 
-        addedSegment: (value) => self.trigger("addedSegment", value),
-
-        needsMediaSourceReload: (value) => onReloadOrder(value),
+        needsMediaSourceReload: (payload) => {
+          const lastObservation = streamObserver.getReference().getValue();
+          const currentPosition = lastObservation.position.pending ??
+                                  streamObserver.getCurrentTime();
+          const isPaused = lastObservation.paused.pending ??
+                           streamObserver.getIsPaused();
+          let position = currentPosition + payload.timeOffset;
+          if (payload.minimumPosition !== undefined) {
+            position = Math.max(payload.minimumPosition, position);
+          }
+          if (payload.maximumPosition !== undefined) {
+            position = Math.min(payload.maximumPosition, position);
+          }
+          onReloadOrder({ position, autoPlay: !isPaused });
+        },
 
-        needsDecipherabilityFlush(value) {
+        needsDecipherabilityFlush() {
           const keySystem = getKeySystemConfiguration(mediaElement);
           if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem?.[0])) {
-            onReloadOrder(value);
+            const lastObservation = streamObserver.getReference().getValue();
+            const position = lastObservation.position.pending ??
+                             streamObserver.getCurrentTime();
+            const isPaused = lastObservation.paused.pending ??
+                             streamObserver.getIsPaused();
+            onReloadOrder({ position, autoPlay: !isPaused });
           } else {
+            const lastObservation = streamObserver.getReference().getValue();
+            const position = lastObservation.position.pending ??
+                             streamObserver.getCurrentTime();
             // simple seek close to the current position
             // to flush the buffers
-            if (value.position + 0.001 < value.duration) {
+            if (position + 0.001 < lastObservation.duration) {
               playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
             } else {
-              playbackObserver.setCurrentTime(value.position);
+              playbackObserver.setCurrentTime(position);
             }
           }
         },
@@ -838,7 +868,7 @@ interface IBufferingMediaSettings {
    * Reference through which decryption initialization information can be
    * communicated.
    */
-  protectionRef : ISharedReference<IContentProtection | null>;
+  protectionRef : SharedReference<IContentProtection | null>;
   /** `MediaSource` element on which the media will be buffered. */
   mediaSource : MediaSource;
   /** The initial position to seek to in media time, in seconds. */

package/src/core/init/types.ts

@@ -16,13 +16,12 @@
 
 import Manifest, {
   Adaptation,
-  ISegment,
   Period,
   Representation,
 } from "../../manifest";
 import { IPlayerError } from "../../public_types";
 import EventEmitter from "../../utils/event_emitter";
-import { ISharedReference } from "../../utils/reference";
+import SharedReference from "../../utils/reference";
 import { PlaybackObserver } from "../api";
 import SegmentBuffersStore, {
   IBufferType,
@@ -170,7 +169,7 @@ export interface IContentInitializerEvents {
      * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
      * yourself.
      */
-    adaptationRef : ISharedReference<IAdaptationChoice|null|undefined>;
+    adaptationRef : SharedReference<IAdaptationChoice|null|undefined>;
   };
   /**
    * A `PeriodStream` has been removed.
@@ -219,19 +218,6 @@ export interface IContentInitializerEvents {
     representation : Representation |
                      null;
   };
-  /** Emitted after a new segment has been succesfully added to the SegmentBuffer */
-  addedSegment: {
-    /** Context about the content that has been added. */
-    content: { period : Period;
-               adaptation : Adaptation;
-               representation : Representation; };
-    /** The concerned Segment. */
-    segment : ISegment;
-    /** TimeRanges of the concerned SegmentBuffer after the segment was pushed. */
-    buffered : TimeRanges;
-    /* The data pushed */
-    segmentData : unknown;
-  };
   /**
    * Event emitted when one or multiple inband events (i.e. events inside a
    * given segment) have been encountered.

package/src/core/init/utils/__tests__/refresh_scheduled_events_list.test.ts

@@ -22,18 +22,32 @@
 
 describe("core - init - refreshScheduledEventsList", () => {
   it("should correclty refresh scheduled events", () => {
+    function generateEventData() {
+      return {
+        type: "dash-event-stream",
+        value: {
+          schemeIdUri: "toto",
+          timescale: 1,
+          element: document.createElement("div"),
+        },
+      };
+    }
     const manifest = { periods: [ { start: 0,
                                     streamEvents: [{ start: 0,
                                                      end: 1,
+                                                     data: generateEventData(),
                                                      id: "1" }] },
                                   { start: 10,
                                     streamEvents: [{ start: 11,
                                                      end: 20,
+                                                     data: generateEventData(),
                                                      id: "2" },
                                                    { start: 12,
+                                                     data: generateEventData(),
                                                      id: "3" },
                                                    { start: 13,
                                                      end: 13.1,
+                                                     data: generateEventData(),
                                                      id: "4" }] } ] };
     const oldScheduledEvents = [
       { start: 1000,
@@ -42,7 +56,7 @@ describe("core - init - refreshScheduledEventsList", () => {
         _isBeingPlayed: true },
       { start: 0,
         end: 1,
-        data: undefined,
+        data: generateEventData(),
         id: "1" },
     ];
     const refreshScheduledEventsList = jest.requireActual(
@@ -54,27 +68,27 @@ describe("core - init - refreshScheduledEventsList", () => {
       { start: 0,
         end: 1,
         id: "1",
-        data: undefined },
+        data: generateEventData() },
       { start: 11,
         end: 20,
         id: "2",
         publicEvent: { start: 11,
                        end: 20,
-                       data: undefined },
-        data: undefined },
+                       data: generateEventData() },
+        data: generateEventData() },
       { start: 12,
         end: undefined,
         id: "3",
         publicEvent: { start: 12,
-                       data: undefined },
-        data: undefined },
+                       data: generateEventData() },
+        data: generateEventData() },
       { start: 13,
         end: 13.1,
         id: "4",
         publicEvent: { start: 13,
                        end: 13.1,
-                       data: undefined },
-        data: undefined },
+                       data: generateEventData() },
+        data: generateEventData() },
     ]);
   });
 });

package/src/core/init/utils/create_media_source.ts

@@ -45,9 +45,10 @@ export function resetMediaSource(
       const sourceBuffer = sourceBuffers[i];
       try {
         if (readyState === "open") {
-          log.info("Init: Removing SourceBuffer from mediaSource");
+          log.info("Init: Aborting SourceBuffer before removing");
           sourceBuffer.abort();
         }
+        log.info("Init: Removing SourceBuffer from mediaSource");
         mediaSource.removeSourceBuffer(sourceBuffer);
       }
       catch (e) {
@@ -60,6 +61,7 @@ export function resetMediaSource(
     }
   }
 
+  log.info("Init: Clearing HTMLMediaElement's src");
   clearElementSrc(mediaElement);
 
   if (mediaSourceURL !== null) {
@@ -130,6 +132,7 @@ export default function openMediaSource(
   return createCancellablePromise(unlinkSignal, (resolve) => {
     const mediaSource = createMediaSource(mediaElement, unlinkSignal);
     events.onSourceOpen(mediaSource, () => {
+      log.info("Init: MediaSource opened");
       resolve(mediaSource);
     }, unlinkSignal);
   });

package/src/core/init/utils/create_stream_playback_observer.ts

@@ -15,10 +15,12 @@
  */
 
 import Manifest from "../../../manifest";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../../../utils/task_canceller";
 import {
   IPlaybackObservation,
   IReadOnlyPlaybackObserver,
@@ -30,6 +32,8 @@ import { IStreamOrchestratorPlaybackObservation } from "../../stream";
 export interface IStreamPlaybackObserverArguments {
   /** If true, the player will auto-play when `initialPlayPerformed` becomes `true`. */
   autoPlay : boolean;
+  /** Manifest of the content being played */
+  manifest : Manifest;
   /** Becomes `true` after the initial play has been taken care of. */
   initialPlayPerformed : IReadOnlySharedReference<boolean>;
   /** Becomes `true` after the initial seek has been taken care of. */
@@ -42,34 +46,40 @@ export interface IStreamPlaybackObserverArguments {
 
 /**
  * Create PlaybackObserver for the `Stream` part of the code.
- * @param {Object} manifest
- * @param {Object} playbackObserver
- * @param {Object} args
+ * @param {Object} srcPlaybackObserver - Base `PlaybackObserver` from which we
+ * will derive information.
+ * @param {Object} context - Various information linked to the current content
+ * being played.
+ * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
  * @returns {Object}
  */
 export default function createStreamPlaybackObserver(
-  manifest : Manifest,
-  playbackObserver : PlaybackObserver,
+  srcPlaybackObserver : PlaybackObserver,
   { autoPlay,
     initialPlayPerformed,
     initialSeekPerformed,
+    manifest,
     speed,
-    startTime } : IStreamPlaybackObserverArguments
+    startTime } : IStreamPlaybackObserverArguments,
+  fnCancelSignal : CancellationSignal
 ) : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation> {
-  return playbackObserver.deriveReadOnlyObserver(function transform(
+  return srcPlaybackObserver.deriveReadOnlyObserver(function transform(
     observationRef : IReadOnlySharedReference<IPlaybackObservation>,
-    cancellationSignal : CancellationSignal
+    parentObserverCancelSignal : CancellationSignal
   ) : IReadOnlySharedReference<IStreamOrchestratorPlaybackObservation> {
-    const newRef = createSharedReference(constructStreamPlaybackObservation(),
-                                         cancellationSignal);
+    const canceller = new TaskCanceller();
+    canceller.linkToSignal(parentObserverCancelSignal);
+    canceller.linkToSignal(fnCancelSignal);
+    const newRef = new SharedReference(constructStreamPlaybackObservation(),
+                                       canceller.signal);
 
     speed.onUpdate(emitStreamPlaybackObservation, {
-      clearSignal: cancellationSignal,
+      clearSignal: canceller.signal,
       emitCurrentValue: false,
     });
 
     observationRef.onUpdate(emitStreamPlaybackObservation, {
-      clearSignal: cancellationSignal,
+      clearSignal: canceller.signal,
       emitCurrentValue: false,
     });
     return newRef;

package/src/core/init/utils/end_of_stream.ts

@@ -98,6 +98,7 @@ export function maintainEndOfStream(
   let endOfStreamCanceller = new TaskCanceller();
   endOfStreamCanceller.linkToSignal(cancelSignal);
   onSourceOpen(mediaSource, () => {
+    log.debug("Init: MediaSource re-opened while end-of-stream is active");
     endOfStreamCanceller.cancel();
     endOfStreamCanceller = new TaskCanceller();
     endOfStreamCanceller.linkToSignal(cancelSignal);

package/src/core/init/utils/get_initial_time.ts

@@ -18,6 +18,7 @@ import config from "../../../config";
 import log from "../../../log";
 import Manifest from "../../../manifest";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 
 /**
  * All possible initial time options that can be set.
@@ -134,7 +135,8 @@ export default function getInitialTime(
       const ast = manifest.availabilityStartTime === undefined ?
         0 :
         manifest.availabilityStartTime;
-      const clockRelativeLiveTime = (performance.now() + clockOffset) / 1000 - ast;
+      const clockRelativeLiveTime =
+        (getMonotonicTimeStamp() + clockOffset) / 1000 - ast;
       liveTime = Math.min(maximumPosition,
                           clockRelativeLiveTime);
     }

package/src/core/init/utils/get_loaded_reference.ts

@@ -18,8 +18,9 @@
 import {
   shouldValidateMetadata,
   shouldWaitForDataBeforeLoaded,
+  shouldWaitForHaveEnoughData,
 } from "../../../compat";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, { CancellationSignal } from "../../../utils/task_canceller";
@@ -45,7 +46,7 @@ export default function getLoadedReference(
 ) : IReadOnlySharedReference<boolean> {
   const listenCanceller = new TaskCanceller();
   listenCanceller.linkToSignal(cancelSignal);
-  const isLoaded = createSharedReference(false, listenCanceller.signal);
+  const isLoaded = new SharedReference(false, listenCanceller.signal);
   playbackObserver.listen((observation) => {
     if (observation.rebuffering !== null ||
         observation.freezing !== null ||
@@ -64,7 +65,9 @@ export default function getLoadedReference(
       }
     }
 
-    if (observation.readyState >= 3 && observation.currentRange !== null) {
+    const minReadyState = shouldWaitForHaveEnoughData() ? 4 :
+                                                          3;
+    if (observation.readyState >= minReadyState && observation.currentRange !== null) {
       if (!shouldValidateMetadata() || mediaElement.duration > 0) {
         isLoaded.setValue(true);
         listenCanceller.cancel();