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

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/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/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.2024100200";
     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.2024100200";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

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/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.
    *
@@ -123,6 +137,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
       lastMessageId: 0,
       resolvers: {},
     };
+    this._queuedWorkerMessages = null;
   }
 
   /**
@@ -176,6 +191,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,49 +1117,6 @@ 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;
@@ -1098,13 +1130,32 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           }
           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);
     });
   }

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 {

package/src/mse/main_media_source_interface.ts

@@ -464,6 +464,20 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
           op.reject(error);
         });
         this._currentOperations = [];
+
+        // A synchronous error probably will not lead to updateend event, so we need to
+        // go to next queue element manually
+        //
+        // FIXME: This here is needed to ensure that we're not left with a
+        // dangling queue of operations.
+        // However it can potentially be counter-productive if e.g. the `appendBuffer`
+        // error was due to a full buffer and if there are pushing operations awaiting in
+        // the queue.
+        //
+        // A better solution might just be to reject all push operations right away here?
+        // Only for a `QuotaExceededError` (to check MSE)?
+        // However this is too disruptive for what is now a hotfix
+        this._performNextOperation();
       }
     } else {
       // TODO merge contiguous removes?
@@ -482,7 +496,13 @@ export class MainSourceBufferInterface implements ISourceBufferInterface {
                 false,
               );
         nextElem.reject(error);
+        this._currentOperations.forEach((op) => {
+          op.reject(error);
+        });
         this._currentOperations = [];
+        // A synchronous error probably will not lead to updateend event, so we need to
+        // go to next queue element manually
+        this._performNextOperation();
       }
     }
   }

package/src/transports/smooth/pipelines.ts

@@ -350,6 +350,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
         if (
           mimeType === "application/ttml+xml+mp4" ||
           lcCodec === "stpp" ||
+          lcCodec === "stpp.ttml" ||
           lcCodec === "stpp.ttml.im1t"
         ) {
           _sdType = "ttml";

package/src/transports/utils/parse_text_track.ts

@@ -42,6 +42,7 @@ export function getISOBMFFTextTrackFormat(codecs: string | undefined): "ttml" |
   }
   switch (codecs.toLowerCase()) {
     case "stpp": // stpp === TTML in MP4
+    case "stpp.ttml":
     case "stpp.ttml.im1t":
       return "ttml";
     case "wvtt": // wvtt === WebVTT in MP4