rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

package/src/compat/index.ts

@@ -22,6 +22,7 @@ import {
   MediaSource_,
 } from "./browser_compatibility_types";
 import canPatchISOBMFFSegment from "./can_patch_isobmff";
+import canReuseMediaKeys from "./can_reuse_media_keys";
 import tryToChangeSourceBufferType, {
   ICompatSourceBuffer,
 } from "./change_source_buffer_type";
@@ -38,6 +39,7 @@ import {
   requestMediaKeySystemAccess,
   setMediaKeys,
 } from "./eme";
+import enableAudioTrack from "./enable_audio_track";
 import * as events from "./event_listeners";
 import {
   exitFullscreen,
@@ -57,7 +59,7 @@ import play from "./play";
 import setElementSrc$ from "./set_element_src";
 // eslint-disable-next-line max-len
 import shouldReloadMediaSourceOnDecipherabilityUpdate from "./should_reload_media_source_on_decipherability_update";
-import shouldRenewMediaKeys from "./should_renew_media_keys";
+import shouldRenewMediaKeySystemAccess from "./should_renew_media_key_system_access";
 import shouldUnsetMediaKeys from "./should_unset_media_keys";
 import shouldValidateMetadata from "./should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "./should_wait_for_data_before_loaded";
@@ -72,9 +74,11 @@ export {
   addClassName,
   addTextTrack,
   canPatchISOBMFFSegment,
+  canReuseMediaKeys,
   clearElementSrc,
   closeSession,
   CustomMediaKeySystemAccess,
+  enableAudioTrack,
   events,
   exitFullscreen,
   generateKeyRequest,
@@ -102,7 +106,7 @@ export {
   setElementSrc$,
   setMediaKeys,
   shouldReloadMediaSourceOnDecipherabilityUpdate,
-  shouldRenewMediaKeys,
+  shouldRenewMediaKeySystemAccess,
   shouldUnsetMediaKeys,
   shouldValidateMetadata,
   shouldWaitForDataBeforeLoaded,

package/src/compat/{should_renew_media_keys.ts → should_renew_media_key_system_access.ts}

@@ -17,10 +17,10 @@
 import { isIE11 } from "./browser_detection";
 
 /**
- * Returns true if the current target require the media keys to be renewed on
- * each content.
+ * Returns true if the current target require the MediaKeySystemAccess to be
+ * renewed on each content.
  * @returns {Boolean}
  */
-export default function shouldRenewMediaKeys() : boolean {
+export default function shouldRenewMediaKeySystemAccess() : boolean {
   return isIE11;
 }

package/src/core/api/playback_observer.ts

@@ -264,7 +264,9 @@ export default class PlaybackObserver {
         startedInternalSeekTime = this._internalSeeksIncoming.shift();
       }
       const _lastObservation = lastObservation ?? this._generateInitialObservation();
-      const mediaTimings = getMediaInfos(this._mediaElement, tmpEvt);
+      const mediaTimings = getMediaInfos(this._mediaElement,
+                                         tmpEvt,
+                                         this._withMediaSource);
       let pendingInternalSeek : number | null = null;
       if (mediaTimings.seeking) {
         if (typeof startedInternalSeekTime === "number") {
@@ -350,7 +352,9 @@ export default class PlaybackObserver {
   }
 
   private _generateInitialObservation() : IPlaybackObservation {
-    return objectAssign(getMediaInfos(this._mediaElement, "init"),
+    return objectAssign(getMediaInfos(this._mediaElement,
+                                      "init",
+                                      this._withMediaSource),
                         { rebuffering: null,
                           freezing: null,
                           pendingInternalSeek: null });
@@ -388,14 +392,23 @@ export type IPlaybackObserverEventType =
 
 /** Information recuperated on the media element on each playback observation. */
 interface IMediaInfos {
-  /** Gap between `currentTime` and the next position with un-buffered data. */
-  bufferGap : number;
+  /**
+   * Gap between `currentTime` and the next position with un-buffered data.
+   * `Infinity` if we don't have buffered data right now.
+   * `undefined` if we cannot determine the buffer gap.
+   */
+  bufferGap : number | undefined;
   /** Value of `buffered` (buffered ranges) for the media element. */
   buffered : TimeRanges;
-  /** The buffered range we are currently playing. */
+  /**
+   * The buffered range we are currently playing.
+   * `null` if no range is currently available.
+   * `undefined` if we cannot tell which range is currently available.
+   */
   currentRange : { start : number;
                    end : number; } |
-                 null;
+                 null |
+                 undefined;
   /**
    * `currentTime` (position) set on the media element at the time of the
    * PlaybackObserver's measure.
@@ -435,8 +448,9 @@ export interface IRebufferingStatus {
   /**
    * Position, in seconds, at which data is awaited.
    * If `null` the player is rebuffering but not because it is awaiting future data.
+   * If `undefined`, that position is unknown.
    */
-  position : number | null;
+  position : number | null | undefined;
 }
 
 /**
@@ -585,13 +599,18 @@ function getRebufferingEndGap(
  * @returns {Boolean}
  */
 function hasLoadedUntilTheEnd(
-  currentRange : { start : number; end : number }|null,
+  currentTime : number,
+  currentRange : { start : number; end : number } | null | undefined,
+  ended : boolean,
   duration : number,
   lowLatencyMode : boolean
 ) : boolean {
   const { REBUFFERING_GAP } = config.getCurrent();
   const suffix : "LOW_LATENCY" | "DEFAULT" = lowLatencyMode ? "LOW_LATENCY" :
                                                               "DEFAULT";
+  if (currentRange === undefined) {
+    return ended && Math.abs(duration - currentTime) <= REBUFFERING_GAP[suffix];
+  }
   return currentRange !== null &&
          (duration - currentRange.end) <= REBUFFERING_GAP[suffix];
 }
@@ -604,7 +623,8 @@ function hasLoadedUntilTheEnd(
  */
 function getMediaInfos(
   mediaElement : HTMLMediaElement,
-  event : IPlaybackObserverEventType
+  event : IPlaybackObserverEventType,
+  withMediaSource : boolean
 ) : IMediaInfos {
   const { buffered,
           currentTime,
@@ -615,11 +635,23 @@ function getMediaInfos(
           readyState,
           seeking } = mediaElement;
 
-  const currentRange = getRange(buffered, currentTime);
-  return { bufferGap: currentRange !== null ? currentRange.end - currentTime :
-                                              // TODO null/0 would probably be
-                                              // more appropriate
-                                              Infinity,
+  let currentRange;
+  let bufferGap;
+  if (!withMediaSource && buffered.length === 0 && readyState >= 3) {
+    // Sometimes `buffered` stay empty for directfile contents yet we are able
+    // to play. This seems to be linked to browser-side issues but has been
+    // encountered on enough platforms (Chrome desktop and PlayStation 4's
+    // WebKit for us to do something about it in the player.
+    currentRange = undefined;
+    bufferGap = undefined;
+  } else {
+    currentRange = getRange(buffered, currentTime);
+    bufferGap = currentRange !== null ? currentRange.end - currentTime :
+                                        // TODO null/0 would probably be
+                                        // more appropriate
+                                        Infinity;
+  }
+  return { bufferGap,
            buffered,
            currentRange,
            position: currentTime,
@@ -664,14 +696,18 @@ function getRebufferingStatus(
           event: prevEvt,
           position: prevTime } = prevObservation;
 
-  const fullyLoaded = hasLoadedUntilTheEnd(currentRange, duration, lowLatencyMode);
+  const fullyLoaded = hasLoadedUntilTheEnd(currentTime,
+                                           currentRange,
+                                           ended,
+                                           duration,
+                                           lowLatencyMode);
 
   const canSwitchToRebuffering = (readyState >= 1 &&
                                   currentEvt !== "loadedmetadata" &&
                                   prevRebuffering === null &&
                                   !(fullyLoaded || ended));
 
-  let rebufferEndPosition : number | null = null;
+  let rebufferEndPosition : number | null | undefined = null;
   let shouldRebuffer : boolean | undefined;
   let shouldStopRebuffer : boolean | undefined;
 
@@ -680,22 +716,32 @@ function getRebufferingStatus(
 
   if (withMediaSource) {
     if (canSwitchToRebuffering) {
-      if (bufferGap <= rebufferGap) {
-        shouldRebuffer = true;
-        rebufferEndPosition = currentTime + bufferGap;
-      } else if (bufferGap === Infinity) {
+      if (bufferGap === Infinity) {
         shouldRebuffer = true;
         rebufferEndPosition = currentTime;
+      } else if (bufferGap === undefined) {
+        if (readyState < 3) {
+          shouldRebuffer = true;
+          rebufferEndPosition = undefined;
+        }
+      } else if (bufferGap <= rebufferGap) {
+        shouldRebuffer = true;
+        rebufferEndPosition = currentTime + bufferGap;
       }
     } else if (prevRebuffering !== null) {
       const resumeGap = getRebufferingEndGap(prevRebuffering, lowLatencyMode);
       if (shouldRebuffer !== true && prevRebuffering !== null && readyState > 1 &&
-          (fullyLoaded || ended || (bufferGap < Infinity && bufferGap > resumeGap)))
+          (fullyLoaded || ended ||
+            (bufferGap !== undefined && isFinite(bufferGap) && bufferGap > resumeGap)) ||
+            (bufferGap === undefined && readyState >= 3))
       {
         shouldStopRebuffer = true;
-      } else if (bufferGap === Infinity || bufferGap <= resumeGap) {
-        rebufferEndPosition = bufferGap === Infinity ? currentTime :
-                                                       currentTime + bufferGap;
+      } else if (bufferGap === undefined) {
+        rebufferEndPosition = undefined;
+      } else if (bufferGap === Infinity) {
+        rebufferEndPosition = currentTime;
+      } else if (bufferGap <= resumeGap) {
+        rebufferEndPosition = currentTime + bufferGap;
       }
     }
   }
@@ -705,17 +751,34 @@ function getRebufferingStatus(
   // between two consecutive timeupdates
   else {
     if (canSwitchToRebuffering &&
-        (!paused && currentEvt === "timeupdate" &&
-         prevEvt === "timeupdate" && currentTime === prevTime ||
-         currentEvt === "seeking" && bufferGap === Infinity)
+        (
+          (
+            !paused &&
+            currentEvt === "timeupdate" && prevEvt === "timeupdate" &&
+            currentTime === prevTime
+          ) ||
+          (
+            currentEvt === "seeking" && (
+              bufferGap === Infinity || (bufferGap === undefined && readyState < 3)
+            )
+          )
+        )
     ) {
       shouldRebuffer = true;
-    } else if (prevRebuffering !== null &&
-               (currentEvt !== "seeking" && currentTime !== prevTime ||
-                currentEvt === "canplay" ||
-                bufferGap < Infinity &&
-                (bufferGap > getRebufferingEndGap(prevRebuffering, lowLatencyMode) ||
-                 fullyLoaded || ended))
+    } else if (
+      prevRebuffering !== null &&
+      (
+        (currentEvt !== "seeking" && currentTime !== prevTime) ||
+        currentEvt === "canplay" ||
+        (bufferGap === undefined && readyState >= 3) ||
+        (
+          bufferGap !== undefined && bufferGap < Infinity &&
+          (
+            bufferGap > getRebufferingEndGap(prevRebuffering, lowLatencyMode) ||
+            fullyLoaded || ended
+          )
+        )
+      )
     ) {
       shouldStopRebuffer = true;
     }
@@ -775,6 +838,7 @@ function getFreezingStatus(
   }
 
   return currentInfo.event === "timeupdate" &&
+         currentInfo.bufferGap !== undefined &&
          currentInfo.bufferGap > MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING &&
          !currentInfo.ended &&
          !currentInfo.paused &&

package/src/core/api/public_api.ts

@@ -41,6 +41,7 @@ import {
   switchMap,
   take,
   takeUntil,
+  tap,
 } from "rxjs";
 import {
   events,
@@ -119,7 +120,6 @@ import {
   IManifestFetcherParsedResult,
   IManifestFetcherWarningEvent,
   ManifestFetcher,
-  SegmentFetcherCreator,
 } from "../fetchers";
 import initializeMediaSourcePlayback, {
   IInitEvent,
@@ -135,6 +135,7 @@ import { IInbandEvent } from "../stream";
 import {
   checkReloadOptions,
   IParsedLoadVideoOptions,
+  IParsedStartAtOption,
   parseConstructorOptions,
   parseLoadVideoOptions,
 } from "./option_utils";
@@ -372,10 +373,35 @@ class Player extends EventEmitter<IPublicAPIEvent> {
   /** Determines whether or not the player should stop at the end of video playback. */
   private readonly _priv_stopAtEnd : boolean;
 
-  /** Information about last content being played. */
-  private _priv_lastContentPlaybackInfos : { options?: IParsedLoadVideoOptions;
-                                             manifest?: Manifest;
-                                             lastPlaybackPosition?: number; };
+  /**
+   * Information that can be relied on once `reload` is called.
+   * It should refer to the last content being played.
+   */
+  private _priv_reloadingMetadata : {
+    /**
+     * `loadVideo` options communicated for the last content that will be re-used
+     * on reload.
+     */
+    options?: IParsedLoadVideoOptions;
+    /**
+     * Manifest loaded for the last content that should be used once `reload`
+     * is called.
+     */
+    manifest?: Manifest;
+    /**
+     * If `true`, the player should be paused after reloading.
+     * If `false`, the player should be playing after reloading.
+     * If `undefined`, `reload` should depend on other criteria (such as the
+     * `autoPlay` option, to know whether the content should play or not after
+     * reloading.
+     */
+    reloadInPause?: boolean;
+    /**
+     * If set this is the position that should be seeked to by default after
+     * reloading.
+     */
+    reloadPosition?: number;
+  };
 
   /** All possible Error types emitted by the RxPlayer. */
   static get ErrorTypes() : Record<IErrorType, IErrorType> {
@@ -434,7 +460,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.29.0-dev.2022091600";
+    this.version = /* PLAYER_VERSION */"3.29.0-dev.2022103100";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -529,7 +555,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     this._priv_preferredTextTracks = preferredTextTracks;
     this._priv_preferredVideoTracks = preferredVideoTracks;
 
-    this._priv_lastContentPlaybackInfos = {};
+    this._priv_reloadingMetadata = {};
   }
 
   /**
@@ -600,7 +626,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     this._priv_bitrateInfos.maxAutoBitrates.video.finish();
     this._priv_bitrateInfos.maxAutoBitrates.audio.finish();
 
-    this._priv_lastContentPlaybackInfos = {};
+    this._priv_reloadingMetadata = {};
 
     // un-attach video element
     this.videoElement = null;
@@ -613,51 +639,56 @@ class Player extends EventEmitter<IPublicAPIEvent> {
   loadVideo(opts : ILoadVideoOptions) : void {
     const options = parseLoadVideoOptions(opts);
     log.info("API: Calling loadvideo", options.url, options.transport);
-    this._priv_lastContentPlaybackInfos = { options };
+    this._priv_reloadingMetadata = { options };
     this._priv_initializeContentPlayback(options);
   }
 
   /**
-   * Reload last content. Init media playback without fetching again
-   * the manifest.
+   * Reload the last loaded content.
    * @param {Object} reloadOpts
    */
-  reload(reloadOpts?: { reloadAt?: { position?: number; relative?: number } }): void {
+  reload(reloadOpts?: {
+    reloadAt?: { position?: number; relative?: number };
+    autoPlay?: boolean;
+  }): void {
     const { options,
             manifest,
-            lastPlaybackPosition } = this._priv_lastContentPlaybackInfos;
-    if (options === undefined ||
-        manifest === undefined ||
-        lastPlaybackPosition === undefined) {
+            reloadPosition,
+            reloadInPause } = this._priv_reloadingMetadata;
+    if (options === undefined) {
       throw new Error("API: Can't reload without having previously loaded a content.");
     }
     checkReloadOptions(reloadOpts);
-    let startAtPositon: number;
-    if (reloadOpts !== undefined &&
-        reloadOpts.reloadAt !== undefined &&
-        reloadOpts.reloadAt.position !== undefined) {
-      startAtPositon = reloadOpts.reloadAt.position;
-    } else {
-      let playbackPosition: number;
-      if (this.state === "STOPPED" || this.state === "ENDED") {
-        playbackPosition = lastPlaybackPosition;
-      } else {
-        if (this.videoElement === null) {
-          throw new Error("Can't reload when video element does not exist.");
-        }
-        playbackPosition = this.videoElement.currentTime;
-      }
-      if (reloadOpts !== undefined &&
-          reloadOpts.reloadAt !== undefined &&
-          reloadOpts.reloadAt.relative !== undefined) {
-        startAtPositon = reloadOpts.reloadAt.relative + playbackPosition;
+    let startAt : IParsedStartAtOption | undefined;
+    if (reloadOpts?.reloadAt?.position !== undefined) {
+      startAt = { position: reloadOpts.reloadAt.position };
+    } else if (reloadOpts?.reloadAt?.relative !== undefined) {
+      if (reloadPosition === undefined) {
+        throw new Error(
+          "Can't reload to a relative position when previous content was not loaded."
+        );
       } else {
-        startAtPositon = playbackPosition;
+        startAt = { position: reloadOpts.reloadAt.relative + reloadPosition };
       }
+    } else if (reloadPosition !== undefined) {
+      startAt = { position: reloadPosition };
+    }
+
+    let autoPlay : boolean | undefined;
+    if (reloadOpts?.autoPlay !== undefined) {
+      autoPlay = reloadOpts.autoPlay;
+    } else if (reloadInPause !== undefined) {
+      autoPlay = !reloadInPause;
     }
+
     const newOptions = { ...options,
                          initialManifest: manifest };
-    newOptions.startAt = { position: startAtPositon };
+    if (startAt !== undefined) {
+      newOptions.startAt = startAt;
+    }
+    if (autoPlay !== undefined) {
+      newOptions.autoPlay = autoPlay;
+    }
     this._priv_initializeContentPlayback(newOptions);
   }
 
@@ -758,14 +789,6 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           maxRetryOffline: offlineRetry,
           requestTimeout:  manifestRequestTimeout });
 
-      /** Interface used to download segments. */
-      const segmentFetcherCreator = new SegmentFetcherCreator(
-        transportPipelines,
-        { lowLatencyMode,
-          maxRetryOffline: offlineRetry,
-          maxRetryRegular: segmentRetry,
-          requestTimeout: segmentRequestTimeout });
-
       /** Observable emitting the initial Manifest */
       let manifest$ : Observable<IManifestFetcherParsedResult |
                                  IManifestFetcherWarningEvent>;
@@ -865,6 +888,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
                                            onCodecSwitch },
                                          this._priv_bufferOptions);
 
+      const segmentRequestOptions = { regularError: segmentRetry,
+                                      requestTimeout: segmentRequestTimeout,
+                                      offlineError: offlineRetry };
+
       // We've every options set up. Start everything now
       const init$ = initializeMediaSourcePlayback({ adaptiveOptions,
                                                     autoPlay,
@@ -876,9 +903,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
                                                     manifestFetcher,
                                                     mediaElement: videoElement,
                                                     minimumManifestUpdateInterval,
-                                                    segmentFetcherCreator,
+                                                    segmentRequestOptions,
                                                     speed: this._priv_speed,
                                                     startAt,
+                                                    transport: transportPipelines,
                                                     textTrackOptions })
         .pipe(takeUntil(stoppedContent$));
 
@@ -1038,10 +1066,51 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       }
     });
 
-    // Link "positionUpdate" events to the PlaybackObserver
-    observation$
-      .pipe(takeUntil(stoppedContent$))
-      .subscribe(o => this._priv_triggerPositionUpdate(o));
+    /**
+     * Function updating `this._priv_reloadingMetadata` in function of the
+     * current state and playback conditions.
+     * To call when either might change.
+     * @param {string} state - The player state we're about to switch to.
+     */
+    const updateReloadingMetadata = (state : IPlayerState) => {
+      switch (state) {
+        case "STOPPED":
+        case "RELOADING":
+        case "LOADING":
+          break; // keep previous metadata
+        case "ENDED":
+          this._priv_reloadingMetadata.reloadInPause = true;
+          this._priv_reloadingMetadata.reloadPosition =
+            playbackObserver.getReference().getValue().position;
+          break;
+        default:
+          const o = playbackObserver.getReference().getValue();
+          this._priv_reloadingMetadata.reloadInPause = o.paused;
+          this._priv_reloadingMetadata.reloadPosition = o.position;
+          break;
+      }
+    };
+
+    playerState$.pipe(
+      tap(newState => {
+        updateReloadingMetadata(newState);
+        this._priv_setPlayerState(newState);
+
+        // Previous call could have performed all kind of side-effects, thus,
+        // we re-check the current state associated to the RxPlayer
+        if (this.state === "ENDED" && this._priv_stopAtEnd) {
+          currentContentCanceller.cancel();
+        }
+      }),
+      map(state => state !== "RELOADING" && state !== "STOPPED"),
+      distinctUntilChanged(),
+      switchMap(canSendObservation => canSendObservation ? observation$ :
+                                                           EMPTY),
+      takeUntil(stoppedContent$)
+    ).subscribe(o => {
+      updateReloadingMetadata(this.state);
+      this._priv_triggerPositionUpdate(o);
+    });
 
     // Link "seeking" and "seeked" events (once the content is loaded)
     loaded$.pipe(
@@ -1052,19 +1121,6 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       this.trigger(evt, null);
     });
 
-    // Handle state updates
-    playerState$
-      .pipe(takeUntil(stoppedContent$))
-      .subscribe(newState => {
-        this._priv_setPlayerState(newState);
-
-        // Previous call could have performed all kind of side-effects, thus,
-        // we re-check the current state associated to the RxPlayer
-        if (this.state === "ENDED" && this._priv_stopAtEnd) {
-          currentContentCanceller.cancel();
-        }
-      });
-
     // Link playback events to the corresponding callbacks
     playback$.subscribe({
       next: (x) => this._priv_onPlaybackEvent(x),
@@ -2498,7 +2554,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       return;
     }
     contentInfos.manifest = manifest;
-    this._priv_lastContentPlaybackInfos.manifest = manifest;
+    this._priv_reloadingMetadata.manifest = manifest;
 
     const { initialAudioTrack, initialTextTrack } = contentInfos;
     this._priv_trackChoiceManager = new TrackChoiceManager({
@@ -2859,17 +2915,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       return;
     }
 
-    if (this.state === PLAYER_STATES.RELOADING) {
-      return;
-    }
-
     const { isDirectFile, manifest } = this._priv_contentInfos;
     if ((!isDirectFile && manifest === null) || isNullOrUndefined(observation)) {
       return;
     }
 
-    this._priv_lastContentPlaybackInfos.lastPlaybackPosition = observation.position;
-
     const maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
                                                 undefined;
     const positionData : IPositionUpdate = {
@@ -2878,9 +2928,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       playbackRate: observation.playbackRate,
       maximumBufferTime: maximumPosition,
 
-      // TODO fix higher up?
-      bufferGap: isFinite(observation.bufferGap) ? observation.bufferGap :
-                                                   0,
+      // TODO bufferGap may be undefined
+      bufferGap: observation.bufferGap === undefined ||
+                 !isFinite(observation.bufferGap) ?
+        0 :
+        observation.bufferGap,
     };
 
     if (manifest !== null &&
@@ -2950,7 +3002,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.29.0-dev.2022091600";
+Player.version = /* PLAYER_VERSION */"3.29.0-dev.2022103100";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/api/tracks_management/media_element_track_choice_manager.ts

@@ -19,6 +19,7 @@
  * It always should be imported through the `features` object.
  */
 
+import { enableAudioTrack } from "../../../compat";
 import {
   ICompatAudioTrack,
   ICompatAudioTrackList,
@@ -39,7 +40,6 @@ import {
   IAvailableAudioTrack,
   IAvailableTextTrack,
 } from "../../../public_types";
-import assert from "../../../utils/assert";
 import EventEmitter from "../../../utils/event_emitter";
 import normalizeLanguage from "../../../utils/languages";
 
@@ -913,16 +913,8 @@ export default class MediaElementTrackChoiceManager
    * @param {number} index}
    */
   private _enableAudioTrackFromIndex(index : number) : void {
-    assert(index < this._audioTracks.length);
-
-    // Seen on Safari MacOS only (2022-02-14), not disabling ALL audio tracks
-    // first (even the wanted one), can lead to the media not playing.
-    for (const audioTrack of this._audioTracks) {
-      audioTrack.nativeTrack.enabled = false;
-    }
-
-    this._audioTracks[index].nativeTrack.enabled = true;
-    return;
+    enableAudioTrack(this._audioTracks.map(({ nativeTrack }) => nativeTrack),
+                     index);
   }
 }