rx-player 4.1.0 → 4.2.0-dev.2024080600

package/src/main_thread/tracks_store/tracks_store.ts

@@ -49,6 +49,7 @@ import type {
   IVideoTrack,
   IVideoTrackSwitchingMode,
   IPlayerError,
+  ITrackType,
 } from "../../public_types";
 import arrayFind from "../../utils/array_find";
 import assert from "../../utils/assert";
@@ -128,6 +129,14 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     }, []);
   }
 
+  /**
+   * Callack that needs to be called as codec support is either first known or
+   * updated on the Manifest.
+   */
+  public onManifestCodecSupportUpdate(): void {
+    this._selectInitialTrackIfNeeded();
+  }
+
   /**
    * Update the list of Periods handled by the TracksStore and make a
    * track choice decision for each of them.
@@ -164,7 +173,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
         newPListIdx++;
 
         const curWantedTextTrack = this._storedPeriodInfo[i].text.storedSettings;
-        if (curWantedTextTrack !== null) {
+        if (!isNullOrUndefined(curWantedTextTrack)) {
           const textAdaptations = getSupportedAdaptations(newPeriod, "text");
           const stillHere = textAdaptations.some(
             (a) => a.id === curWantedTextTrack.adaptation.id,
@@ -188,14 +197,18 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
               this._storedPeriodInfo,
               periodInfo.period.id,
             );
-            if (periodItem !== undefined && periodItem.text.storedSettings === null) {
+            if (
+              periodItem !== undefined &&
+              periodItem.isPeriodAdvertised &&
+              periodItem.text.storedSettings === null
+            ) {
               periodItem.text.dispatcher?.updateTrack(null);
             }
           }
         }
 
         const curWantedVideoTrack = this._storedPeriodInfo[i].video.storedSettings;
-        if (curWantedVideoTrack !== null) {
+        if (!isNullOrUndefined(curWantedVideoTrack)) {
           const videoAdaptations = getSupportedAdaptations(newPeriod, "video");
           const stillHere = videoAdaptations.some(
             (a) => a.id === curWantedVideoTrack.adaptation.id,
@@ -239,6 +252,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
             );
             if (
               newPeriodItem !== undefined &&
+              newPeriodItem.isPeriodAdvertised &&
               newPeriodItem.video.storedSettings === storedSettings
             ) {
               newPeriodItem.video.dispatcher?.updateTrack(storedSettings);
@@ -247,7 +261,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
         }
 
         const curWantedAudioTrack = this._storedPeriodInfo[i].audio.storedSettings;
-        if (curWantedAudioTrack !== null) {
+        if (!isNullOrUndefined(curWantedAudioTrack)) {
           const audioAdaptations = getSupportedAdaptations(newPeriod, "audio");
           const stillHere = audioAdaptations.some(
             (a) => a.id === curWantedAudioTrack.adaptation.id,
@@ -282,6 +296,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
             );
             if (
               newPeriodItem !== undefined &&
+              newPeriodItem.isPeriodAdvertised &&
               newPeriodItem.audio.storedSettings === storedSettings
             ) {
               newPeriodItem.audio.dispatcher?.updateTrack(storedSettings);
@@ -297,12 +312,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
           i--;
         }
       } else {
-        const newPeriodInfo = generatePeriodInfo(
-          newPeriod,
-          true,
-          this._isTrickModeTrackEnabled,
-          this._defaultAudioTrackSwitchingMode,
-        );
+        const newPeriodInfo = generatePeriodInfo(newPeriod, true);
         // oldPeriod.start > newPeriod.start: insert newPeriod before
         this._storedPeriodInfo.splice(i, 0, newPeriodInfo);
         addedPeriods.push(newPeriodInfo);
@@ -316,14 +326,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       // Add further new Period
       const periodsToAdd = periods
         .slice(newPListIdx)
-        .map((p) =>
-          generatePeriodInfo(
-            p,
-            true,
-            this._isTrickModeTrackEnabled,
-            this._defaultAudioTrackSwitchingMode,
-          ),
-        );
+        .map((p) => generatePeriodInfo(p, true));
       this._storedPeriodInfo.push(...periodsToAdd);
       addedPeriods.push(...periodsToAdd);
     }
@@ -362,12 +365,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     let periodObj = getPeriodItem(this._storedPeriodInfo, period.id);
     if (periodObj === undefined) {
       // The Period has not yet been added.
-      periodObj = generatePeriodInfo(
-        period,
-        false,
-        this._isTrickModeTrackEnabled,
-        this._defaultAudioTrackSwitchingMode,
-      );
+      periodObj = generatePeriodInfo(period, false);
       let found = false;
       for (let i = 0; i < this._storedPeriodInfo.length; i++) {
         if (this._storedPeriodInfo[i].period.start > period.start) {
@@ -380,35 +378,32 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       }
     }
 
-    if (!periodObj.isPeriodAdvertised) {
-      periodObj.isPeriodAdvertised = true;
-      this.trigger("newAvailablePeriods", [
-        { id: period.id, start: period.start, end: period.end },
-      ]);
-      if (this._isDisposed) {
-        return;
-      }
-    }
-
     if (periodObj[bufferType].dispatcher !== null) {
       log.error(
         `TS: Subject already added for ${bufferType} ` + `and Period ${period.start}`,
       );
       return;
     }
-    const trackSetting = periodObj[bufferType].storedSettings;
+
     const dispatcher = new TrackDispatcher(adaptationRef);
     periodObj[bufferType].dispatcher = dispatcher;
+
     dispatcher.addEventListener("noPlayableRepresentation", () => {
-      const nextAdaptation = arrayFind(period.adaptations[bufferType] ?? [], (a) => {
-        if (a.isSupported === false) {
-          return false;
-        }
-        const playableRepresentations = a.representations.filter(
-          (r) => r.isSupported === true && r.decipherable !== false,
-        );
-        return playableRepresentations.length > 0;
-      });
+      const nextAdaptation = arrayFind(
+        period.adaptations[bufferType] ?? [],
+        (adaptation) => {
+          if (
+            adaptation.supportStatus.hasSupportedCodec === false ||
+            adaptation.supportStatus.isDecipherable === false
+          ) {
+            return false;
+          }
+          const playableRepresentations = adaptation.representations.filter(
+            (r) => r.isSupported === true && r.decipherable !== false,
+          );
+          return playableRepresentations.length > 0;
+        },
+      );
       if (nextAdaptation === undefined) {
         const noRepErr = new MediaError(
           "NO_PLAYABLE_REPRESENTATION",
@@ -451,13 +446,49 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     dispatcher.addEventListener("noPlayableLockedRepresentation", () => {
       // TODO check that it doesn't already lead to segment loading or MediaSource
       // reloading
-      trackSetting?.lockedRepresentations.setValue(null);
+      if (periodObj === undefined) {
+        return;
+      }
+      this.unlockVideoRepresentations(periodObj);
       this.trigger("brokenRepresentationsLock", {
         period: { id: period.id, start: period.start, end: period.end },
         trackType: bufferType,
       });
     });
-    dispatcher.start(trackSetting);
+
+    this._selectInitialTrackIfNeeded();
+
+    // Ensure `newAvailablePeriods` is sent
+    if (this._shouldAdvertisePeriod(periodObj)) {
+      periodObj.isPeriodAdvertised = true;
+      this.trigger("newAvailablePeriods", [
+        {
+          id: period.id,
+          start: period.start,
+          end: period.end,
+        },
+      ]);
+      if (this._isDisposed) {
+        return;
+      }
+    }
+
+    // Ensure the initial track is set for each type now)
+    const trackTypes: ITrackType[] = ["audio", "video", "text"];
+    for (const ttype of trackTypes) {
+      const trackObj = periodObj[ttype];
+      if (
+        periodObj.isPeriodAdvertised &&
+        trackObj.dispatcher !== null &&
+        !trackObj.dispatcher.hasSetTrack() &&
+        trackObj.storedSettings !== undefined
+      ) {
+        trackObj.dispatcher.updateTrack(trackObj.storedSettings);
+      }
+      if (this._isDisposed) {
+        return;
+      }
+    }
   }
 
   /**
@@ -662,10 +693,16 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     lockedRepresentations: string[] | null;
     relativeResumingPosition: number | undefined;
   }): void {
+    if (!periodRef.isPeriodAdvertised) {
+      throw new Error("Wanted Period not yet advertised.");
+    }
     const period = periodRef.period;
     const wantedAdaptation = arrayFind(
       period.adaptations[bufferType] ?? [],
-      ({ id, isSupported }) => isSupported === true && id === trackId,
+      ({ id, supportStatus }) =>
+        supportStatus.hasSupportedCodec !== false &&
+        supportStatus.isDecipherable !== false &&
+        id === trackId,
     );
 
     if (wantedAdaptation === undefined) {
@@ -744,10 +781,16 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       lockedRepresentations,
       relativeResumingPosition,
     } = payload;
+    if (!periodRef.isPeriodAdvertised) {
+      throw new Error("Wanted Period not yet advertised.");
+    }
     const period = periodRef.period;
     const wantedAdaptation = arrayFind(
       period.adaptations.video ?? [],
-      ({ id, isSupported }) => isSupported === true && id === trackId,
+      ({ id, supportStatus }) =>
+        supportStatus.isDecipherable !== false &&
+        supportStatus.hasSupportedCodec !== false &&
+        id === trackId,
     );
 
     if (wantedAdaptation === undefined) {
@@ -815,6 +858,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     periodObj: ITSPeriodObject,
     bufferType: "audio" | "video" | "text",
   ): void {
+    if (!periodObj.isPeriodAdvertised) {
+      throw new Error("Wanted Period not yet advertised.");
+    }
     const trackInfo = periodObj[bufferType];
     if (trackInfo.storedSettings === null) {
       return;
@@ -865,7 +911,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * known.
    */
   public getChosenAudioTrack(periodObj: ITSPeriodObject): IAudioTrack | null {
-    return periodObj.audio.storedSettings === null
+    return isNullOrUndefined(periodObj.audio.storedSettings)
       ? null
       : toAudioTrack(periodObj.audio.storedSettings.adaptation, true);
   }
