rx-player 4.3.0-dev.2025012900 → 4.3.0-dev.2025030400

package/src/main_thread/decrypt/utils/server_certificate_store.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys } from "../../../compat/eme";
+import type { IMediaKeys } from "../../../compat/browser_compatibility_types";
 import hashBuffer from "../../../utils/hash_buffer";
 
 /**
@@ -31,7 +31,7 @@ import hashBuffer from "../../../utils/hash_buffer";
  * EME APIs failed or had an unexpected behavior).
  */
 const serverCertificateHashesMap = new WeakMap<
-  MediaKeys | ICustomMediaKeys,
+  IMediaKeys,
   { hash: number; serverCertificate: Uint8Array } | null
 >();
 
@@ -49,7 +49,7 @@ export default {
    * server certificate attached to this MediaKeys is for now invalid.
    * @param {MediaKeys | Object} mediaKeys
    */
-  prepare(mediaKeys: MediaKeys | ICustomMediaKeys): void {
+  prepare(mediaKeys: IMediaKeys): void {
     serverCertificateHashesMap.set(mediaKeys, null);
   },
 
@@ -64,10 +64,7 @@ export default {
    * @param {MediaKeys | Object} mediaKeys
    * @param {ArrayBufferView | BufferSource} serverCertificate
    */
-  set(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): void {
+  set(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): void {
     const formattedServerCertificate: Uint8Array =
       serverCertificate instanceof Uint8Array
         ? serverCertificate
@@ -92,7 +89,7 @@ export default {
    * @param {MediaKeys} mediaKeys
    * @returns {Boolean|undefined}
    */
-  hasOne(mediaKeys: MediaKeys | ICustomMediaKeys): boolean | undefined {
+  hasOne(mediaKeys: IMediaKeys): boolean | undefined {
     const currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
     if (currentServerCertificate === undefined) {
       return false;
@@ -111,10 +108,7 @@ export default {
    * @param {ArrayBufferView | BufferSource} serverCertificate
    * @returns {boolean}
    */
-  has(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): boolean {
+  has(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): boolean {
     const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
     if (serverCertificateHash === undefined || serverCertificateHash === null) {
       return false;

package/src/main_thread/init/directfile_content_initializer.ts

@@ -225,7 +225,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
       cancelSignal,
     )
       .autoPlayResult.then(() =>
-        getLoadedReference(playbackObserver, mediaElement, true, cancelSignal).onUpdate(
+        getLoadedReference(playbackObserver, true, cancelSignal).onUpdate(
           (isLoaded, stopListening) => {
             if (isLoaded) {
               stopListening();

package/src/main_thread/init/media_source_content_initializer.ts

@@ -27,7 +27,9 @@ import AdaptiveRepresentationSelector from "../../core/adaptive";
 import CmcdDataBuilder from "../../core/cmcd";
 import { ManifestFetcher, SegmentQueueCreator } from "../../core/fetchers";
 import createContentTimeBoundariesObserver from "../../core/main/common/create_content_time_boundaries_observer";
-import DecipherabilityFreezeDetector from "../../core/main/common/DecipherabilityFreezeDetector";
+import type { IFreezeResolution } from "../../core/main/common/FreezeResolver";
+import FreezeResolver from "../../core/main/common/FreezeResolver";
+import synchronizeSegmentSinksOnObservation from "../../core/main/common/synchronize_sinks_on_observation";
 import SegmentSinksStore from "../../core/segment_sinks";
 import type {
   IStreamOrchestratorOptions,
@@ -51,7 +53,7 @@ import type {
 } from "../../public_types";
 import type { ITransportPipelines } from "../../transports";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
-import assert from "../../utils/assert";
+import assert, { assertUnreachable } from "../../utils/assert";
 import createCancellablePromise from "../../utils/create_cancellable_promise";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import noop from "../../utils/noop";
@@ -617,11 +619,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       (isPerformed, stopListening) => {
         if (isPerformed) {
           stopListening();
-          const streamEventsEmitter = new StreamEventsEmitter(
-            manifest,
-            mediaElement,
-            playbackObserver,
-          );
+          const streamEventsEmitter = new StreamEventsEmitter(manifest, playbackObserver);
           manifest.addEventListener(
             "manifestUpdate",
             () => {
@@ -676,9 +674,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       speed,
       cancelSignal,
     );
-    const decipherabilityFreezeDetector = new DecipherabilityFreezeDetector(
-      segmentSinksStore,
-    );
+    const freezeResolver = new FreezeResolver(segmentSinksStore);
 
     if (mayMediaElementFailOnUndecipherableData) {
       // On some devices, just reload immediately when data become undecipherable
@@ -693,36 +689,32 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       );
     }
 
-    playbackObserver.listen(
+    coreObserver.listen(
       (observation) => {
-        if (decipherabilityFreezeDetector.needToReload(observation)) {
-          let position: number;
-          const lastObservation = playbackObserver.getReference().getValue();
-          if (lastObservation.position.isAwaitingFuturePosition()) {
-            position = lastObservation.position.getWanted();
-          } else {
-            position = playbackObserver.getCurrentTime();
-          }
+        synchronizeSegmentSinksOnObservation(observation, segmentSinksStore);
+        const freezeResolution = freezeResolver.onNewObservation(observation);
+        if (freezeResolution === null) {
+          return;
+        }
 
+        // TODO: The following method looks generic, we may be able to factorize
+        // it with other reload handlers after some work.
+        const triggerReload = () => {
+          const lastObservation = playbackObserver.getReference().getValue();
+          const position = lastObservation.position.isAwaitingFuturePosition()
+            ? lastObservation.position.getWanted()
+            : (coreObserver.getCurrentTime() ?? lastObservation.position.getPolled());
           const autoplay = initialPlayPerformed.getValue()
             ? !playbackObserver.getIsPaused()
             : autoPlay;
           onReloadOrder({ position, autoPlay: autoplay });
-        }
-      },
-      { clearSignal: cancelSignal },
-    );
+        };
 
-    // Synchronize SegmentSinks with what has been buffered.
-    coreObserver.listen(
-      (observation) => {
-        ["video" as const, "audio" as const, "text" as const].forEach((tType) => {
-          const segmentSinkStatus = segmentSinksStore.getStatus(tType);
-          if (segmentSinkStatus.type === "initialized") {
-            segmentSinkStatus.value.synchronizeInventory(
-              observation.buffered[tType] ?? [],
-            );
-          }
+        handleFreezeResolution(freezeResolution, {
+          enableRepresentationAvoidance: this._initSettings.enableRepresentationAvoidance,
+          manifest,
+          triggerReload,
+          playbackObserver,
         });
       },
       { clearSignal: cancelSignal },
@@ -748,7 +740,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
      */
     autoPlayResult
       .then(() => {
-        getLoadedReference(playbackObserver, mediaElement, false, cancelSignal).onUpdate(
+        getLoadedReference(playbackObserver, false, cancelSignal).onUpdate(
           (isLoaded, stopListening) => {
             if (isLoaded) {
               stopListening();
@@ -793,7 +785,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       return {
         needsBufferFlush: (payload?: INeedsBufferFlushPayload) => {
           let wantedSeekingTime: number;
-          const currentTime = playbackObserver.getCurrentTime();
+          const lastObservation = playbackObserver.getReference().getValue();
+          const currentTime = lastObservation.position.isAwaitingFuturePosition()
+            ? lastObservation.position.getWanted()
+            : mediaElement.currentTime;
           const relativeResumingPosition = payload?.relativeResumingPosition ?? 0;
           const canBeApproximateSeek = Boolean(payload?.relativePosHasBeenDefaulted);
 
@@ -917,7 +912,10 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
-          self.trigger("periodStreamCleared", value);
+          self.trigger("periodStreamCleared", {
+            type: value.type,
+            periodId: value.period.id,
+          });
         },
 
         bitrateEstimateChange: (value) => {
@@ -1176,6 +1174,12 @@ export interface IInitializeArguments {
    * When set to an object, enable "Common Media Client Data", or "CMCD".
    */
   cmcd?: ICmcdOptions | undefined;
+  /**
+   * If `true`, the RxPlayer can enable its "Representation avoidance"
+   * mechanism, where it avoid loading Representation that it suspect
+   * have issues being decoded on the current device.
+   */
+  enableRepresentationAvoidance: boolean;
   /** Every encryption configuration set. */
   keySystems: IKeySystemOption[];
   /** `true` to play low-latency contents optimally. */
@@ -1365,3 +1369,61 @@ type IReloadMediaSourceCallback = (reloadOrder: {
   position: number;
   autoPlay: boolean;
 }) => void;
+
+/**
+ * Handle accordingly an `IFreezeResolution` object.
+ * @param {Object|null} freezeResolution - The `IFreezeResolution` suggested.
+ * @param {Object} param - Parameters that might be needed to implement the
+ * resolution.
+ * @param {Object} param.manifest - The current content's Manifest object.
+ * @param {Object} param.playbackObserver - Object regularly emitting playback
+ * conditions.
+ * @param {Function} param.triggerReload - Function to call if we need to ask
+ * for a "MediaSource reload".
+ * @param {Boolean} param.enableRepresentationAvoidance - If `true`, this
+ * function is authorized to mark `Representation` as "to avoid" if the
+ * `IFreezeResolution` object suggest it.
+ */
+function handleFreezeResolution(
+  freezeResolution: IFreezeResolution,
+  {
+    playbackObserver,
+    enableRepresentationAvoidance,
+    manifest,
+    triggerReload,
+  }: {
+    playbackObserver: IMediaElementPlaybackObserver;
+    enableRepresentationAvoidance: boolean;
+    manifest: IManifest;
+    triggerReload: () => void;
+  },
+): void {
+  switch (freezeResolution.type) {
+    case "reload": {
+      log.info("Init: Planning reload due to freeze");
+      triggerReload();
+      break;
+    }
+    case "flush": {
+      log.info("Init: Flushing buffer due to freeze");
+      const observation = playbackObserver.getReference().getValue();
+      const currentTime = observation.position.isAwaitingFuturePosition()
+        ? observation.position.getWanted()
+        : playbackObserver.getCurrentTime();
+      const relativeResumingPosition = freezeResolution.value.relativeSeek;
+      const wantedSeekingTime = currentTime + relativeResumingPosition;
+      playbackObserver.setCurrentTime(wantedSeekingTime);
+      break;
+    }
+    case "avoid-representations": {
+      const contents = freezeResolution.value;
+      if (enableRepresentationAvoidance) {
+        manifest.addRepresentationsToAvoid(contents);
+      }
+      triggerReload();
+      break;
+    }
+    default:
+      assertUnreachable(freezeResolution);
+  }
+}

package/src/main_thread/init/multi_thread_content_initializer.ts

@@ -173,6 +173,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
       value: {
         contentId,
         cmcd: this._settings.cmcd,
+        enableRepresentationAvoidance: this._settings.enableRepresentationAvoidance,
         url: this._settings.url,
         hasText: this._hasTextBufferFeature(),
         transportOptions,
@@ -690,7 +691,10 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           if (this._currentContentInfo?.contentId !== msgData.contentId) {
             return;
           }
-          const currentTime = mediaElement.currentTime;
+          const lastObservation = playbackObserver.getReference().getValue();
+          const currentTime = lastObservation.position.isAwaitingFuturePosition()
+            ? lastObservation.position.getWanted()
+            : mediaElement.currentTime;
           const relativeResumingPosition = msgData.value?.relativeResumingPosition ?? 0;
           const canBeApproximateSeek = Boolean(
             msgData.value?.relativePosHasBeenDefaulted,
@@ -969,15 +973,8 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
           ) {
             return;
           }
-          const period = arrayFind(
-            this._currentContentInfo.manifest.periods,
-            (p) => p.id === msgData.value.periodId,
-          );
-          if (period === undefined) {
-            return;
-          }
           this.trigger("periodStreamCleared", {
-            period,
+            periodId: msgData.value.periodId,
             type: msgData.value.bufferType,
           });
           break;
@@ -1563,11 +1560,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
       (isPerformed, stopListening) => {
         if (isPerformed) {
           stopListening();
-          const streamEventsEmitter = new StreamEventsEmitter(
-            manifest,
-            mediaElement,
-            playbackObserver,
-          );
+          const streamEventsEmitter = new StreamEventsEmitter(manifest, playbackObserver);
           currentContentInfo.streamEventsEmitter = streamEventsEmitter;
           streamEventsEmitter.addEventListener(
             "event",
@@ -1625,7 +1618,7 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
      */
     autoPlayResult
       .then(() => {
-        getLoadedReference(playbackObserver, mediaElement, false, cancelSignal).onUpdate(
+        getLoadedReference(playbackObserver, false, cancelSignal).onUpdate(
           (isLoaded, stopListening) => {
             if (isLoaded) {
               stopListening();
@@ -1909,6 +1902,12 @@ export interface IInitializeArguments {
    * When set to an object, enable "Common Media Client Data", or "CMCD".
    */
   cmcd?: ICmcdOptions | undefined;
+  /**
+   * If `true`, the RxPlayer can enable its "Representation avoidance"
+   * mechanism, where it avoid loading Representation that it suspect
+   * have issues being decoded on the current device.
+   */
+  enableRepresentationAvoidance: boolean;
   /** Every encryption configuration set. */
   keySystems: IKeySystemOption[];
   /** `true` to play low-latency contents optimally. */

package/src/main_thread/init/types.ts

@@ -192,12 +192,13 @@ export interface IContentInitializerEvents {
      */
     type: IBufferType;
     /**
-     * The `Period` linked to the `PeriodStream` we just removed.
+     * The `id` property of the `Period` linked to the `PeriodStream` we just
+     * removed.
      *
      * The combination of this and `Period` should give you enough information
      * about which `PeriodStream` has been removed.
      */
-    period: IPeriodMetadata;
+    periodId: string;
   };
   /** Emitted when a new `Adaptation` is being considered. */
   adaptationChange: IAdaptationChangeEventPayload;

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

@@ -92,6 +92,8 @@ export interface ICorePlaybackObservation {
    *  to be buffered at this time.
    */
   canStream: boolean;
+  /** If `true` the content is loaded until its maximum position. */
+  fullyLoaded: boolean;
 }
 
 /**
@@ -170,6 +172,7 @@ export default function createCorePlaybackObserver(
         readyState: observation.readyState,
         speed: lastSpeed,
         canStream: mediaSource?.streaming ?? true,
+        fullyLoaded: observation.fullyLoaded,
       };
     }
 

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

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import shouldValidateMetadata from "../../../compat/should_validate_metadata";
 import shouldWaitForDataBeforeLoaded from "../../../compat/should_wait_for_data_before_loaded";
 import shouldWaitForHaveEnoughData from "../../../compat/should_wait_for_have_enough_data";
@@ -31,14 +30,12 @@ import TaskCanceller from "../../../utils/task_canceller";
  * Returns an `IReadOnlySharedReference` that switches to `true` once the
  * content is considered loaded (i.e. once it can begin to be played).
  * @param {Object} playbackObserver
- * @param {HTMLMediaElement} mediaElement
  * @param {boolean} isDirectfile - `true` if this is a directfile content
  * @param {Object} cancelSignal
  * @returns {Object}
  */
 export default function getLoadedReference(
   playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>,
-  mediaElement: IMediaElement,
   isDirectfile: boolean,
   cancelSignal: CancellationSignal,
 ): IReadOnlySharedReference<boolean> {
@@ -58,10 +55,10 @@ export default function getLoadedReference(
       if (!shouldWaitForDataBeforeLoaded(isDirectfile)) {
         // The duration is NaN if no media data is available,
         // which means media is not loaded yet.
-        if (isNaN(mediaElement.duration)) {
+        if (isNaN(observation.duration)) {
           return;
         }
-        if (mediaElement.duration > 0) {
+        if (observation.duration > 0) {
           isLoaded.setValue(true);
           listenCanceller.cancel();
           return;
@@ -71,7 +68,7 @@ export default function getLoadedReference(
       const minReadyState = shouldWaitForHaveEnoughData() ? 4 : 3;
       if (observation.readyState >= minReadyState) {
         if (observation.currentRange !== null || observation.ended) {
-          if (!shouldValidateMetadata() || mediaElement.duration > 0) {
+          if (!shouldValidateMetadata() || observation.duration > 0) {
             isLoaded.setValue(true);
             listenCanceller.cancel();
             return;

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

@@ -96,36 +96,16 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
       playbackRateUpdater.dispose();
     });
 
-    let prevFreezingState: { attemptTimestamp: number } | null = null;
-
     this._playbackObserver.listen(
       (observation) => {
         const discontinuitiesStore = this._discontinuitiesStore;
         const { buffered, position, readyState, rebuffering, freezing } = observation;
 
-        const {
-          BUFFER_DISCONTINUITY_THRESHOLD,
-          FREEZING_STALLED_DELAY,
-          UNFREEZING_SEEK_DELAY,
-          UNFREEZING_DELTA_POSITION,
-        } = config.getCurrent();
+        const { BUFFER_DISCONTINUITY_THRESHOLD, FREEZING_STALLED_DELAY } =
+          config.getCurrent();
 
         if (freezing !== null) {
           const now = getMonotonicTimeStamp();
-
-          const referenceTimestamp =
-            prevFreezingState === null
-              ? freezing.timestamp
-              : prevFreezingState.attemptTimestamp;
-
-          if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
-            log.warn("Init: trying to seek to un-freeze player");
-            this._playbackObserver.setCurrentTime(
-              observation.position.getWanted() + UNFREEZING_DELTA_POSITION,
-            );
-            prevFreezingState = { attemptTimestamp: now };
-          }
-
           if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
             if (rebuffering === null) {
               playbackRateUpdater.stopRebuffering();
@@ -135,8 +115,6 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
             this.trigger("stalled", "freezing");
             return;
           }
-        } else {
-          prevFreezingState = null;
         }
 
         if (rebuffering === null) {

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

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../../../compat/browser_compatibility_types";
 import config from "../../../../config";
 import type { IManifestMetadata } from "../../../../manifest";
 import { SeekingState } from "../../../../playback_observer";
@@ -44,7 +43,6 @@ interface IStreamEventsEmitterEvent {
  */
 export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitterEvent> {
   private _manifest: IManifestMetadata;
-  private _mediaElement: IMediaElement;
   private _playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>;
   private _scheduledEventsRef: SharedReference<
     Array<IStreamEventPayload | INonFiniteStreamEventPayload>
@@ -57,17 +55,14 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
 
   /**
    * @param {Object} manifest
-   * @param {HTMLMediaElement} mediaElement
    * @param {Object} playbackObserver
    */
   constructor(
     manifest: IManifestMetadata,
-    mediaElement: IMediaElement,
     playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>,
   ) {
     super();
     this._manifest = manifest;
-    this._mediaElement = mediaElement;
     this._playbackObserver = playbackObserver;
     this._canceller = null;
     this._scheduledEventsRef = new SharedReference<
@@ -87,7 +82,6 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
 
     const cancelSignal = this._canceller.signal;
     const playbackObserver = this._playbackObserver;
-    const mediaElement = this._mediaElement;
 
     let isPollingEvents = false;
     let cancelCurrentPolling = new TaskCanceller();
@@ -137,7 +131,9 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
 
         function constructObservation() {
           const lastObservation = playbackObserver.getReference().getValue();
-          const currentTime = mediaElement.currentTime;
+          const currentTime =
+            playbackObserver.getCurrentTime() ??
+            playbackObserver.getReference().getValue().position.getPolled();
           const isSeeking = lastObservation.seeking !== SeekingState.None;
           return { currentTime, isSeeking };
         }

package/src/main_thread/tracks_store/tracks_store.ts

@@ -363,6 +363,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     period: IPeriodMetadata,
     adaptationRef: SharedReference<IAdaptationChoice | null | undefined>,
   ): void {
+    log.debug("TS: Adding Track Reference", bufferType, period.id);
     let periodObj = getPeriodItem(this._storedPeriodInfo, period.id);
     if (periodObj === undefined) {
       // The Period has not yet been added.
@@ -383,7 +384,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       log.error(
         `TS: Subject already added for ${bufferType} ` + `and Period ${period.start}`,
       );
-      return;
+      periodObj[bufferType].dispatcher.dispose();
     }
 
     const dispatcher = new TrackDispatcher(adaptationRef);
@@ -496,15 +497,23 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * Remove shared reference to choose an "audio", "video" or "text" Adaptation
    * for a Period.
    * @param {string} bufferType - The concerned buffer type
-   * @param {Period} period - The concerned Period.
+   * @param {string} periodId - The concerned Period's `id`.
    */
   public removeTrackReference(
     bufferType: "audio" | "text" | "video",
-    period: IPeriodMetadata,
+    periodId: string,
   ): void {
-    const periodIndex = findPeriodIndex(this._storedPeriodInfo, period);
+    log.debug("TS: Removing Track Reference", bufferType, periodId);
+    let periodIndex;
+    for (let i = 0; i < this._storedPeriodInfo.length; i++) {
+      const periodI = this._storedPeriodInfo[i];
+      if (periodI.period.id === periodId) {
+        periodIndex = i;
+        break;
+      }
+    }
     if (periodIndex === undefined) {
-      log.warn(`TS: ${bufferType} not found for period`, period.start);
+      log.warn(`TS: ${bufferType} not found for period`, periodId);
       return;
     }
 
@@ -513,7 +522,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     if (choiceItem?.dispatcher === null) {
       log.warn(
         `TS: TrackDispatcher already removed for ${bufferType} ` +
-          `and Period ${period.start}`,
+          `and Period ${periodId}`,
       );
       return;
     }
@@ -593,6 +602,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * You might want to call this API when restarting playback.
    */
   public resetPeriodObjects(): void {
+    log.debug("TS: Resetting Period Objects");
     for (let i = this._storedPeriodInfo.length - 1; i >= 0; i--) {
       const storedObj = this._storedPeriodInfo[i];
       storedObj.audio.dispatcher?.dispose();
@@ -1378,26 +1388,6 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   }
 }
 
-/**
- * Returns the index of the given `period` in the given `periods`
- * Array.
- * Returns `undefined` if that `period` is not found.
- * @param {Object} periods
- * @param {Object} period
- * @returns {number|undefined}
- */
-function findPeriodIndex(
-  periods: ITSPeriodObject[],
-  period: IPeriodMetadata,
-): number | undefined {
-  for (let i = 0; i < periods.length; i++) {
-    const periodI = periods[i];
-    if (periodI.period.id === period.id) {
-      return i;
-    }
-  }
-}
-
 /**
  * Returns element in the given `periods` Array that corresponds to the
  * `period` given.