rx-player 4.2.0-dev.2024092400 → 4.2.0-dev.2024101500

package/src/core/main/worker/worker_main.ts

@@ -80,6 +80,9 @@ export default function initializeWorkerMain() {
    */
   let playbackObservationRef: SharedReference<IWorkerPlaybackObservation> | null = null;
 
+  onmessageerror = (_msg: MessageEvent) => {
+    log.error("MTCI: Error when receiving message from main thread.");
+  };
   onmessage = function (e: MessageEvent<IMainThreadMessage>) {
     log.debug("Worker: received message", e.data.type);
 

package/src/core/segment_sinks/segment_buffers_store.ts

@@ -103,7 +103,11 @@ export default class SegmentSinksStore {
    * disabled. This means that the corresponding type (e.g. audio, video etc.)
    * won't be needed when playing the current content.
    */
-  private _initializedSegmentSinks: Partial<Record<IBufferType, SegmentSink | null>>;
+  private _initializedSegmentSinks: {
+    audio?: AudioVideoSegmentSink | undefined | null;
+    video?: AudioVideoSegmentSink | undefined | null;
+    text?: TextSegmentSink | null;
+  };
 
   /**
    * Callbacks called after a SourceBuffer is either created or disabled.
@@ -308,7 +312,7 @@ export default class SegmentSinksStore {
       return memorizedSegmentSink;
     }
 
-    let segmentSink: SegmentSink;
+    let segmentSink: TextSegmentSink;
     if (bufferType === "text") {
       log.info("SB: Creating a new text SegmentSink");
       if (this._textInterface === null) {

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

@@ -376,8 +376,13 @@ export default function AdaptationStream(
     representationStreamCallbacks: IRepresentationStreamCallbacks,
     fnCancelSignal: CancellationSignal,
   ): void {
+    /** Set to `true` if we've encountered an error with this `RepresentationStream` */
+    let hasEncounteredError = false;
+
     const bufferGoalCanceller = new TaskCanceller();
     bufferGoalCanceller.linkToSignal(fnCancelSignal);
+
+    /** Actually built buffer size, in seconds. */
     const bufferGoal = createMappedReference(
       wantedBufferAhead,
       (prev) => {
@@ -385,6 +390,7 @@ export default function AdaptationStream(
       },
       bufferGoalCanceller.signal,
     );
+
     const maxBufferSize =
       adaptation.type === "video" ? maxVideoBufferSize : new SharedReference(Infinity);
     log.info(
@@ -394,7 +400,18 @@ export default function AdaptationStream(
       representation.bitrate,
     );
     const updatedCallbacks = objectAssign({}, representationStreamCallbacks, {
-      error(err: unknown) {
+      error(err: Error) {
+        if (hasEncounteredError) {
+          // A RepresentationStream might trigger multiple Errors (for example
+          // multiple segments it tried to push at once led to errors).
+          // In that case, we'll only consider the first Error.
+          //
+          // That could mean that we're hiding legitimate issues but handling
+          // multiple of those errors at once is too hard a task for now.
+          log.warn("Stream: Ignoring RepresentationStream error", err);
+          return;
+        }
+        hasEncounteredError = true;
         const formattedError = formatError(err, {
           defaultCode: "NONE",
           defaultReason: "Unknown `RepresentationStream` error",
@@ -402,6 +419,11 @@ export default function AdaptationStream(
         if (formattedError.code !== "BUFFER_FULL_ERROR") {
           representationStreamCallbacks.error(err);
         } else {
+          log.warn(
+            "Stream: received BUFFER_FULL_ERROR",
+            adaptation.type,
+            representation.bitrate,
+          );
           const wba = wantedBufferAhead.getValue();
           const lastBufferGoalRatio = bufferGoalRatioMap.get(representation.id) ?? 1;
           // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%

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

@@ -90,6 +90,11 @@ export default function RepresentationStream<TSegmentDataType>(
   callbacks: IRepresentationStreamCallbacks,
   parentCancelSignal: CancellationSignal,
 ): void {
+  log.debug(
+    "Stream: Creating RepresentationStream",
+    content.adaptation.type,
+    content.representation.bitrate,
+  );
   const { period, adaptation, representation } = content;
   const { bufferGoal, maxBufferSize, drmSystemId, fastSwitchThreshold } = options;
   const bufferType = adaptation.type;
@@ -488,6 +493,12 @@ export default function RepresentationStream<TSegmentDataType>(
       // We can thus ignore it, it is very unlikely to lead to true buffer issues.
       return;
     }
+    log.warn(
+      "Stream: Received fatal buffer error",
+      adaptation.type,
+      representation.bitrate,
+      err instanceof Error ? err : null,
+    );
     globalCanceller.cancel();
     callbacks.error(err);
   }

package/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts

@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
+import { canRelyOnRequestMediaKeySystemAccess } from "../../../../compat/can_rely_on_request_media_key_system_access";
 import eme from "../../../../compat/eme";
+import {
+  DUMMY_PLAY_READY_HEADER,
+  generatePlayReadyInitData,
+} from "../../../../compat/generate_init_data";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import log from "../log";
 import type { ICompatibleKeySystem, IMediaConfiguration } from "../types";
@@ -57,13 +62,40 @@ export default function probeDRMInfos(
 
   return eme
     .requestMediaKeySystemAccess(type, [configuration])
-    .then((keySystemAccess) => {
-      result.compatibleConfiguration = keySystemAccess.getConfiguration();
-      const status: [ProberStatus, ICompatibleKeySystem?] = [
-        ProberStatus.Supported,
-        result,
-      ];
-      return status;
+    .then(async (keySystemAccess) => {
+      if (!canRelyOnRequestMediaKeySystemAccess(type)) {
+        try {
+          const mediaKeys = await keySystemAccess.createMediaKeys();
+          const session = mediaKeys.createSession();
+          const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
+          await session.generateRequest("cenc", initData);
+          session.close().catch(() => {
+            log.warn("DRM: Failed to close the dummy session");
+          });
+          result.compatibleConfiguration = keySystemAccess.getConfiguration();
+          const status: [ProberStatus, ICompatibleKeySystem?] = [
+            ProberStatus.Supported,
+            result,
+          ];
+          return status;
+        } catch (err) {
+          log.debug("DRM: KeySystemAccess was granted but it is not usable");
+
+          const statusError: [ProberStatus, ICompatibleKeySystem] = [
+            ProberStatus.NotSupported,
+            result,
+          ];
+          return statusError;
+        }
+      } else {
+        result.compatibleConfiguration = keySystemAccess.getConfiguration();
+
+        const status: [ProberStatus, ICompatibleKeySystem?] = [
+          ProberStatus.Supported,
+          result,
+        ];
+        return status;
+      }
     })
     .catch(() => {
       return [ProberStatus.NotSupported, result];

package/src/main_thread/api/debug/modules/general_info.ts

@@ -65,7 +65,7 @@ export default function constructDebugGeneralInfo(
         valuesLine1.push(["wo", "0"]);
       }
 
-      const valuesLine2: Array<[string, string]> = [];
+      const valuesLine2: Array<[string, string]> = [["v", instance.version]];
       const ks = instance.getKeySystemConfiguration();
       if (ks !== null) {
         valuesLine2.push(["ks", ks.keySystem]);

package/src/main_thread/api/public_api.ts

@@ -411,7 +411,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024092400";
+    this.version = /* PLAYER_VERSION */ "4.2.0-dev.2024101500";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3330,7 +3330,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024092400";
+Player.version = /* PLAYER_VERSION */ "4.2.0-dev.2024101500";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/find_key_system.ts

@@ -539,6 +539,9 @@ export async function testKeySystem(
       const session = mediaKeys.createSession();
       const initData = generatePlayReadyInitData(DUMMY_PLAY_READY_HEADER);
       await session.generateRequest("cenc", initData);
+      session.close().catch(() => {
+        log.warn("DRM: Failed to close the dummy session");
+      });
     } catch (err) {
       log.debug("DRM: KeySystemAccess was granted but it is not usable");
       throw err;

package/src/main_thread/init/directfile_content_initializer.ts

@@ -254,7 +254,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
 function getDirectFileInitialTime(
   mediaElement: IMediaElement,
   startAt?: IInitialTimeOptions,
-): number {
+): number | undefined {
   if (isNullOrUndefined(startAt)) {
     return 0;
   }
@@ -268,28 +268,38 @@ function getDirectFileInitialTime(
   }
 
   const duration = mediaElement.duration;
-
   if (typeof startAt.fromLastPosition === "number") {
-    if (isNullOrUndefined(duration) || !isFinite(duration)) {
-      log.warn(
-        "startAt.fromLastPosition set but no known duration, " + "beginning at 0.",
-      );
-      return 0;
+    if (!isNullOrUndefined(duration) && isFinite(duration)) {
+      return Math.max(0, duration + startAt.fromLastPosition);
     }
-    return Math.max(0, duration + startAt.fromLastPosition);
+
+    if (mediaElement.seekable.length > 0) {
+      const lastSegmentEnd = mediaElement.seekable.end(mediaElement.seekable.length - 1);
+      if (isFinite(lastSegmentEnd)) {
+        return Math.max(0, lastSegmentEnd + startAt.fromLastPosition);
+      }
+    }
+    log.warn(
+      "Init: startAt.fromLastPosition set but no known duration, " +
+        "it may be too soon to seek",
+    );
+    return undefined;
   } else if (typeof startAt.fromLivePosition === "number") {
     const livePosition =
       mediaElement.seekable.length > 0 ? mediaElement.seekable.end(0) : duration;
     if (isNullOrUndefined(livePosition)) {
       log.warn(
-        "startAt.fromLivePosition set but no known live position, " + "beginning at 0.",
+        "Init: startAt.fromLivePosition set but no known live position, " +
+          "beginning at 0.",
       );
       return 0;
     }
     return Math.max(0, livePosition + startAt.fromLivePosition);
   } else if (!isNullOrUndefined(startAt.percentage)) {
     if (isNullOrUndefined(duration) || !isFinite(duration)) {
-      log.warn("startAt.percentage set but no known duration, " + "beginning at 0.");
+      log.warn(
+        "Init: startAt.percentage set but no known duration, " + "beginning at 0.",
+      );
       return 0;
     }
     const { percentage } = startAt;

package/src/main_thread/init/media_source_content_initializer.ts

@@ -92,7 +92,7 @@ import listenToMediaError from "./utils/throw_on_media_error";
  */
 export default class MediaSourceContentInitializer extends ContentInitializer {
   /** Constructor settings associated to this `MediaSourceContentInitializer`. */
-  private _settings: IInitializeArguments;
+  private _initSettings: IInitializeArguments;
   /**
    * `TaskCanceller` allowing to abort everything that the
    * `MediaSourceContentInitializer` is doing.
@@ -145,7 +145,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   constructor(settings: IInitializeArguments) {
     super();
-    this._settings = settings;
+    this._initSettings = settings;
     this._initCanceller = new TaskCanceller();
     this._manifest = null;
     this._decryptionCapabilities = { status: "uninitialized", value: null };
@@ -234,6 +234,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this._initCanceller.cancel();
   }
 
+  /**
+   * Callback called when an error interrupting playback arised.
+   * @param {*} err
+   */
   private _onFatalError(err: unknown) {
     if (this._initCanceller.isUsed()) {
       return;
@@ -242,6 +246,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     this.trigger("error", err);
   }
 
+  /**
+   * Initialize decryption mechanisms if needed and begin creating and relying
+   * on the initial `MediaSourceInterface` for this content.
+   * @param {HTMLMediaElement|null} mediaElement
+   * @returns {Promise.<Object>}
+   */
   private _initializeMediaSourceAndDecryption(mediaElement: IMediaElement): Promise<{
     mediaSource: MainMediaSourceInterface;
     drmSystemId: string | undefined;
@@ -249,7 +259,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }> {
     const initCanceller = this._initCanceller;
     return createCancellablePromise(initCanceller.signal, (resolve) => {
-      const { keySystems } = this._settings;
+      const { keySystems } = this._initSettings;
 
       /** Initialize decryption capabilities. */
       const { statusRef: drmInitRef, contentDecryptor } = initializeContentDecryption(
@@ -383,7 +393,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       startAt,
       textTrackOptions,
       transport,
-    } = this._settings;
+    } = this._initSettings;
     const initCanceller = this._initCanceller;
     assert(this._manifest !== null);
     let manifest: IManifest;
@@ -526,7 +536,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
    */
   private _startBufferingOnMediaSource(
     args: IBufferingMediaSettings,
-    onReloadOrder: (reloadOrder: { position: number; autoPlay: boolean }) => void,
+    onReloadOrder: IReloadMediaSourceCallback,
     cancelSignal: CancellationSignal,
   ): void {
     const {
@@ -553,18 +563,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     }
 
     let textDisplayerInterface: ITextDisplayerInterface | null = null;
-    let textDisplayer: ITextDisplayer | null = null;
-    if (
-      this._settings.textTrackOptions.textTrackMode === "html" &&
-      features.htmlTextDisplayer !== null
-    ) {
-      textDisplayer = new features.htmlTextDisplayer(
-        mediaElement,
-        this._settings.textTrackOptions.textTrackElement,
-      );
-    } else if (features.nativeTextDisplayer !== null) {
-      textDisplayer = new features.nativeTextDisplayer(mediaElement);
-    }
+    const textDisplayer = createTextDisplayer(
+      mediaElement,
+      this._initSettings.textTrackOptions,
+    );
     if (textDisplayer !== null) {
       const sender = new MainThreadTextDisplayerInterface(textDisplayer);
       textDisplayerInterface = sender;
@@ -1123,6 +1125,21 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 }
 
+function createTextDisplayer(
+  mediaElement: IMediaElement,
+  textTrackOptions: ITextDisplayerOptions,
+): ITextDisplayer | null {
+  if (textTrackOptions.textTrackMode === "html" && features.htmlTextDisplayer !== null) {
+    return new features.htmlTextDisplayer(
+      mediaElement,
+      textTrackOptions.textTrackElement,
+    );
+  } else if (features.nativeTextDisplayer !== null) {
+    return new features.nativeTextDisplayer(mediaElement);
+  }
+  return null;
+}
+
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
   /** Options concerning the ABR logic. */
@@ -1324,3 +1341,19 @@ function blackListProtectionDataOnManifest(
     return rep.decipherable;
   });
 }
+
+/**
+ * Function to call when you want to "reload" the MediaSource: basically
+ * restarting playback on a new MediaSource for the same content (it may
+ * be for varied reasons, such as ensuring data buffers are empty, or
+ * restarting after some kind of fatal error).
+ * @param {Object} reloadOrder
+ * @param {number} reloadOrder.position - Position in seconds at which we
+ * should restart from when playback restarts.
+ * @param {boolean} reloadOrder.autoPlay - If `true` we will directly play
+ * once enough data is re-loaded.
+ */
+type IReloadMediaSourceCallback = (reloadOrder: {
+  position: number;
+  autoPlay: boolean;
+}) => void;

package/src/main_thread/init/multi_thread_content_initializer.ts

@@ -78,6 +78,20 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
   /** Constructor settings associated to this `MultiThreadContentInitializer`. */
   private _settings: IInitializeArguments;
 
+  /**
+   * The WebWorker may be sending messages as soon as we're preparing the
+   * content but the `MultiThreadContentInitializer` is only able to handle all of
+   * them only once `start`ed.
+   *
+   * As such `_queuedWorkerMessages` is set to an Array  when `prepare` has been
+   * called but not `start` yet, and contains all worker messages that have to
+   * be processed when `start` is called.
+   *
+   * It is set to `null` when there's no need to rely on that queue (either not
+   * yet `prepare`d or already `start`ed).
+   */
+  private _queuedWorkerMessages: MessageEvent[] | null;
+
   /**
    * Information relative to the current loaded content.
    *
@@ -99,12 +113,13 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
   private _currentMediaSourceCanceller: TaskCanceller;
 
   /**
-   * Stores the resolvers and the current messageId that is sent to the web worker to receive segment sink metrics.
+   * Stores the resolvers and the current messageId that is sent to the web worker to
+   * receive segment sink metrics.
    * The purpose of collecting metrics is for monitoring and debugging.
    */
   private _segmentMetrics: {
     lastMessageId: number;
-    resolvers: Record<number, (value: ISegmentSinkMetrics | undefined) => void>;
+    resolvers: Map<number, (value: ISegmentSinkMetrics | undefined) => void>;
   };
 
   /**
@@ -121,8 +136,9 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
     this._currentContentInfo = null;
     this._segmentMetrics = {
       lastMessageId: 0,
-      resolvers: {},
+      resolvers: new Map(),
     };
+    this._queuedWorkerMessages = null;
   }
 
   /**
@@ -176,6 +192,66 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
     if (this._initCanceller.isUsed()) {
       return;
     }
+    this._queuedWorkerMessages = [];
+    log.debug("MTCI: addEventListener prepare buffering worker messages");
+    const onmessage = (evt: MessageEvent): void => {
+      const msgData = evt.data as unknown as IWorkerMessage;
+      const type = msgData.type;
+      switch (type) {
+        case WorkerMessageType.LogMessage: {
+          const formatted = msgData.value.logs.map((l) => {
+            switch (typeof l) {
+              case "string":
+              case "number":
+              case "boolean":
+              case "undefined":
+                return l;
+              case "object":
+                if (l === null) {
+                  return null;
+                }
+                return formatWorkerError(l);
+              default:
+                assertUnreachable(l);
+            }
+          });
+          switch (msgData.value.logLevel) {
+            case "NONE":
+              break;
+            case "ERROR":
+              log.error(...formatted);
+              break;
+            case "WARNING":
+              log.warn(...formatted);
+              break;
+            case "INFO":
+              log.info(...formatted);
+              break;
+            case "DEBUG":
+              log.debug(...formatted);
+              break;
+            default:
+              assertUnreachable(msgData.value.logLevel);
+          }
+          break;
+        }
+        default:
+          if (this._queuedWorkerMessages !== null) {
+            this._queuedWorkerMessages.push(evt);
+          }
+          break;
+      }
+    };
+    this._settings.worker.addEventListener("message", onmessage);
+    const onmessageerror = (_msg: MessageEvent) => {
+      log.error("MTCI: Error when receiving message from worker.");
+    };
+    this._settings.worker.addEventListener("messageerror", onmessageerror);
+    this._initCanceller.signal.register(() => {
+      log.debug("MTCI: removeEventListener prepare for worker message");
+      this._settings.worker.removeEventListener("message", onmessage);
+      this._settings.worker.removeEventListener("messageerror", onmessageerror);
+    });
 
     // Also bind all `SharedReference` objects:
 
@@ -1042,69 +1118,44 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           }
           break;
 
-        case WorkerMessageType.LogMessage: {
-          const formatted = msgData.value.logs.map((l) => {
-            switch (typeof l) {
-              case "string":
-              case "number":
-              case "boolean":
-              case "undefined":
-                return l;
-              case "object":
-                if (l === null) {
-                  return null;
-                }
-                return formatWorkerError(l);
-              default:
-                assertUnreachable(l);
-            }
-          });
-          switch (msgData.value.logLevel) {
-            case "NONE":
-              break;
-            case "ERROR":
-              log.error(...formatted);
-              break;
-            case "WARNING":
-              log.warn(...formatted);
-              break;
-            case "INFO":
-              log.info(...formatted);
-              break;
-            case "DEBUG":
-              log.debug(...formatted);
-              break;
-            default:
-              assertUnreachable(msgData.value.logLevel);
-          }
-          break;
-        }
-
-        case WorkerMessageType.InitSuccess:
-        case WorkerMessageType.InitError:
-          // Should already be handled by the API
-          break;
-
         case WorkerMessageType.SegmentSinkStoreUpdate: {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
-          const resolveFn = this._segmentMetrics.resolvers[msgData.value.messageId];
+          const resolveFn = this._segmentMetrics.resolvers.get(msgData.value.messageId);
           if (resolveFn !== undefined) {
             resolveFn(msgData.value.segmentSinkMetrics);
-            delete this._segmentMetrics.resolvers[msgData.value.messageId];
           } else {
             log.error("MTCI: Failed to send segment sink store update");
           }
           break;
         }
+
+        case WorkerMessageType.InitSuccess:
+        case WorkerMessageType.InitError:
+          // Should already be handled by the API
+          break;
+
+        case WorkerMessageType.LogMessage:
+          // Already handled by prepare's handler
+          break;
         default:
           assertUnreachable(msgData);
       }
     };
 
+    log.debug("MTCI: addEventListener for worker message");
+    if (this._queuedWorkerMessages !== null) {
+      const bufferedMessages = this._queuedWorkerMessages.slice();
+      log.debug("MTCI: Processing buffered messages", bufferedMessages.length);
+      for (const message of bufferedMessages) {
+        onmessage(message);
+      }
+      this._queuedWorkerMessages = null;
+    }
     this._settings.worker.addEventListener("message", onmessage);
     this._initCanceller.signal.register(() => {
+      log.debug("MTCI: removeEventListener for worker message");
       this._settings.worker.removeEventListener("message", onmessage);
     });
   }
@@ -1538,11 +1589,19 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
         value: { messageId },
       });
       return new Promise((resolve, reject) => {
-        this._segmentMetrics.resolvers[messageId] = resolve;
         const rejectFn = (err: CancellationError) => {
-          delete this._segmentMetrics.resolvers[messageId];
+          cancelSignal.deregister(rejectFn);
+          this._segmentMetrics.resolvers.delete(messageId);
           return reject(err);
         };
+        this._segmentMetrics.resolvers.set(
+          messageId,
+          (value: ISegmentSinkMetrics | undefined) => {
+            cancelSignal.deregister(rejectFn);
+            this._segmentMetrics.resolvers.delete(messageId);
+            resolve(value);
+          },
+        );
         cancelSignal.register(rejectFn);
       });
     };

package/src/main_thread/init/utils/initial_seek_and_play.ts

@@ -71,7 +71,7 @@ export default function performInitialSeekAndPlay(
   }: {
     mediaElement: IMediaElement;
     playbackObserver: IMediaElementPlaybackObserver;
-    startTime: number | (() => number);
+    startTime: number | (() => number | undefined);
     mustAutoPlay: boolean;
     isDirectfile: boolean;
     onWarning: (err: IPlayerError) => void;
@@ -107,18 +107,37 @@ export default function performInitialSeekAndPlay(
       if (!isDirectfile || typeof startTime === "number") {
         const initiallySeekedTime =
           typeof startTime === "number" ? startTime : startTime();
-        if (initiallySeekedTime !== 0) {
+        if (initiallySeekedTime !== 0 && initiallySeekedTime !== undefined) {
           performInitialSeek(initiallySeekedTime);
         }
         waitForSeekable();
       } else {
         playbackObserver.listen(
           (obs, stopListening) => {
+            const initiallySeekedTime =
+              typeof startTime === "number" ? startTime : startTime();
+            if (
+              initiallySeekedTime === undefined &&
+              obs.readyState < HTMLMediaElement.HAVE_CURRENT_DATA
+            ) {
+              /**
+               * On browser, such as Safari, the HTMLMediaElement.duration
+               * and HTMLMediaElement.buffered may not be initialized at readyState 1, leading
+               * to cases where it can be equal to `Infinity`.
+               * If so, the range in which it is possible to seek is not yet known.
+               * To solve this, the seek should be done after readyState HAVE_CURRENT_DATA (2),
+               * at that time the previously mentioned attributes are correctly initialized and
+               * the range in which it is possible to seek is correctly known.
+               * If the initiallySeekedTime is still `undefined` when the readyState is >= 2,
+               * let assume that the initiallySeekedTime will never be known and continue
+               * the logic without seeking.
+               */
+              return;
+            }
             if (obs.readyState >= 1) {
               stopListening();
-              const initiallySeekedTime =
-                typeof startTime === "number" ? startTime : startTime();
-              if (initiallySeekedTime !== 0) {
+
+              if (initiallySeekedTime !== 0 && initiallySeekedTime !== undefined) {
                 if (canSeekDirectlyAfterLoadedMetadata) {
                   performInitialSeek(initiallySeekedTime);
                 } else {