@@ -881,7 +927,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * @returns {Object|null} - The text track chosen for this Period
    */
   public getChosenTextTrack(periodObj: ITSPeriodObject): ITextTrack | null {
-    return periodObj.text.storedSettings === null
+    return isNullOrUndefined(periodObj.text.storedSettings)
       ? null
       : toTextTrack(periodObj.text.storedSettings.adaptation);
   }
@@ -897,7 +943,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * @returns {Object|null} - The video track chosen for this Period
    */
   public getChosenVideoTrack(periodObj: ITSPeriodObject): IVideoTrack | null {
-    if (periodObj.video.storedSettings === null) {
+    if (isNullOrUndefined(periodObj.video.storedSettings)) {
       return null;
     }
 
@@ -917,7 +963,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     periodObj: ITSPeriodObject,
   ): IAvailableAudioTrack[] | undefined {
     const storedSettings = periodObj.audio.storedSettings;
-    const currentId = storedSettings !== null ? storedSettings.adaptation.id : null;
+    const currentId = !isNullOrUndefined(storedSettings)
+      ? storedSettings.adaptation.id
+      : null;
     const adaptations = getSupportedAdaptations(periodObj.period, "audio");
     return adaptations.map((adaptation: IAdaptationMetadata) => {
       const active = currentId === null ? false : currentId === adaptation.id;
@@ -938,7 +986,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     periodObj: ITSPeriodObject,
   ): IAvailableTextTrack[] | undefined {
     const storedSettings = periodObj.text.storedSettings;
-    const currentId = storedSettings !== null ? storedSettings.adaptation.id : null;
+    const currentId = !isNullOrUndefined(storedSettings)
+      ? storedSettings.adaptation.id
+      : null;
 
     const adaptations = getSupportedAdaptations(periodObj.period, "text");
     return adaptations.map((adaptation) => {
@@ -960,7 +1010,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     periodObj: ITSPeriodObject,
   ): IAvailableVideoTrack[] | undefined {
     const storedSettings = periodObj.video.storedSettings;
-    const currentId = storedSettings === null ? undefined : storedSettings.adaptation.id;
+    const currentId = isNullOrUndefined(storedSettings)
+      ? undefined
+      : storedSettings.adaptation.id;
 
     const adaptations = getSupportedAdaptations(periodObj.period, "video");
     return adaptations.map((adaptation) => {
@@ -984,7 +1036,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
 
   public getLockedAudioRepresentations(periodObj: ITSPeriodObject): string[] | null {
     const { storedSettings } = periodObj.audio;
-    if (storedSettings === null) {
+    if (isNullOrUndefined(storedSettings)) {
       return null;
     }
     const lastLockedSettings = storedSettings.lockedRepresentations.getValue();
@@ -993,7 +1045,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
 
   public getLockedVideoRepresentations(periodObj: ITSPeriodObject): string[] | null {
     const { storedSettings } = periodObj.video;
-    if (storedSettings === null) {
+    if (isNullOrUndefined(storedSettings)) {
       return null;
     }
     const lastLockedSettings = storedSettings.lockedRepresentations.getValue();
@@ -1005,7 +1057,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     lockSettings: IAudioRepresentationsLockSettings,
   ): void {
     const { storedSettings } = periodObj.audio;
-    if (storedSettings === null) {
+    if (isNullOrUndefined(storedSettings)) {
       return;
     }
     const { DEFAULT_AUDIO_REPRESENTATIONS_SWITCHING_MODE } = config.getCurrent();
@@ -1027,7 +1079,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     lockSettings: IVideoRepresentationsLockSettings,
   ): void {
     const { storedSettings } = periodObj.video;
-    if (storedSettings === null) {
+    if (isNullOrUndefined(storedSettings)) {
       return;
     }
 
@@ -1047,7 +1099,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   public unlockAudioRepresentations(periodObj: ITSPeriodObject): void {
     const { storedSettings } = periodObj.audio;
     if (
-      storedSettings === null ||
+      isNullOrUndefined(storedSettings) ||
       storedSettings.lockedRepresentations.getValue() === null
     ) {
       return;
@@ -1058,7 +1110,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   public unlockVideoRepresentations(periodObj: ITSPeriodObject): void {
     const { storedSettings } = periodObj.video;
     if (
-      storedSettings === null ||
+      isNullOrUndefined(storedSettings) ||
       storedSettings.lockedRepresentations.getValue() === null
     ) {
       return;
@@ -1080,7 +1132,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   private _resetVideoTrackChoices(reason: "trickmode-enabled" | "trickmode-disabled") {
     for (let i = 0; i < this._storedPeriodInfo.length; i++) {
       const periodObj = this._storedPeriodInfo[i];
-      if (periodObj.video.storedSettings !== null) {
+      if (!isNullOrUndefined(periodObj.video.storedSettings)) {
         const chosenBaseTrack = periodObj.video.storedSettings.adaptationBase;
         if (chosenBaseTrack !== null) {
           const chosenTrack = getRightVideoTrack(
@@ -1100,23 +1152,26 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       const period = sliced[i].period;
       const videoItem = sliced[i].video;
       const storedSettings = videoItem.storedSettings;
-      this.trigger("trackUpdate", {
-        period: toExposedPeriod(period),
-        trackType: "video",
-        reason,
-      });
-
-      // The previous event trigger could have had side-effects, so we
-      // re-check if we're still mostly in the same state
-      if (this._isDisposed) {
-        return; // Someone disposed the `TracksStore` on the previous side-effect
-      }
-      const newPeriodItem = getPeriodItem(this._storedPeriodInfo, period.id);
-      if (
-        newPeriodItem !== undefined &&
-        newPeriodItem.video.storedSettings === storedSettings
-      ) {
-        newPeriodItem.video.dispatcher?.updateTrack(storedSettings);
+      if (storedSettings !== undefined) {
+        this.trigger("trackUpdate", {
+          period: toExposedPeriod(period),
+          trackType: "video",
+          reason,
+        });
+
+        // The previous event trigger could have had side-effects, so we
+        // re-check if we're still mostly in the same state
+        if (this._isDisposed) {
+          return; // Someone disposed the `TracksStore` on the previous side-effect
+        }
+        const newPeriodItem = getPeriodItem(this._storedPeriodInfo, period.id);
+        if (
+          newPeriodItem !== undefined &&
+          newPeriodItem.isPeriodAdvertised &&
+          newPeriodItem.video.storedSettings === storedSettings
+        ) {
+          newPeriodItem.video.dispatcher?.updateTrack(storedSettings);
+        }
       }
     }
   }
@@ -1155,6 +1210,147 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
 
     return filtered;
   }
+
+  /**
+   * Check or re-check all Periods for which both an initial track can be chosen
+   * and for which the `newAvailablePeriods` event can be triggered.
+   */
+  private _selectInitialTrackIfNeeded(): void {
+    const { DEFAULT_VIDEO_TRACK_SWITCHING_MODE } = config.getCurrent();
+
+    const periodsToAdvertise: IPeriod[] = [];
+    const toDispatchTrack: ITSPeriodObject[] = [];
+    for (const trackStorePeriod of this._storedPeriodInfo) {
+      const { period } = trackStorePeriod;
+      if (
+        trackStorePeriod.audio.storedSettings !== undefined &&
+        trackStorePeriod.video.storedSettings !== undefined &&
+        trackStorePeriod.text.storedSettings !== undefined
+      ) {
+        // already processed, continue
+        continue;
+      }
+      const adaptations: IAdaptationMetadata[] = [
+        ...(period.adaptations.audio ?? []),
+        ...(period.adaptations.video ?? []),
+      ];
+      const hasCodecWithUndefinedSupport = adaptations.every(
+        (a) => a.supportStatus.hasCodecWithUndefinedSupport,
+      );
+      if (adaptations.length > 0 && hasCodecWithUndefinedSupport) {
+        // Not all codecs for that Period are known yet.
+        // Await until this is the case.
+        continue;
+      }
+
+      const audioAdaptation = getSupportedAdaptations(period, "audio")[0];
+      trackStorePeriod.audio.storedSettings =
+        audioAdaptation === undefined
+          ? null
+          : {
+              adaptation: audioAdaptation,
+              switchingMode: this._defaultAudioTrackSwitchingMode,
+              lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(
+                null,
+              ),
+            };
+
+      const baseVideoAdaptation = getSupportedAdaptations(period, "video")[0];
+      const videoAdaptation = getRightVideoTrack(
+        baseVideoAdaptation,
+        this._isTrickModeTrackEnabled,
+      );
+      trackStorePeriod.video.storedSettings =
+        videoAdaptation === undefined
+          ? null
+          : {
+              adaptation: videoAdaptation,
+              adaptationBase: baseVideoAdaptation,
+              switchingMode: DEFAULT_VIDEO_TRACK_SWITCHING_MODE,
+              lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(
+                null,
+              ),
+            };
+
+      let textAdaptation: IAdaptationMetadata | null = null;
+      const forcedSubtitles = (period.adaptations.text ?? []).filter(
+        (ad) => ad.isForcedSubtitles === true,
+      );
+      if (forcedSubtitles.length > 0) {
+        if (audioAdaptation !== null && audioAdaptation !== undefined) {
+          const sameLanguage = arrayFind(
+            forcedSubtitles,
+            (f) => f.normalizedLanguage === audioAdaptation.normalizedLanguage,
+          );
+          if (sameLanguage !== undefined) {
+            textAdaptation = sameLanguage;
+          }
+        }
+        if (textAdaptation === null) {
+          textAdaptation =
+            arrayFind(forcedSubtitles, (f) => f.normalizedLanguage === undefined) ?? null;
+        }
+      }
+      trackStorePeriod.text.storedSettings =
+        textAdaptation === null
+          ? null
+          : {
+              adaptation: textAdaptation,
+              switchingMode: "direct" as const,
+              lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(
+                null,
+              ),
+            };
+
+      toDispatchTrack.push(trackStorePeriod);
+      if (this._shouldAdvertisePeriod(trackStorePeriod)) {
+        trackStorePeriod.isPeriodAdvertised = true;
+        periodsToAdvertise.push({ id: period.id, start: period.start, end: period.end });
+      }
+    }
+
+    if (periodsToAdvertise.length > 0) {
+      this.trigger("newAvailablePeriods", periodsToAdvertise);
+      if (this._isDisposed) {
+        return;
+      }
+    }
+
+    for (const trackStorePeriod of toDispatchTrack) {
+      if (!trackStorePeriod.isPeriodAdvertised) {
+        continue;
+      }
+      const bufferTypes: ITrackType[] = ["audio", "video", "text"];
+      for (const bufferType of bufferTypes) {
+        const trackInfo = trackStorePeriod[bufferType];
+        if (
+          trackInfo.dispatcher !== null &&
+          trackInfo.storedSettings !== undefined &&
+          !trackInfo.dispatcher.hasSetTrack()
+        ) {
+          trackInfo.dispatcher.updateTrack(trackInfo.storedSettings);
+          if (this._isDisposed) {
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns `true` once a Period can be advertised through a `newAvailablePeriods`
+   * event, after which track can begin to be set and updated.
+   * @param {Object} periodObj
+   * @returns {boolean}
+   */
+  private _shouldAdvertisePeriod(periodObj: ITSPeriodObject): boolean {
+    return (
+      !periodObj.isPeriodAdvertised &&
+      periodObj.text.dispatcher !== null &&
+      periodObj.video.dispatcher !== null &&
+      periodObj.audio.dispatcher !== null
+    );
+  }
 }
 
 /**
@@ -1227,76 +1423,20 @@ function getRightVideoTrack(
  * default track for each type.
  * @param {Object} period
  * @param {boolean} inManifest
- * @param {boolean} isTrickModeTrackEnabled
  * @returns {object}
  */
 function generatePeriodInfo(
   period: IPeriodMetadata,
   inManifest: boolean,
-  isTrickModeTrackEnabled: boolean,
-  defaultAudioTrackSwitchingMode: IAudioTrackSwitchingMode,
 ): ITSPeriodObject {
-  const audioAdaptation = getSupportedAdaptations(period, "audio")[0];
-  const baseVideoAdaptation = getSupportedAdaptations(period, "video")[0];
-  const videoAdaptation = getRightVideoTrack(
-    baseVideoAdaptation,
-    isTrickModeTrackEnabled,
-  );
-  const { DEFAULT_VIDEO_TRACK_SWITCHING_MODE } = config.getCurrent();
-  const audioSettings =
-    audioAdaptation !== undefined
-      ? {
-          adaptation: audioAdaptation,
-          switchingMode: defaultAudioTrackSwitchingMode,
-          lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(null),
-        }
-      : null;
-  const videoSettings =
-    videoAdaptation !== undefined
-      ? {
-          adaptation: videoAdaptation,
-          adaptationBase: baseVideoAdaptation,
-          switchingMode: DEFAULT_VIDEO_TRACK_SWITCHING_MODE,
-          lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(null),
-        }
-      : null;
-
-  let textAdaptation: IAdaptationMetadata | null = null;
-  const forcedSubtitles = (period.adaptations.text ?? []).filter(
-    (ad) => ad.isForcedSubtitles === true,
-  );
-  if (forcedSubtitles.length > 0) {
-    if (audioAdaptation !== null && audioAdaptation !== undefined) {
-      const sameLanguage = arrayFind(
-        forcedSubtitles,
-        (f) => f.normalizedLanguage === audioAdaptation.normalizedLanguage,
-      );
-      if (sameLanguage !== undefined) {
-        textAdaptation = sameLanguage;
-      }
-    }
-    if (textAdaptation === null) {
-      textAdaptation =
-        arrayFind(forcedSubtitles, (f) => f.normalizedLanguage === undefined) ?? null;
-    }
-  }
-
-  let textSettings = null;
-  if (textAdaptation !== null) {
-    textSettings = {
-      adaptation: textAdaptation,
-      switchingMode: "direct" as const,
-      lockedRepresentations: new SharedReference<IRepresentationsChoice | null>(null),
-    };
-  }
   return {
     period,
     inManifest,
     isPeriodAdvertised: false,
     isRemoved: false,
-    audio: { storedSettings: audioSettings, dispatcher: null },
-    video: { storedSettings: videoSettings, dispatcher: null },
-    text: { storedSettings: textSettings, dispatcher: null },
+    audio: { storedSettings: undefined, dispatcher: null },
+    video: { storedSettings: undefined, dispatcher: null },
+    text: { storedSettings: undefined, dispatcher: null },
   };
 }
 
@@ -1319,6 +1459,9 @@ export interface ITSPeriodObject {
   /**
    * Set to `true` once a `newAvailablePeriods` event has been sent for this
    * particular Period.
+   *
+   * Once this event has been sent, we can begin to select a audio, video and
+   * text track for that Period (but **NOT** before).
    */
   isPeriodAdvertised: boolean;
   /**
@@ -1347,19 +1490,23 @@ interface IAudioPeriodInfo {
   /**
    * Information on the last audio track settings wanted by the user.
    * `null` if no audio track is wanted.
+   * `undefined` if not set yet.
    */
-  storedSettings: {
-    /** Contains the last `Adaptation` wanted by the user. */
-    adaptation: IAdaptationMetadata;
-    /** "Switching mode" in which the track switch should happen. */
-    switchingMode: IAudioTrackSwitchingMode;
-    /**
-     * Contains the last locked `Representation`s for this `Adaptation` wanted
-     * by the user.
-     * `null` if no Representation is locked.
-     */
-    lockedRepresentations: SharedReference<IRepresentationsChoice | null>;
-  } | null;
+  storedSettings:
+    | {
+        /** Contains the last `Adaptation` wanted by the user. */
+        adaptation: IAdaptationMetadata;
+        /** "Switching mode" in which the track switch should happen. */
+        switchingMode: IAudioTrackSwitchingMode;
+        /**
+         * Contains the last locked `Representation`s for this `Adaptation` wanted
+         * by the user.
+         * `null` if no Representation is locked.
+         */
+        lockedRepresentations: SharedReference<IRepresentationsChoice | null>;
+      }
+    | null
+    | undefined;
   /**
    * Tracks are internally emitted through RxJS's `Subject`s.
    * A `TrackDispatcher` allows to facilitate and centralize the management of
@@ -1380,19 +1527,23 @@ export interface ITextPeriodInfo {
   /**
    * Information on the last text track settings wanted.
    * `null` if no text track is wanted.
+   * `undefined` if not set yet.
    */
-  storedSettings: {
-    /** Contains the last `Adaptation` wanted by the user. */
-    adaptation: IAdaptationMetadata;
-    /** "Switching mode" in which the track switch should happen. */
-    switchingMode: "direct";
-    /**
-     * Contains the last locked `Representation`s for this `Adaptation` wanted
-     * by the user.
-     * `null` if no Representation is locked.
-     */
-    lockedRepresentations: SharedReference<IRepresentationsChoice | null>;
-  } | null;
+  storedSettings:
+    | {
+        /** Contains the last `Adaptation` wanted by the user. */
+        adaptation: IAdaptationMetadata;
+        /** "Switching mode" in which the track switch should happen. */
+        switchingMode: "direct";
+        /**
+         * Contains the last locked `Representation`s for this `Adaptation` wanted
+         * by the user.
+         * `null` if no Representation is locked.
+         */
+        lockedRepresentations: SharedReference<IRepresentationsChoice | null>;
+      }
+    | null
+    | undefined;
   /**
    * Tracks are internally emitted through RxJS's `Subject`s.
    * A `TrackDispatcher` allows to facilitate and centralize the management of
@@ -1413,30 +1564,9 @@ export interface IVideoPeriodInfo {
   /**
    * Information on the `id` of the last video track settings wanted.
    * `null` if no video track is wanted.
+   * `undefined` if not set yet.
    */
-  storedSettings: {
-    /**
-     * The wanted Adaptation itself (may be different from `adaptationBase`
-     * when a trickmode track is chosen, in which case `adaptationBase` is
-     * the Adaptation the trickmode track is linked to and `adaptation` is
-     * the trickmode track).
-     */
-    adaptation: IAdaptationMetadata;
-    /** "Switching mode" in which the track switch should happen. */
-    switchingMode: IVideoTrackSwitchingMode;
-    /**
-     * The "base" Adaptation for `storedSettings` (if a trickmode track was
-     * chosen, this is the Adaptation the trickmode track is linked to, and not
-     * the trickmode track itself).
-     */
-    adaptationBase: IAdaptationMetadata;
-    /**
-     * Contains the last locked `Representation`s for this `Adaptation` wanted
-     * by the user.
-     * `null` if no Representation is locked.
-     */
-    lockedRepresentations: SharedReference<IRepresentationsChoice | null>;
-  } | null;
+  storedSettings: IVideoStoredSettings | null | undefined;
   /**
    * Tracks are internally emitted through RxJS's `Subject`s.
    * A `TrackDispatcher` allows to facilitate and centralize the management of